diff --git a/jaxsw/_src/domain/base.py b/jaxsw/_src/domain/base.py index dfbfb55..b1287a1 100644 --- a/jaxsw/_src/domain/base.py +++ b/jaxsw/_src/domain/base.py @@ -82,13 +82,22 @@ def ndim(self) -> int: def size(self) -> tp.Tuple[int]: return tuple(map(len, self.coords)) + @property + def Nx(self) -> tp.Tuple[int]: + return self.size + + @property + def Lx(self) -> tp.Tuple[int]: + f = lambda xmin, xmax: xmax - xmin + return tuple(map(f, self.xmin, self.xmax)) + @property def cell_volume(self) -> float: return reduce(mul, self.dx) def make_coords(xmin, xmax, delta): - return jnp.arange(xmin, xmax, delta) + return jnp.arange(xmin, xmax + delta, delta) def make_grid_from_coords(coords: tp.Iterable) -> Float[Array, " D"]: diff --git a/jaxsw/_src/domain/qg.py b/jaxsw/_src/domain/qg.py new file mode 100644 index 0000000..e771464 --- /dev/null +++ b/jaxsw/_src/domain/qg.py @@ -0,0 +1,90 @@ +import typing as tp +import equinox as eqx +import jax.numpy as jnp +import numpy as np +from jaxtyping import Array + + +class LayerDomain(eqx.Module): + heights: Array = eqx.static_field() + reduced_gravities: Array = eqx.static_field() + Nz: float = eqx.static_field() + A: Array = eqx.static_field() + A_layer_2_mode: Array = eqx.static_field() + A_mode_2_layer: Array = eqx.static_field() + lambd: Array = eqx.static_field() + + def __init__(self, heights: tp.List[float], reduced_gravities: tp.List[float]): + num_layers = len(heights) + + msg = "Incorrect number of heights to reduced gravities." + msg += f"\nHeights: {heights} | {num_layers}" + msg += f"\nReduced Gravities: {reduced_gravities} | {len(reduced_gravities)}" + assert num_layers - 1 == len(reduced_gravities), msg + + self.heights = jnp.asarray(heights) + self.reduced_gravities = jnp.asarray(reduced_gravities) + self.Nz = num_layers + + # calculate matrix M + A = create_qg_multilayer_mat(heights, reduced_gravities) + self.A = jnp.asarray(A) + + # create layer to mode matrices + lambd, A_layer_2_mode, A_mode_2_layer = compute_layer_to_mode_matrices(A) + self.lambd = jnp.asarray(lambd) + self.A_layer_2_mode = jnp.asarray(A_layer_2_mode) + self.A_mode_2_layer = jnp.asarray(A_mode_2_layer) + + +def create_qg_multilayer_mat( + heights: tp.List[float], reduced_gravities: tp.List[float] +) -> np.ndarray: + """Computes the Matrix that is used to connected a stacked + isopycnal Quasi-Geostrophic model. + + Args: + heights (tp.List[float]): the height for each layer + Size = [Nx] + reduced_gravities (tp.List[float]): the reduced gravities + for each layer, Size = [Nx-1] + + Returns: + np.ndarray: The Matrix connecting the layers, Size = [Nz, Nx] + """ + num_heights = len(heights) + + # initialize matrix + A = np.zeros((num_heights, num_heights)) + + # top rows + A[0, 0] = 1.0 / (heights[0] * reduced_gravities[0]) + A[0, 1] = -1.0 / (heights[0] * reduced_gravities[0]) + + # interior rows + for i in range(1, num_heights - 1): + A[i, i - 1] = -1.0 / (heights[i] * reduced_gravities[i - 1]) + A[i, i] = ( + 1.0 / heights[i] * (1 / reduced_gravities[i] + 1 / reduced_gravities[i - 1]) + ) + A[i, i + 1] = -1.0 / (heights[i] * reduced_gravities[num_heights - 2]) + + # bottom rows + A[-1, -1] = 1.0 / (heights[num_heights - 1] * reduced_gravities[num_heights - 2]) + A[-1, -2] = -1.0 / (heights[num_heights - 1] * reduced_gravities[num_heights - 2]) + return A + + +def compute_layer_to_mode_matrices(A): + # eigenvalue decomposition + lambd_r, R = jnp.linalg.eig(A) + _, L = jnp.linalg.eig(A.T) + + # extract real components + lambd, R, L = lambd_r.real, R.real, L.real + + # create matrices + Cl2m = np.diag(1.0 / np.diag(L.T @ R)) @ L.T + Cm2l = R + # create diagonal matrix + return lambd, -Cl2m, -Cm2l diff --git a/jaxsw/_src/domain/test_base.py b/jaxsw/_src/domain/test_base.py index 415a246..16a0b45 100644 --- a/jaxsw/_src/domain/test_base.py +++ b/jaxsw/_src/domain/test_base.py @@ -14,8 +14,8 @@ def test_1d_domain(): domain = Domain(xmin=demo.xmin, xmax=demo.xmax, dx=demo.dx) assert domain.ndim == 1 - assert domain.size == (20,) - assert domain.grid.shape == (20, 1) + assert domain.Nx == (21,) + assert domain.grid.shape == (21, 1) assert domain.cell_volume == 0.1 @@ -24,6 +24,6 @@ def test_2d_domain(): domain = Domain(xmin=demo.xmin, xmax=demo.xmax, dx=demo.dx) assert domain.ndim == 2 - assert domain.size == (20, 20) - assert domain.grid.shape == (20, 20, 2) + assert domain.Nx == (21, 21) + assert domain.grid.shape == (21, 21, 2) assert domain.cell_volume == 0.05 diff --git a/jaxsw/_src/forcing/__init__.py b/jaxsw/_src/forcing/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/jaxsw/_src/forcing/wind.py b/jaxsw/_src/forcing/wind.py new file mode 100644 index 0000000..e340c01 --- /dev/null +++ b/jaxsw/_src/forcing/wind.py @@ -0,0 +1,38 @@ +import numpy as np +from jaxsw._src.operators.functional import grid as F_grid +import finitediffx as fdx + + +def init_tau(domain, tau0: float = 2.0e-5): + """ + Args + ---- + tau0 (float): wind stress magnitude m/s^2 + default=2.0e-5""" + # initial TAU + tau = np.zeros((2, domain.Nx[0], domain.Nx[1])) + + # create staggered coordinates (y-direction) + y_coords = np.arange(domain.Nx[1]) + 0.5 + + # create tau + tau[0, :, :] = -tau0 * np.cos(2 * np.pi * (y_coords / domain.Nx[1])) + + return tau + + +def calculate_wind_forcing(tau, domain): + # move from edges to nodes + tau_x = F_grid.x_average_2D(tau[0], padding=((1, 0), (0, 0))) + tau_y = F_grid.y_average_2D(tau[1], padding=((0, 0), (1, 0))) + + # compute finite difference + dF2dX = fdx.difference( + tau_y, axis=0, step_size=domain.dx[0], accuracy=1, method="central" + ) + dF1dY = fdx.difference( + tau_x, axis=1, step_size=domain.dx[1], accuracy=1, method="central" + ) + curl_stagg = dF2dX - dF1dY + + return F_grid.center_average_2D(curl_stagg.squeeze()[1:, 1:]) diff --git a/jaxsw/_src/models/qg_louis.py b/jaxsw/_src/models/qg_louis.py new file mode 100644 index 0000000..0bb3972 --- /dev/null +++ b/jaxsw/_src/models/qg_louis.py @@ -0,0 +1,408 @@ +import typing as tp +import jax +import einops +import jax.numpy as jnp +import numpy as np +from jaxsw._src.operators.functional import grid as F_grid +from jaxsw._src.operators.functional import elliptical as F_elliptical +import equinox as eqx +from jaxtyping import Array + + +class PDEParams(tp.NamedTuple): + f0: float = 9.375e-5 # coriolis (s^-1) + beta: float = 1.754e-11 # coriolis gradient (m^-1 s^-1) + tau0: float = 2.0e-5 # wind stress magnitude m/s^2 + y0: float = 2400000.0 # m + a_2: float = 0.0 # laplacian diffusion coef (m^2/s) + a_4: float = 5.0e11 # LR # 2.0e9 # HR + bcco: float = 0.2 # boundary condition coef. (non-dim.) + delta_ek: float = 2.0 # eckman height (m) + + @property + def zfbc(self): + return self.bcco / (1.0 + 0.5 * self.bcco) + + +def create_qgml_helmholtz_matrix( + domain, heights, coriolis_param: float = 9.375e-05 +) -> Array: + # create coefficients + alpha = 1 / coriolis_param**2 + beta = einops.repeat(heights, "Nz -> Nz 1 1") + return F_elliptical.helmholtz_dst( + nx=domain.Nx[0], + ny=domain.Nx[1], + dx=domain.dx[0], + dy=domain.dx[1], + alpha=alpha, + beta=beta, + ) + + +def homogeneous_sol_layers(helmoltz_dst_mat, domain, A_mat): + beta = einops.repeat(A_mat.lambd, "Nz -> Nz 1 1") + # constant field + num_layers = helmoltz_dst_mat.shape[0] + constant_field = jnp.ones((num_layers, domain.nx, domain.ny)) / ( + domain.nx * domain.ny + ) + + s_solutions = jnp.zeros_like(constant_field) + out = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))( + constant_field[:, 1:-1, 1:-1], helmoltz_dst_mat + ) + s_solutions = s_solutions.at[:, 1:-1, 1:-1].set(out) + + homogeneous_sol = constant_field + s_solutions * beta + + return homogeneous_sol[:-1] + + +class Domain(eqx.Module): + nx: int = eqx.static_field() + ny: int = eqx.static_field() + Lx: int = eqx.static_field() + Ly: int = eqx.static_field() + dx: float = eqx.static_field() + dy: float = eqx.static_field() + x: Array = eqx.static_field() + y: Array = eqx.static_field() + + def __init__(self, nx, ny, Lx, Ly): + self.Lx = Lx + self.Ly = Ly + self.nx = nx + self.ny = ny + self.dx = Lx / (nx - 1) + self.dy = Ly / (ny - 1) + + X = jnp.linspace(0, Lx, nx) + Y = jnp.linspace(0, Ly, ny) + self.x, self.y = jnp.meshgrid(X, Y, indexing="ij") + + +class MLQGHeightMatrix(eqx.Module): + heights: Array = eqx.static_field() + reduced_gravities: Array = eqx.static_field() + A: Array = eqx.static_field() + lambd: Array = eqx.static_field() + A_layer_2_mode: Array = eqx.static_field() + A_mode_2_layer: Array = eqx.static_field() + + def __init__(self, heights: tp.List[float], reduced_gravities: tp.List[float]): + # check input values + assert len(heights) > 1 and len(reduced_gravities) > 1 + assert len(heights) - 1 == len(reduced_gravities) + + # create matrix + A = create_qg_multilayer_mat( + heights=heights, reduced_gravities=reduced_gravities + ) + + # create layer to mode matrices + lambd, C_layer_2_mat, C_mat_2_layer = compute_layer_to_mode_matrices(A) + + self.heights = jnp.asarray(heights) + self.reduced_gravities = jnp.asarray(reduced_gravities) + self.A = jnp.asarray(A) + self.lambd = jnp.asarray(lambd) + self.A_layer_2_mode = jnp.asarray(C_layer_2_mat) + self.A_mode_2_layer = jnp.asarray(C_mat_2_layer) + + def __call__(self): + return self.A + + @property + def Nz(self): + return len(self.heights) + + +def create_qg_multilayer_mat( + heights: tp.List[float], reduced_gravities: tp.List[float] +) -> np.ndarray: + """Computes the Matrix that is used to connected a stacked + isopycnal Quasi-Geostrophic model. + + Args: + heights (tp.List[float]): the height for each layer + Size = [Nx] + reduced_gravities (tp.List[float]): the reduced gravities + for each layer, Size = [Nx-1] + + Returns: + np.ndarray: The Matrix connecting the layers, Size = [Nz, Nx] + """ + num_heights = len(heights) + + # initialize matrix + A = np.zeros((num_heights, num_heights)) + + # top rows + A[0, 0] = 1.0 / (heights[0] * reduced_gravities[0]) + A[0, 1] = -1.0 / (heights[0] * reduced_gravities[0]) + + # interior rows + for i in range(1, num_heights - 1): + A[i, i - 1] = -1.0 / (heights[i] * reduced_gravities[i - 1]) + A[i, i] = ( + 1.0 / heights[i] * (1 / reduced_gravities[i] + 1 / reduced_gravities[i - 1]) + ) + A[i, i + 1] = -1.0 / (heights[i] * reduced_gravities[num_heights - 2]) + + # bottom rows + A[-1, -1] = 1.0 / (heights[num_heights - 1] * reduced_gravities[num_heights - 2]) + A[-1, -2] = -1.0 / (heights[num_heights - 1] * reduced_gravities[num_heights - 2]) + return A + + +def compute_layer_to_mode_matrices(A): + # eigenvalue decomposition + lambd_r, R = jnp.linalg.eig(A) + _, L = jnp.linalg.eig(A.T) + + # extract real components + lambd, R, L = lambd_r.real, R.real, L.real + + # create matrices + Cl2m = np.diag(1.0 / np.diag(L.T @ R)) @ L.T + Cm2l = R + # create diagonal matrix + return lambd, -Cl2m, -Cm2l + + +def compute_alpha_matrix(C, hom_sol): + Nz = C.shape[0] + # extract top layer components + M = (C[1:] - C[:-1])[: Nz - 1, : Nz - 1] * hom_sol.mean(axis=(1, 2)) + M_inv = np.linalg.inv(M) + alpha_matrix = -M_inv @ (C[1:, :-1] - C[:-1, :-1]) + return alpha_matrix + + +def init_tau(domain, tau0: float = 2.0e-5): + """ + Args + ---- + tau0 (float): wind stress magnitude m/s^2 + default=2.0e-5""" + # initial TAU + tau = np.zeros((2, domain.nx, domain.ny)) + + # create staggered coordinates (y-direction) + y_coords = np.arange(domain.ny) + 0.5 + + # create tau + tau[0, :, :] = -tau0 * np.cos(2 * np.pi * (y_coords / domain.ny)) + + return tau + + +def calculate_wind_forcing(tau, domain): + # move from edges to nodes + tau_x = F_grid.x_average_2D(tau[0]) + tau_y = F_grid.y_average_2D(tau[1]) + + # calculate curl + dF2dX = (tau_y[1:] - tau_y[:-1]) / domain.dx + dF1dY = (tau_x[:, 1:] - tau_x[:, :-1]) / domain.dy + curl_stagg = dF2dX - dF1dY + + # move from nodes to faces + return F_grid.center_average_2D(curl_stagg) + + +def calculate_A_term(A, pressure): + return -jnp.einsum("ij,jkl->ikl", A, pressure) + + +def calculate_beta_term(domain, params): + return (params.beta / params.f0) * (domain.y - 0.5 * domain.Ly) + + +def laplacian(u, constant): + delta_f = jnp.zeros_like(u) + + # calculate interior Laplacian + out = laplacian_interior(u) + delta_f = delta_f.at[..., 1:-1, 1:-1].set(out) + # calculate Laplacian at the boundaries + delta_f_bound = laplacian_boundaries(u, constant) + return _apply_boundaries(delta_f, delta_f_bound) + + +def _apply_boundaries(u, bc): + nx, ny = u.shape[-2:] + + # set the boundaries + u = u.at[..., 0, 1:-1].set(bc[..., : ny - 2]) + u = u.at[..., -1, 1:-1].set(bc[..., ny - 2 : 2 * ny - 4]) + u = u.at[..., 0].set(bc[..., 2 * ny - 4 : nx + 2 * ny - 4]) + u = u.at[..., -1].set(bc[..., nx + 2 * ny - 4 : 2 * nx + 2 * ny - 4]) + return u + + +def laplacian_interior(u, constant=0.0): + return ( + u[..., 2:, 1:-1] + + u[..., :-2, 1:-1] + + u[..., 1:-1, 2:] + + u[..., 1:-1, :-2] + - 4 * u[..., 1:-1, 1:-1] + ) + + +def laplacian_boundaries(u, constant=0.0): + return constant * ( + jnp.concatenate( + [u[..., 1, 1:-1], u[..., -2, 1:-1], u[..., 1], u[..., -2]], axis=-1 + ) + - jnp.concatenate( + [u[..., 0, 1:-1], u[..., -1, 1:-1], u[..., 0], u[..., -1]], axis=-1 + ) + ) + + +def pressure_to_vorticity(pressure, A, domain, params): + # calculate A tearm + Ap = calculate_A_term(A, pressure) + + # calculate beta term + beta_term = calculate_beta_term(domain, params) + + # calculate laplacian + lap_term = laplacian(pressure, params.zfbc) / (params.f0 * domain.dx) ** 2 + + # calculate vorticity + q = lap_term + Ap + beta_term + return q + + +## discrete spatial differential operators +def det_jacobian(f, g): + """Arakawa discretisation of Jacobian J(f,g). + Scalar fields f and g must have the same dimension. + Grid is regular and dx = dy.""" + dx_f = f[..., 2:, :] - f[..., :-2, :] + dx_g = g[..., 2:, :] - g[..., :-2, :] + dy_f = f[..., 2:] - f[..., :-2] + dy_g = g[..., 2:] - g[..., :-2] + return ( + (dx_f[..., 1:-1] * dy_g[..., 1:-1, :] - dx_g[..., 1:-1] * dy_f[..., 1:-1, :]) + + ( + ( + f[..., 2:, 1:-1] * dy_g[..., 2:, :] + - f[..., :-2, 1:-1] * dy_g[..., :-2, :] + ) + - (f[..., 1:-1, 2:] * dx_g[..., 2:] - f[..., 1:-1, :-2] * dx_g[..., :-2]) + ) + + ( + (g[..., 1:-1, 2:] * dx_f[..., 2:] - g[..., 1:-1, :-2] * dx_f[..., :-2]) + - ( + g[..., 2:, 1:-1] * dy_f[..., 2:, :] + - g[..., :-2, 1:-1] * dy_f[..., :-2, :] + ) + ) + ) / 12.0 + + +def advection_term(q, p, params, domain): + return (1.0 / (params.f0 * domain.dx * domain.dy)) * det_jacobian(q, p) + + +def diffusion_term(p, params, domain): + return params.a_2 / params.f0**2 / domain.dx**4 * laplacian_interior(p) + + +def hyperdiffusion_term(p, params, domain): + return ( + -(params.a_4 / params.f0**2) + / domain.dx**6 + * laplacian_interior(laplacian(p, params.zfbc)) + ) + + +def bottom_friction(p, params, domain, height_params): + return ( + params.delta_ek + / (2 * np.abs(params.f0) * domain.dx**2 * (-height_params.heights[-1])) + * laplacian_interior(p[..., -1:, :, :]) + ) + + +def rhs_pde(q, p, params, domain, A_mat, wind_forcing): + # Calculate Determinant Jacobian + rhs = advection_term(q, p, params, domain) + + # calculate Laplacian + delta2_p = laplacian(p, params.zfbc) + + # Add Diffusion Term + if params.a_2 != 0.0: + rhs += diffusion_term(delta2_p, params, domain) + + # Add HyperDiffusion + if params.a_4 != 0.0: + rhs += hyperdiffusion_term(delta2_p, params, domain) + + # Add Wind Forcing + rhs = rhs.at[..., 0:1, :, :].set(rhs[..., 0:1, :, :] + wind_forcing) + + # Add Bottom Friction + bottom_term = bottom_friction(p, params, domain, A_mat) + + rhs = rhs.at[..., -1:, :, :].set(rhs[..., -1:, :, :] + bottom_term) + + return rhs + + +class QGARGS(eqx.Module): + A_mat: MLQGHeightMatrix + domain: Domain + wind_forcing: Array = eqx.static_field() + helmoltz_dst: Array = eqx.static_field() + alpha_matrix: Array = eqx.static_field() + homogeneous_sol: Array = eqx.static_field() + + +def rhs_time_step(q, p, params, args: QGARGS): + # calculate advection - interior only + dq_f0 = rhs_pde( + q, + p, + params=params, + domain=args.domain, + A_mat=args.A_mat, + wind_forcing=args.wind_forcing, + ) + # pad - original domain + dq_f0 = jnp.pad(dq_f0, ((0, 0), (1, 1), (1, 1))) + + # pressure + rhs_helmholtz = jnp.einsum("ij,jkl->ikl", args.A_mat.A_layer_2_mode, dq_f0) + dp_modes = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))( + rhs_helmholtz[:, 1:-1, 1:-1], args.helmoltz_dst + ) + # pad - original domain + dp_modes = jnp.pad(dp_modes, ((0, 0), (1, 1), (1, 1))) + + # ensure mass conservation + dalpha = args.alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1)) + dalpha = einops.repeat(dalpha, "i -> i 1 1") + dp_modes = dp_modes.at[..., :-1, :, :].set( + dp_modes[..., :-1, :, :] + dalpha * args.homogeneous_sol + ) + dp = jnp.einsum("ij,jkl->ikl", args.A_mat.A_mode_2_layer, dp_modes) + + # UPDATE VORTICITY @ BOUNDARIES + delta_p_boundaries = laplacian_boundaries( + dp / (params.f0 * args.domain.dx) ** 2, params.zfbc + ) + dp_boundaries = jnp.concatenate( + [dp[..., 0, 1:-1], dp[..., -1, 1:-1], dp[..., :, 0], dp[..., :, -1]], axis=-1 + ) + dq_f0_boundaries = delta_p_boundaries - args.A_mat.A @ dp_boundaries + + dq_f0 = _apply_boundaries(dq_f0, dq_f0_boundaries) + + return dq_f0, dp diff --git a/jaxsw/_src/models/qg_ml.py b/jaxsw/_src/models/qg_ml.py new file mode 100644 index 0000000..5957193 --- /dev/null +++ b/jaxsw/_src/models/qg_ml.py @@ -0,0 +1,227 @@ +import typing as tp +import jax +import einops +import jax.numpy as jnp +import numpy as np +from jaxsw._src.operators.functional import elliptical as F_elliptical +from jaxsw._src.operators.functional.advection import det_jacobian +from jaxsw._src.domain.base import Domain +from jaxsw._src.domain.qg import LayerDomain +import equinox as eqx +import finitediffx as fdx +from jaxtyping import Array + + +class PDEParams(eqx.Module): + f0: float = 9.375e-5 # coriolis (s^-1) + beta: float = 1.754e-11 # coriolis gradient (m^-1 s^-1) + tau0: float = 2.0e-5 # wind stress magnitude m/s^2 + y0: float = 2400000.0 # m + a_2: float = 0.0 # laplacian diffusion coef (m^2/s) + a_4: float = 5.0e11 # LR # 2.0e9 # HR + bcco: float = 0.2 # boundary condition coef. (non-dim.) + delta_ek: float = 2.0 # eckman height (m) + + @property + def zfbc(self): + return self.bcco / (1.0 + 0.5 * self.bcco) + + +class QGState(tp.NamedTuple): + q: Array + p: Array + + +class QGARGS(eqx.Module): + domain: Domain = eqx.static_field() + layer_domain: LayerDomain = eqx.static_field() + wind_forcing: Array = eqx.static_field() + helmoltz_dst_mat: Array = eqx.static_field() + alpha_matrix: Array = eqx.static_field() + homogeneous_sol: Array = eqx.static_field() + bc_fn: tp.Callable + + +def create_qgml_helmholtz_matrix( + domain, heights, coriolis_param: float = 9.375e-05 +) -> Array: + # create coefficients + alpha = 1 / coriolis_param**2 + beta = einops.repeat(heights, "Nz -> Nz 1 1") + return F_elliptical.helmholtz_dst( + nx=domain.Nx[0], + ny=domain.Nx[1], + dx=domain.dx[0], + dy=domain.dx[1], + alpha=alpha, + beta=beta, + ) + + +def helmholtz_homogeneous_sol_multilayer(helmoltz_dst_mat, heights, domain): + num_layers = len(heights) + assert len(helmoltz_dst_mat.shape) == 3 + + # inversion scheme (interior points) + # (nabla_H - beta) s = L + # constant field (where did we get this???) + constant_field = jnp.ones((num_layers, domain.Nx[0], domain.Nx[1])) / ( + domain.Nx[0] * domain.Nx[1] + ) + + out = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))( + constant_field[:, 1:-1, 1:-1], helmoltz_dst_mat + ) + + # construct s (interior points) + s_solutions = jnp.zeros_like(constant_field) + s_solutions = s_solutions.at[:, 1:-1, 1:-1].set(out) + + # add the boundary: p = L + beta * s + beta = einops.repeat(heights, "Nz -> Nz 1 1") + homogeneous_sol = constant_field + beta * s_solutions + + # ignore last solution correponding to lambd = 0, i.e. Laplace equation + return homogeneous_sol[:-1] + + +def compute_alpha_matrix(A_mode_2_layer, hom_sol): + Nz = A_mode_2_layer.shape[0] + # extract top layer components + M = (A_mode_2_layer[1:] - A_mode_2_layer[:-1])[: Nz - 1, : Nz - 1] * hom_sol.mean( + axis=(1, 2) + ) + M_inv = np.linalg.inv(M) + alpha_matrix = -M_inv @ (A_mode_2_layer[1:, :-1] - A_mode_2_layer[:-1, :-1]) + return alpha_matrix + + +def custom_boundaries(u, constant): + # Top-Down (Channel) + u = u.at[..., 0].set(constant * (u[..., 1] - u[..., 0])) + u = u.at[..., -1].set(constant * (u[..., -2] - u[..., -1])) + # Left-Right + u = u.at[..., 0, 1:-1].set(constant * (u[..., 1, 1:-1] - u[..., 0, 1:-1])) + u = u.at[..., -1, 1:-1].set(constant * (u[..., -2, 1:-1] - u[..., -1, 1:-1])) + return u + + +def apply_boundaries(u, bc, constant=1.0): + # Top-Down (Channel) + u = u.at[..., 0].set(constant * bc[..., 0]) + u = u.at[..., -1].set(constant * bc[..., -1]) + # Left-Right + u = u.at[..., 0, 1:-1].set(constant * bc[..., 0, 1:-1]) + u = u.at[..., -1, 1:-1].set(constant * bc[..., -1, 1:-1]) + return u + + +def pressure_to_vorticity(pressure, bc_fn: tp.Callable, A, params, domain): + # Calculate Node Term + Ap_term = -jnp.einsum("ij,jkl->ikl", A, pressure) + # print_debug_quantity(Ap_term, "Ap_term") + + # ============================= + # calculate Laplacian (interior) + lap_term = jnp.zeros_like(pressure) + accuracy = 1 + fn = lambda x: fdx.laplacian( + x, accuracy=accuracy, step_size=domain.dx, method="central" + ) + lap_term = lap_term.at[..., 1:-1, 1:-1].set(jax.vmap(fn)(pressure)[..., 1:-1, 1:-1]) + lap_term /= params.f0**2 # scale factor + + lap_term = bc_fn(lap_term) # apply boundary conditions + + # Calculate Beta Term + beta_term = (params.beta / params.f0) * (domain.grid[..., 1] - 0.5 * domain.Lx[1]) + + return Ap_term + lap_term + beta_term + + +def rhs_pde( + q, p, bc_fn, params, layer_domain, domain, wind_forcing: tp.Optional[Array] = None +): + rhs = jnp.zeros_like(p) + + # create Laplacian function + laplacian = lambda x: fdx.laplacian( + x, accuracy=1, step_size=domain.dx, method="central" + ) + vectorized_laplacian = jax.vmap(laplacian) + + # laplacian + lap_p = vectorized_laplacian(p) + lap_p = custom_boundaries(lap_p, params.zfbc) + + # ADVECTION TERM (Interior) + rhs = (1 / params.f0) * det_jacobian(q, p, domain.dx[0], domain.dx[1]) + + # DIFFUSION TERM + if params.a_2 != 0.0: + rhs_diff = (params.a_2 / params.f0**2) * vectorized_laplacian(lap_p) + rhs += rhs_diff[..., 1:-1, 1:-1] + + # HYPERDIFFUSION TERM + if params.a_4 != 0.0: + lap2_p = vectorized_laplacian(lap_p) + lap2_p = custom_boundaries(lap2_p, params.zfbc) + rhs_hyperdiff = -(params.a_4 / params.f0**2) * vectorized_laplacian(lap2_p) + rhs += rhs_hyperdiff[..., 1:-1, 1:-1] + + # WIND FORCING + if wind_forcing is not None: + rhs = rhs.at[..., 0, :, :].set(rhs[..., 0, :, :] + wind_forcing) + + # BOTTOM FRICTION + coeff = params.delta_ek / (2 * jnp.abs(params.f0) * (-layer_domain.heights[-1])) + rhs_bottom = coeff * laplacian(p[..., -1, 1:-1, 1:-1]) + # print_debug_quantity(rhs_bottom[..., 1:-1, 1:-1], "BOTTOM FRICTION") + rhs = rhs.at[..., -1, :, :].set(rhs[..., -1, :, :] + rhs_bottom) + + return rhs + + +def pde_time_step(p, q, params, args): + # unpack state + + # RHS of PDE for Q (INTERIOR) + dq_f0 = rhs_pde( + q, + p, + bc_fn=args.bc_fn, + params=params, + layer_domain=args.layer_domain, + domain=args.domain, + wind_forcing=args.wind_forcing, + ) + # pad for original domain + dq_f0 = jnp.pad(dq_f0, ((0, 0), (1, 1), (1, 1))) + + # PRESSURE (INTERIOR) + rhs_helmholtz = jnp.einsum("ij,jkl->ikl", args.layer_domain.A_layer_2_mode, dq_f0) + dp_modes = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))( + rhs_helmholtz[:, 1:-1, 1:-1], args.helmoltz_dst_mat + ) + + dp_modes = jnp.pad(dp_modes, ((0, 0), (1, 1), (1, 1))) + + # ensure mass conservation + dalpha = args.alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1)) + dalpha = einops.repeat(dalpha, "i -> i 1 1") + + dp_modes = dp_modes.at[..., :-1, :, :].set( + dp_modes[..., :-1, :, :] + dalpha * args.homogeneous_sol + ) + dp = jnp.einsum("ij,jkl->ikl", args.layer_domain.A_mode_2_layer, dp_modes) + + delta_p_boundaries = args.bc_fn(dp / (params.f0 * args.domain.dx[0]) ** 2) + + # apply boundaries + dq_f0_boundaries = delta_p_boundaries - jnp.einsum( + "ij,jkl->ikl", args.layer_domain.A, dp + ) + + dq_f0 = apply_boundaries(dq_f0, dq_f0_boundaries) + + return dp, dq_f0 diff --git a/jaxsw/_src/operators/functional/advection.py b/jaxsw/_src/operators/functional/advection.py index 7a61d9c..380540d 100644 --- a/jaxsw/_src/operators/functional/advection.py +++ b/jaxsw/_src/operators/functional/advection.py @@ -342,3 +342,30 @@ def plusminus( u_plus = way * fn(way * u) u_minus = -1.0 * way * fn(-1.0 * way * u) return u_plus, u_minus + + +def det_jacobian(f, g, dx, dy): + """Arakawa discretisation of Jacobian J(f,g). + Scalar fields f and g must have the same dimension. + Grid is regular and dx = dy.""" + dx_f = f[..., 2:, :] - f[..., :-2, :] + dx_g = g[..., 2:, :] - g[..., :-2, :] + dy_f = f[..., 2:] - f[..., :-2] + dy_g = g[..., 2:] - g[..., :-2] + return ( + (dx_f[..., 1:-1] * dy_g[..., 1:-1, :] - dx_g[..., 1:-1] * dy_f[..., 1:-1, :]) + + ( + ( + f[..., 2:, 1:-1] * dy_g[..., 2:, :] + - f[..., :-2, 1:-1] * dy_g[..., :-2, :] + ) + - (f[..., 1:-1, 2:] * dx_g[..., 2:] - f[..., 1:-1, :-2] * dx_g[..., :-2]) + ) + + ( + (g[..., 1:-1, 2:] * dx_f[..., 2:] - g[..., 1:-1, :-2] * dx_f[..., :-2]) + - ( + g[..., 2:, 1:-1] * dy_f[..., 2:, :] + - g[..., :-2, 1:-1] * dy_f[..., :-2, :] + ) + ) + ) / (12.0 * dx * dy) diff --git a/jaxsw/_src/operators/functional/dst.py b/jaxsw/_src/operators/functional/dst.py new file mode 100644 index 0000000..c83ea05 --- /dev/null +++ b/jaxsw/_src/operators/functional/dst.py @@ -0,0 +1,75 @@ +from typing import Union + +import jax.numpy as jnp +from jaxtyping import Array + + +def dstI1D(x, norm="ortho"): + """1D type-I discrete sine transform.""" + return jnp.fft.irfft(-1j * jnp.pad(x, (1, 1)), axis=-1, norm=norm)[ + 1 : x.shape[0] + 1, 1 : x.shape[1] + 1 + ] + + +def dstI2D(x, norm="ortho"): + """2D type-I discrete sine transform.""" + return dstI1D(dstI1D(x, norm=norm).T, norm=norm).T + + +def inverse_elliptic_dst(f, operator_dst): + """Inverse elliptic operator (e.g. Laplace, Helmoltz) + using float32 discrete sine transform.""" + return dstI2D(dstI2D(f) / operator_dst) + + +def laplacian_dist(nx, ny, dx, dy, mean: bool = True) -> Array: + if mean: + dx = dy = jnp.mean(jnp.asarray([dx, dy])) + + x, y = jnp.meshgrid( + jnp.arange(1, nx - 1, dtype=dx.dtype), + jnp.arange(1, ny - 1, dtype=dx.dtype), + ) + + return ( + 2 * (jnp.cos(jnp.pi / (nx - 1) * x) - 1) / dx**2 + + 2 * (jnp.cos(jnp.pi / (ny - 1) * y) - 1) / dy**2 + ) + + +def helmholtz_dist( + nx: int, + ny: int, + dx: Union[float, Array], + dy: Union[float, Array], + alpha: float = 1.0, + beta: float = 0.0, + mean: bool = True, +) -> Array: + laplace_op = laplacian_dist(nx=nx, ny=ny, dx=dx, dy=dy, mean=mean) + return alpha * laplace_op - beta + + +def inverse_elliptical_dst_solver( + q: Array, + nx: int, + ny: int, + dx: Union[float, Array], + dy: Union[float, Array], + alpha: float = 1.0, + beta: float = 0.0, + mean: bool = True, +) -> Array: + """Solves the Poisson Equation + with Dirichlet Boundaries using the Discrete Sine + transform + """ + assert q.shape == (nx - 2, ny - 2) + + operator = helmholtz_dist( + nx=nx, ny=ny, dx=dx, dy=dy, mean=mean, alpha=alpha, beta=beta + ).T + + # print(q.shape, operator.shape) + + return inverse_elliptic_dst(q, operator) diff --git a/jaxsw/_src/operators/functional/elliptical.py b/jaxsw/_src/operators/functional/elliptical.py index 9862d9b..50e5b21 100644 --- a/jaxsw/_src/operators/functional/elliptical.py +++ b/jaxsw/_src/operators/functional/elliptical.py @@ -2,23 +2,73 @@ import finitediffx as fdx from jaxtyping import Array +import jax.numpy as jnp +from jaxsw._src.operators.functional.utils import identity def laplacian_matvec( u: Array, - bc_fn: tp.Callable, + alpha: float = 1.0, + bc_fn: tp.Callable = identity, **kwargs, ): - return helmholtz_matvec(u=u, bc_fn=bc_fn, alpha=1.0, beta=0.0, **kwargs) + return helmholtz_matvec(u=u, bc_fn=bc_fn, alpha=alpha, beta=0.0, **kwargs) def helmholtz_matvec( u: Array, - bc_fn: tp.Callable, alpha: float = 1.0, beta: float = 0.0, + bc_fn: tp.Callable = identity, **kwargs, ) -> Array: u_lap = fdx.laplacian(u, **kwargs) u_helmholtz = alpha * u_lap - beta * u return bc_fn(u_helmholtz) + + +def laplacian_dst(nx, ny, dx, dy, mean: bool = True, dtype=jnp.float32) -> Array: + if mean: + dx = dy = jnp.mean(jnp.asarray([dx, dy])) + + x, y = jnp.meshgrid( + jnp.arange(1, nx - 1, dtype=dtype), + jnp.arange(1, ny - 1, dtype=dtype), + indexing="ij", + ) + + return ( + 2 * (jnp.cos(jnp.pi / (nx - 1) * x) - 1) / dx**2 + + 2 * (jnp.cos(jnp.pi / (ny - 1) * y) - 1) / dy**2 + ) + + +def helmholtz_dst( + nx: int, + ny: int, + dx: tp.Union[float, Array], + dy: tp.Union[float, Array], + alpha: float = 1.0, + beta: float = 0.0, + mean: bool = True, +) -> Array: + laplace_op = laplacian_dst(nx=nx, ny=ny, dx=dx, dy=dy, mean=mean) + return alpha * laplace_op - beta + + +def dstI1D(x, norm="ortho"): + """1D type-I discrete sine transform.""" + return jnp.fft.irfft(-1j * jnp.pad(x, (1, 1)), axis=-1, norm=norm)[ + ..., 1 : x.shape[0] + 1, 1 : x.shape[1] + 1 + ] + + +def dstI2D(x, norm="ortho"): + """2D type-I discrete sine transform.""" + return dstI1D(dstI1D(x, norm=norm).T, norm=norm).T + + +def inverse_elliptic_dst(f, operator_dst): + """Inverse elliptic operator (e.g. Laplace, Helmoltz) + using float32 discrete sine transform.""" + return dstI2D(dstI2D(f) / operator_dst) diff --git a/jaxsw/_src/operators/functional/utils.py b/jaxsw/_src/operators/functional/utils.py index ae70d31..5e06112 100644 --- a/jaxsw/_src/operators/functional/utils.py +++ b/jaxsw/_src/operators/functional/utils.py @@ -1,3 +1,7 @@ +def identity(u): + return u + + # import jax.numpy as jnp # def check_dims(value, ndim, name: str): diff --git a/jbook/_toc.yml b/jbook/_toc.yml index 807de03..dfd7b68 100644 --- a/jbook/_toc.yml +++ b/jbook/_toc.yml @@ -34,3 +34,4 @@ parts: - file: content/qg/overview.md - file: content/qg/ssh_free_run - file: content/qg/qg_inversion + - file: content/qg/multilayer_qg diff --git a/jbook/content/12_steps/3.1_laplace.ipynb b/jbook/content/12_steps/3.1_laplace.ipynb index 1c8ab79..08fea20 100644 --- a/jbook/content/12_steps/3.1_laplace.ipynb +++ b/jbook/content/12_steps/3.1_laplace.ipynb @@ -571,7 +571,7 @@ ], "source": [ "target_criterion = 1e-5\n", - "max_iterations = 1_000\n", + "max_iterations = 2_000\n", "criterion = \"l2\"\n", "u = init_u0(domain).copy()\n", "b = jnp.zeros_like(u)\n", @@ -633,7 +633,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 27, "id": "4498f528-b005-4f5f-85dd-9f4649f696e0", "metadata": { "tags": [] @@ -652,7 +652,7 @@ "b = jnp.zeros_like(u_init)\n", "\n", "# define solver\n", - "solver = linear_solve.solve_normal_cg # BiCGStab, NormalCG, GMRES, CG\n", + "solver = linear_solve.solve_cg # BiCGStab, NormalCG, GMRES, CG\n", "solver_kwargs = dict(maxiters=10_000, tol=1e-5)\n", "\n", "# create matvec_fn\n", @@ -664,13 +664,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 28, "id": "e6ff6cbb-c788-4cff-85bd-1a23b958d960", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -704,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 34, "id": "a0c77477", "metadata": {}, "outputs": [ @@ -739,7 +739,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 35, "id": "32a3cc4c", "metadata": {}, "outputs": [ diff --git a/jbook/content/12_steps/3.2_poisson.ipynb b/jbook/content/12_steps/3.2_poisson.ipynb index b536e6e..af5aea5 100644 --- a/jbook/content/12_steps/3.2_poisson.ipynb +++ b/jbook/content/12_steps/3.2_poisson.ipynb @@ -829,7 +829,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 29, "id": "10695fce", "metadata": {}, "outputs": [ @@ -865,7 +865,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 30, "id": "372fa427", "metadata": {}, "outputs": [ @@ -891,6 +891,14 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d50cab93", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/jbook/content/qg/multilayer_qg.ipynb b/jbook/content/qg/multilayer_qg.ipynb new file mode 100644 index 0000000..d6c16fc --- /dev/null +++ b/jbook/content/qg/multilayer_qg.ipynb @@ -0,0 +1,2453 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d5bca1fd-b90e-43b2-90ba-4cf6ea2a6884", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "# Multilayer QG" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ef9b5897-79b7-41ac-8476-44ccc04243e1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eman/miniconda3/envs/jaxsw/lib/python3.11/site-packages/equinox/_ad.py:733: UserWarning: As of Equinox 0.10.7, `equinox.filter_custom_vjp.defvjp` is deprecated in favour of `.def_fwd` and `.def_bwd`. This new API supports symbolic zeros, which allow for more efficient autodifferentiation rules. In particular:\n", + "- the fwd and bwd functions take an extra `perturbed` argument, which indicates which primals actually need a gradient. You can use this to skip computing the gradient for any unperturbed value. (You can also safely just ignore this if you wish.)\n", + "- `None` was previously passed to indicate a symbolic zero gradient for all objects that weren't inexact arrays, but all inexact arrays always had an array-valued gradient. Now, `None` may also be passed to indicate that an inexact array has a symbolic zero gradient.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import autoroot\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.scipy as jsp\n", + "from jax.config import config\n", + "import numpy as np\n", + "import numba as nb\n", + "import pandas as pd\n", + "import equinox as eqx\n", + "import finitediffx as fdx\n", + "import diffrax as dfx\n", + "import xarray as xr\n", + "import einops\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from einops import rearrange, repeat, reduce\n", + "from tqdm.notebook import tqdm, trange\n", + "from jaxtyping import Array, Float\n", + "\n", + "from jaxsw._src.domain.base import Domain\n", + "from jaxsw._src.operators.functional import advection as F_adv\n", + "from jaxsw._src.operators.functional import geostrophic as F_geos\n", + "from jaxsw._src.operators.functional import cgrid as F_cgrid\n", + "from jaxsw._src.operators.functional import grid as F_grid\n", + "from jaxsw._src.boundaries.helmholtz import enforce_boundaries_helmholtz\n", + "from jaxsw._src.models import qg_louis as F_louis\n", + "from jaxsw._src.models import qg_ml as F_qgml\n", + "\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=0.7)\n", + "config.update(\"jax_enable_x64\", True)\n", + "\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1441015d", + "metadata": {}, + "outputs": [], + "source": [ + "from loguru import logger\n", + "\n", + "\n", + "def plot_field(field):\n", + " num_axis = len(field)\n", + " fig, ax = plt.subplots(ncols=num_axis, figsize=(8, 3))\n", + "\n", + " for i in range(num_axis):\n", + " pts = ax[i].pcolormesh(field[i], cmap=\"coolwarm\")\n", + " plt.colorbar(pts)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def print_debug_quantity(quantity, name=\"\"):\n", + " size = quantity.shape\n", + " min_ = np.min(quantity)\n", + " max_ = np.max(quantity)\n", + " mean_ = np.mean(quantity)\n", + " median_ = np.mean(quantity)\n", + " logger.debug(\n", + " f\"{name}: {size} | {min_:.6e} | {mean_:.6e} | {median_:.6e} | {max_:.6e}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "0dc829a9-a35c-49ca-8f95-aedb5ff5f61c", + "metadata": { + "user_expressions": [] + }, + "source": [ + "In this problem, we are looking at sea surface height (SSH) in relation to the Quasi-Geostrophic (QG) equations. These equations are a simplified form for the Navier-Stokes equations with approximations like *hydrostatic approximation*, *small aspect ratio*, and a *small Rossby number*. Ideally, these equations might be a decent approximation at mesoscale (100km - 10,000km). In this application, we will see how SSH propagates with the QG equations." + ] + }, + { + "cell_type": "markdown", + "id": "692a7d6b-1de0-462e-9fe8-34a5105eec5b", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Equations\n", + "\n", + "\n", + "$$\n", + "\\partial_t q_k + (u_kq_k)_x + (v_kq_k)_y = F_k + D_k\n", + "$$ (eq:qg_form_adv)\n", + "\n", + "The term that links each of the layers together, $\\mathbf{A}$, is a tri-diagonal matrix that can be written as\n", + "\n", + "$$\n", + "\\mathbf{A} =\n", + "\\begin{bmatrix}\n", + "\\frac{1}{H_1 g_1'} & \\frac{-1}{H_1 g_2'} & \\ldots & \\ldots & \\ldots \\\\\n", + "\\frac{-1}{H_2 g_1'} & \\frac{1}{H_1}\\left(\\frac{1}{g_1'} + \\frac{1}{g_2'} \\right) & \\frac{-1}{H_2 g_2'} & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\ldots & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\frac{-1}{H_{n-1} g_{n-2}'} & \\frac{1}{H_{n-1}}\\left(\\frac{1}{g_{n-2}'} + \\frac{1}{g_{n-1}'} \\right) & \\frac{-1}{H_{n-1} g_{n-2}'} \\\\\n", + "\\ldots & \\ldots& \\ldots & \\frac{-1}{H_n g_{n-1}'} & \\frac{1}{H_n g_{n-1}'} \\\\\n", + "\\end{bmatrix}\n", + "$$ (eq:qg_A)\n", + "\n", + "In the paper [[Thiry et al., 2023](https://doi.org/10.22541/essoar.167397445.54992823/v1)], they use the following method\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\text{Hyperviscosity}: && \n", + "\\boldsymbol{D_1} &= \n", + "-a_4\\boldsymbol{\\nabla}_H^6\\psi\\\\\n", + "\\text{Wind Forcing}: && \n", + "\\boldsymbol{F} &= \n", + "\\frac{\\tau_0}{\\rho_0H_1}\\left[\\partial_x\\tau_y - \\partial_y\\tau_x, 0\\cdots,0\\right]\\\\\n", + "\\text{Bottom Drag}: && \n", + "\\boldsymbol{D_2} &= \n", + "\\frac{\\delta_{ek}}{2H_{N_Z}}\n", + "\\left[0,\\cdots,0,\\Delta\\psi_N\\right]\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "Source:\n", + "* [Geophysical Fluid Dynamcis - Pedlosky](https://doi.org/10.1007/978-1-4612-4650-3)\n", + "* [Atmosphere and Oceanic Fluid Dynamics - Vallis](https://doi.org/10.1017/9781107588417)" + ] + }, + { + "cell_type": "markdown", + "id": "21f846ac", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4e9d4f12", + "metadata": {}, + "outputs": [], + "source": [ + "a_4 = 5.0e11 # 2.0e9 #\n", + "params = F_qgml.PDEParams(a_4=a_4)" + ] + }, + { + "cell_type": "markdown", + "id": "f589e7b9-e033-41e7-b122-6d0a9ca6e8c8", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Domain" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "070b4a1d", + "metadata": {}, + "outputs": [], + "source": [ + "# Low Resolution\n", + "Nx, Ny = 97, 121\n", + "# High Resolution\n", + "# Nx, Ny = 769, 961\n", + "\n", + "Lx, Ly = 3840.0e3, 4800.0e3\n", + "\n", + "# initialize domain\n", + "domain = Domain.from_numpoints(xmin=(0, 0), xmax=(Lx, Ly), N=(Nx, Ny))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7345b7ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((40000.0, 40000.0), (97, 121), (3840000.0, 4800000.0), 1600000000.0, 2)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "domain.dx, domain.Nx, domain.Lx, domain.cell_volume, domain.ndim" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "563e5026", + "metadata": {}, + "outputs": [], + "source": [ + "# # initialize domain\n", + "# # domain = Domain.from_numpoints(xmin=(0, 0), xmax=(Lx, Ly), N=(Nx+1, Ny+1))\n", + "# domain = F_qgml.Domain(nx=Nx, ny=Ny, Lx=Lx, Ly=Ly)\n", + "\n", + "# domain.dx" + ] + }, + { + "cell_type": "markdown", + "id": "6575c549", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Heights\n" + ] + }, + { + "cell_type": "markdown", + "id": "22482952", + "metadata": { + "user_expressions": [] + }, + "source": [ + "$$\n", + "\\mathbf{A} =\n", + "\\begin{bmatrix}\n", + "\\frac{1}{H_1 g_1'} & \\frac{-1}{H_1 g_2'} & \\ldots & \\ldots & \\ldots \\\\\n", + "\\frac{-1}{H_2 g_1'} & \\frac{1}{H_1}\\left(\\frac{1}{g_1'} + \\frac{1}{g_2'} \\right) & \\frac{-1}{H_2 g_2'} & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\ldots & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\frac{-1}{H_{n-1} g_{n-2}'} & \\frac{1}{H_{n-1}}\\left(\\frac{1}{g_{n-2}'} + \\frac{1}{g_{n-1}'} \\right) & \\frac{-1}{H_{n-1} g_{n-2}'} \\\\\n", + "\\ldots & \\ldots& \\ldots & \\frac{-1}{H_n g_{n-1}'} & \\frac{1}{H_n g_{n-1}'} \\\\\n", + "\\end{bmatrix}\n", + "$$ (eq:qg_A)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f8be78a1", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.domain.qg import LayerDomain\n", + "\n", + "# heights\n", + "heights = [350.0, 750.0, 2900.0]\n", + "\n", + "# reduced gravities\n", + "reduced_gravities = [0.025, 0.0125]\n", + "\n", + "layer_domain = LayerDomain(heights, reduced_gravities)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4d2e629f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[ 0.11428571, -0.11428571, 0. ],\n", + " [-0.05333333, 0.16 , -0.10666667],\n", + " [ 0. , -0.02758621, 0.02758621]], dtype=float64)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "layer_domain.A" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3aa8fcc3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array([ 2.28183707e-01, 7.36882145e-02, -4.04361683e-18], dtype=float64),\n", + " Array([[-0.43193138, 0.92242719, -0.49049581],\n", + " [-0.65802762, -0.50089268, 1.15892029],\n", + " [-0.15155445, -0.32475953, -1.25573684]], dtype=float64),\n", + " Array([[-0.70499319, -0.92396019, -0.57735027],\n", + " [ 0.70260146, -0.32821664, -0.57735027],\n", + " [-0.09662189, 0.19639605, -0.57735027]], dtype=float64))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "layer_domain.lambd, layer_domain.A_layer_2_mode, layer_domain.A_mode_2_layer" + ] + }, + { + "cell_type": "markdown", + "id": "ac3e4aab", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Helmholtz Matrices" + ] + }, + { + "cell_type": "markdown", + "id": "9c3e969b", + "metadata": { + "user_expressions": [] + }, + "source": [ + "We can precompute the Helmoltz matrices\n", + "\n", + "$$\n", + "\\text{Helmholtz}:=\\left(\\alpha\\boldsymbol{\\nabla}-\\beta\\right)u\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\alpha &= \\frac{1}{f_0^2} \\\\\n", + "\\beta &= \\lambda\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8bafc984", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.operators.functional import elliptical as F_elliptical" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c6733cba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([ 2.28183707e-01, 7.36882145e-02, -4.04361683e-18], dtype=float64)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "layer_domain.lambd" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9552abdc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:29.460\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mhelmholtz: (95, 119) | -7.969477e-01 | -5.126282e-01 | -5.126282e-01 | -2.283086e-01\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:29.462\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mhelmholtz: (95, 119) | -6.424522e-01 | -3.581327e-01 | -3.581327e-01 | -7.381310e-02\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:29.464\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mhelmholtz: (95, 119) | -5.687640e-01 | -2.844445e-01 | -2.844445e-01 | -1.248847e-04\u001b[0m\n" + ] + } + ], + "source": [ + "# create Helmholtz Matrix\n", + "helmoltz_dst_mat = F_qgml.create_qgml_helmholtz_matrix(\n", + " domain, layer_domain.lambd, params.f0\n", + ")\n", + "\n", + "print_debug_quantity(helmoltz_dst_mat[0], \"helmholtz\")\n", + "print_debug_quantity(helmoltz_dst_mat[1], \"helmholtz\")\n", + "print_debug_quantity(helmoltz_dst_mat[2], \"helmholtz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "51faa09b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(helmoltz_dst_mat)" + ] + }, + { + "cell_type": "markdown", + "id": "bacab1f1", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Inversion" + ] + }, + { + "cell_type": "markdown", + "id": "38ec22c4", + "metadata": {}, + "source": [ + "We are interested in solving for the Helmholtz equation which is given by\n", + "\n", + "$$\n", + "(\\boldsymbol{\\alpha\\nabla}_H^2 - \\boldsymbol{\\beta})p = q\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0c044b45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 95, 119)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "helmoltz_dst_mat.shape" + ] + }, + { + "cell_type": "markdown", + "id": "3e8c94d6", + "metadata": {}, + "source": [ + "#### Homogeneous Solution" + ] + }, + { + "cell_type": "markdown", + "id": "cbe1b411", + "metadata": {}, + "source": [ + "First, we need to use the scheme to solve the homogeneous Helmholtz equation for the baroclinic nodes.\n", + "The homoegeneous equation is given by:\n", + "\n", + "$$\n", + "(\\boldsymbol{\\nabla}_H^2 - \\boldsymbol{\\beta})p = 0\n", + "$$\n", + "\n", + "Let's reformulate the pressure to be:\n", + "\n", + "$$\n", + "p = \\mathbf{L} + \\beta s\n", + "$$\n", + "\n", + "where $\\mathbf{L}$ is a known solution of the Laplace's equation with non-zero boundaries.\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\boldsymbol{\\nabla}_H^2\\mathbf{L} &= 0 && && x\\in\\Omega\\\\\n", + "\\boldsymbol{F}_{BC}(\\mathbf{L}) &= b && && x\\in\\partial\\Omega\\\\\n", + "\\end{aligned}\n", + "$$\n", + "\n", + " which is non\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "103c99e6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:30.258\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1m: (2, 97, 121) | -3.576361e-12 | 4.449322e-06 | 4.449322e-06 | 8.520065e-05\u001b[0m\n" + ] + } + ], + "source": [ + "homogeneous_sol = F_qgml.helmholtz_homogeneous_sol_multilayer(\n", + " helmoltz_dst_mat, layer_domain.lambd, domain\n", + ")\n", + "print_debug_quantity(homogeneous_sol)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "72632456", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(homogeneous_sol)" + ] + }, + { + "cell_type": "markdown", + "id": "7e67f679", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Alpha Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "977e4e24", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:30.618\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1m: (2, 2) | -2.558977e+05 | -1.140663e+05 | -1.140663e+05 | 2.813377e-11\u001b[0m\n" + ] + } + ], + "source": [ + "alpha_matrix = F_qgml.compute_alpha_matrix(layer_domain.A_mode_2_layer, homogeneous_sol)\n", + "\n", + "print_debug_quantity(alpha_matrix)" + ] + }, + { + "cell_type": "markdown", + "id": "903d7d5e", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Forcing" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f316ab30", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:30.658\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mTau: (2, 97, 121) | -1.999326e-05 | 3.348584e-22 | 3.348584e-22 | 2.000000e-05\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:31.571\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mwind_forcing: (95, 119) | -7.905821e-10 | 4.311263e-13 | 4.311263e-13 | 7.905821e-10\u001b[0m\n" + ] + } + ], + "source": [ + "from jaxsw._src.forcing import wind as F_wind\n", + "\n", + "tau = F_wind.init_tau(domain, tau0=2.0e-5)\n", + "print_debug_quantity(tau, \"Tau\")\n", + "wind_forcing = F_wind.calculate_wind_forcing(tau, domain) / (params.f0 * heights[0])\n", + "print_debug_quantity(wind_forcing, \"wind_forcing\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f51f9db0", + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_wind_forcing(tau, domain):\n", + " # move from edges to nodes\n", + " tau_x = F_grid.x_average_2D(tau[0])\n", + " tau_y = F_grid.y_average_2D(tau[1])\n", + "\n", + " # calculate curl\n", + " dF2dX = (tau_y[1:] - tau_y[:-1]) / domain.dx[0]\n", + " dF1dY = (tau_x[:, 1:] - tau_x[:, :-1]) / domain.dx[1]\n", + " curl_stagg = dF2dX - dF1dY\n", + "\n", + " # move from nodes to faces\n", + " return F_grid.center_average_2D(curl_stagg)\n", + "\n", + "\n", + "wind_forcing = calculate_wind_forcing(tau, domain)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0b88b88f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "pts = ax.pcolormesh(wind_forcing)\n", + "plt.colorbar(pts)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f0f5575b", + "metadata": {}, + "source": [ + "## Pressure" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "16df2ab7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 97, 121)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if domain.Nx[0] == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "p.shape" + ] + }, + { + "cell_type": "markdown", + "id": "d4a91ca0", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Vorticity" + ] + }, + { + "cell_type": "markdown", + "id": "37ce0a2f", + "metadata": {}, + "source": [ + "$$\n", + "f_0 q = (\\boldsymbol{\\nabla}_H^2 - f_0^2A)p + f_0\\beta(y-y_0)\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2c69a72f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:33.131\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:33.167\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mVORTICITY: (3, 97, 121) | -4.657202e-01 | -6.053233e-06 | -6.053233e-06 | 4.963626e-01\u001b[0m\n" + ] + } + ], + "source": [ + "import functools as ft\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "print_debug_quantity(q, \"VORTICITY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b1dded12", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(p)\n", + "plot_field(q)" + ] + }, + { + "cell_type": "markdown", + "id": "b30c8523-b8e2-4dc5-a0bd-dde652607df2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## RHS" + ] + }, + { + "cell_type": "markdown", + "id": "37e6fb82", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{aligned}\n", + "\\text{Advection}: && \n", + "\\boldsymbol{D_1} &= \n", + "-\\frac{1}{f_0}\\boldsymbol{J}(q,p)\\\\\n", + "\\text{Diffusion}: && \n", + "\\boldsymbol{D_2} &= \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\\\\\n", + "\\text{HyperDiffusion}: && \n", + "\\boldsymbol{D_2} &= \n", + "-\\frac{a_4}{f_0}\\boldsymbol{\\nabla}_H^6\\psi\\\\\n", + "\\text{Wind Forcing}: && \n", + "\\boldsymbol{F} &= \n", + "\\frac{\\tau_0}{\\rho_0H_1}\\left[\\partial_x\\tau_y - \\partial_y\\tau_x, 0\\cdots,0\\right]\\\\\n", + "\\text{Bottom Drag}: && \n", + "\\boldsymbol{D_2} &= \n", + "\\frac{\\delta_{ek}}{2H_{N_Z}}\n", + "\\left[0,\\cdots,0,\\Delta\\psi_N\\right]\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "3b1e4ab0-86ee-427b-8460-96bb65ee8bd8", + "metadata": { + "user_expressions": [] + }, + "source": [ + "#### Advection Term\n", + "\n", + "$$\n", + "\\boldsymbol{D_1} = \n", + "-\\frac{1}{f_0}\\boldsymbol{J}(q,p)\n", + "$$\n", + "\n", + "Here, we will use the (determinant) Jacobian to calculate this." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "38fd3114", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.operators.functional.advection import det_jacobian" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "96146c01", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:33.874\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:33.876\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mVORTICITY: (3, 97, 121) | -4.657202e-01 | -6.053233e-06 | -6.053233e-06 | 4.963626e-01\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:33.919\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS ADVECTION: (3, 95, 119) | -1.564097e-06 | -2.804566e-12 | -2.804566e-12 | 1.195297e-06\u001b[0m\n" + ] + } + ], + "source": [ + "rhs_advection = (1 / params.f0) * det_jacobian(q, p, domain.dx[0], domain.dx[1])\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "print_debug_quantity(q, \"VORTICITY\")\n", + "print_debug_quantity(rhs_advection, \"RHS ADVECTION\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "48526664", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs_advection)" + ] + }, + { + "cell_type": "markdown", + "id": "2ef48ac3", + "metadata": {}, + "source": [ + "#### Diffusion Term\n", + "\n", + "$$\n", + "\\boldsymbol{D_2} = \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "0b2167a9", + "metadata": {}, + "source": [ + "#### HyperDiffusion Term\n", + "\n", + "$$\n", + "\\boldsymbol{D_2} = \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "e47f41ef", + "metadata": {}, + "source": [ + "**Wind Stress**\n", + "\n", + "$$\n", + "\\boldsymbol{F} = \n", + "\\frac{\\tau_0}{\\rho_0H_1}\\left[\\partial_x\\tau_y - \\partial_y\\tau_x, 0\\cdots,0\\right]^\\top\n", + "$$\n", + "\n", + "**Bottom Friction Term**\n", + "\n", + "$$\n", + "\\boldsymbol{D_2} = \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "b94a3cce", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:34.327\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:34.706\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS: (3, 95, 119) | -1.502200e-06 | -7.205300e-12 | -7.205300e-12 | 1.339382e-06\u001b[0m\n" + ] + } + ], + "source": [ + "print_debug_quantity(p, \"PRESSURE\")\n", + "rhs = F_qgml.rhs_pde(\n", + " q, jnp.asarray(p), bc_fn, params, layer_domain, domain, wind_forcing\n", + ")\n", + "print_debug_quantity(rhs, \"RHS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "74b75cc9-6be6-41e2-8864-0af73bbbc043", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "markdown", + "id": "04719607", + "metadata": {}, + "source": [ + "## Time Step" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "54d52da6", + "metadata": {}, + "outputs": [], + "source": [ + "import typing as tp\n", + "\n", + "\n", + "class QGState(tp.NamedTuple):\n", + " q: Array\n", + " p: Array\n", + "\n", + "\n", + "class QGARGS(tp.NamedTuple):\n", + " params: tp.NamedTuple\n", + " domain: Domain\n", + " layer_domain: LayerDomain\n", + " wind_forcing: Array\n", + " helmoltz_dst_mat: Array\n", + " alpha_matrix: Array\n", + " homogeneous_sol: Array\n", + " bc_fn: tp.Callable" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "bec25f44", + "metadata": {}, + "outputs": [], + "source": [ + "if domain.Nx[0] == 97:\n", + " p = jnp.asarray(\n", + " np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + " )\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "import functools as ft\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)\n", + "\n", + "state_init = F_qgml.QGState(p=p, q=q)\n", + "\n", + "args = F_qgml.QGARGS(\n", + " domain=domain,\n", + " layer_domain=layer_domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst_mat=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + " bc_fn=bc_fn,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "43d0178b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:35.234\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.185125e-06 | 2.919435e-08 | 2.919435e-08 | 5.175048e-06\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:35.235\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -8.966964e-12 | -8.966964e-12 | 1.339382e-06\u001b[0m\n" + ] + } + ], + "source": [ + "import typing as tp\n", + "\n", + "\n", + "def pde_time_step(t, state, args):\n", + " # unpack state\n", + " p, q = state.p, state.q\n", + "\n", + " # RHS of PDE for Q (INTERIOR)\n", + " dq_f0 = F_qgml.rhs_pde(\n", + " q,\n", + " p,\n", + " bc_fn=bc_fn,\n", + " params=args.params,\n", + " layer_domain=args.layer_domain,\n", + " domain=args.domain,\n", + " wind_forcing=args.wind_forcing,\n", + " )\n", + " print_debug_quantity(dq_f0, \"dq_f0\")\n", + " # pad for original domain\n", + " dq_f0 = jnp.pad(dq_f0, ((0, 0), (1, 1), (1, 1)))\n", + "\n", + " # PRESSURE (INTERIOR)\n", + " rhs_helmholtz = jnp.einsum(\"ij,jkl->ikl\", args.layer_domain.A_layer_2_mode, dq_f0)\n", + " print_debug_quantity(rhs_helmholtz, \"rhs_helmholtz\")\n", + " dp_modes = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))(\n", + " rhs_helmholtz[:, 1:-1, 1:-1], args.helmoltz_dst_mat\n", + " )\n", + "\n", + " dp_modes = jnp.pad(dp_modes, ((0, 0), (1, 1), (1, 1)))\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + "\n", + " # ensure mass conservation\n", + " print_debug_quantity(args.alpha_matrix, \"alpha_matrix\")\n", + " dalpha = args.alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1))\n", + " dalpha = einops.repeat(dalpha, \"i -> i 1 1\")\n", + " print_debug_quantity(dalpha, \"dalpha\")\n", + " print_debug_quantity(args.homogeneous_sol, \"homogeneous_sol\")\n", + " dp_modes = dp_modes.at[..., :-1, :, :].set(\n", + " dp_modes[..., :-1, :, :] + dalpha * args.homogeneous_sol\n", + " )\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + " dp = jnp.einsum(\"ij,jkl->ikl\", args.layer_domain.A_mode_2_layer, dp_modes)\n", + " print_debug_quantity(dp, \"dp\")\n", + "\n", + " delta_p_boundaries = args.bc_fn(dp / (params.f0 * args.domain.dx[0]) ** 2)\n", + " print_debug_quantity(delta_p_boundaries, \"delta_p_boundaries\")\n", + "\n", + " # apply boundaries\n", + " print(delta_p_boundaries.shape, args.layer_domain.A.shape, dp.shape)\n", + " dq_f0_boundaries = delta_p_boundaries - jnp.einsum(\n", + " \"ij,jkl->ikl\", args.layer_domain.A, dp\n", + " )\n", + "\n", + " dq_f0 = F_qgml.apply_boundaries(dq_f0, dq_f0_boundaries)\n", + "\n", + " return dp, q\n", + "\n", + "\n", + "out_state = F_qgml.pde_time_step(p, q, params, args)\n", + "print_debug_quantity(out_state[0], \"dp\")\n", + "print_debug_quantity(out_state[1], \"dq_f0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "e71b5af3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(out_state[0])\n", + "plot_field(out_state[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "e0eee8e7-1131-42c6-bdb4-5f0d70e77d21", + "metadata": {}, + "outputs": [], + "source": [ + "pde_args = QGARGS(\n", + " params=params,\n", + " domain=domain,\n", + " layer_domain=layer_domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst_mat=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + " bc_fn=bc_fn,\n", + ")\n", + "\n", + "pde_time_step_fn = ft.partial(F_qgml.pde_time_step, params=params, args=pde_args)\n", + "\n", + "rhs_time_step_jitted = jax.jit(pde_time_step_fn)\n", + "\n", + "\n", + "# vector field\n", + "def vector_field(t, state, args):\n", + " p, q = state\n", + " p, q = rhs_time_step_jitted(p, q)\n", + "\n", + " return (p, q)\n", + "\n", + "\n", + "if domain.Nx[0] == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "d36f0d83-644d-46a6-a194-20ec3e74d505", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:57:12.848\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.185125e-06 | 2.919435e-08 | 2.919435e-08 | 5.175048e-06\u001b[0m\n", + "\u001b[32m2023-07-12 18:57:12.848\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -8.966964e-12 | -8.966964e-12 | 1.339382e-06\u001b[0m\n" + ] + } + ], + "source": [ + "dp, dq = vector_field(0, (p, q), None)\n", + "print_debug_quantity(dp, \"dp\")\n", + "print_debug_quantity(dq, \"dq_f0\")" + ] + }, + { + "cell_type": "markdown", + "id": "dc9508f4-3ddd-4a46-b3fd-6110267f9ff2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Time Stepping\n", + "\n", + "We're going to use the Heun method.\n", + "I'll also be using `diffrax` to handle the time stepping :)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "988e4234-c444-49a0-a17b-15dad9e8bfae", + "metadata": {}, + "outputs": [], + "source": [ + "dt = 1_200 # LR #600 # HR #\n", + "n_years = 2\n", + "n_days = 365\n", + "tmin = 0\n", + "tmax = pd.to_timedelta(n_years * n_days, unit=\"day\").total_seconds()\n", + "ts = jnp.arange(tmin, tmax, dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "70d59ba6-3cb1-4557-a7ce-379269c31548", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "52560" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ts)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "25a0510c-a635-4b48-bc80-ea59da75e70c", + "metadata": {}, + "outputs": [], + "source": [ + "if domain.Nx[0] == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)\n", + "\n", + "state = (p, q)\n", + "\n", + "\n", + "solver = dfx.Heun()\n", + "solver_state = solver.init(\n", + " terms=dfx.ODETerm(vector_field),\n", + " t0=tmax,\n", + " t1=tmin + dt,\n", + " y0=state,\n", + " args=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "ba30e79b-1ec6-4d91-add1-382910d41ce4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2000" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_check = 2_000\n", + "freq_log = 1_000 # LR #50 # HR #\n", + "n_check" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "5355e16e-6862-4bd1-af6f-593293208943", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02be4df57ec44719ae279f9dc0826dc7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/52560 [00:00 21\u001b[0m \u001b[39mif\u001b[39;00m t \u001b[39m%\u001b[39;49m (freq_log \u001b[39m*\u001b[39;49m dt) \u001b[39m==\u001b[39;49m \u001b[39m0\u001b[39;49m:\n\u001b[1;32m 22\u001b[0m saved_states[\u001b[39m\"\u001b[39m\u001b[39mq\u001b[39m\u001b[39m\"\u001b[39m]\u001b[39m.\u001b[39mappend(state[\u001b[39m1\u001b[39m])\n\u001b[1;32m 23\u001b[0m saved_states[\u001b[39m\"\u001b[39m\u001b[39mp\u001b[39m\u001b[39m\"\u001b[39m]\u001b[39m.\u001b[39mappend(state[\u001b[39m0\u001b[39m])\n", + "File \u001b[0;32m~/miniconda3/envs/jaxsw/lib/python3.11/site-packages/jax/_src/numpy/array_methods.py:258\u001b[0m, in \u001b[0;36m_defer_to_unrecognized_arg..deferring_binary_op\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 256\u001b[0m args \u001b[39m=\u001b[39m (other, \u001b[39mself\u001b[39m) \u001b[39mif\u001b[39;00m swap \u001b[39melse\u001b[39;00m (\u001b[39mself\u001b[39m, other)\n\u001b[1;32m 257\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, _accepted_binop_types):\n\u001b[0;32m--> 258\u001b[0m \u001b[39mreturn\u001b[39;00m binary_op(\u001b[39m*\u001b[39;49margs)\n\u001b[1;32m 259\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, _rejected_binop_types):\n\u001b[1;32m 260\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39munsupported operand type(s) for \u001b[39m\u001b[39m{\u001b[39;00mopchar\u001b[39m}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 261\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mtype\u001b[39m(args[\u001b[39m0\u001b[39m])\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m!r}\u001b[39;00m\u001b[39m and \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mtype\u001b[39m(args[\u001b[39m1\u001b[39m])\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m!r}\u001b[39;00m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "saved_states = dict(q=list(), p=list(), t=list())\n", + "\n", + "solver_step = jax.jit(solver.step, static_argnames=(\"made_jump\", \"terms\"))\n", + "\n", + "with tqdm(ts) as pbar:\n", + " for t in pbar:\n", + " state, _, _, solver_state, _ = solver_step(\n", + " terms=dfx.ODETerm(vector_field),\n", + " t0=t,\n", + " t1=t + dt,\n", + " y0=state,\n", + " args=None,\n", + " solver_state=solver_state,\n", + " made_jump=False,\n", + " )\n", + "\n", + " msg1 = f\"PRESSURE: {jnp.min(state[0]):.4e} | {jnp.max(state[0]):.4e}\"\n", + " msg2 = f\"VORTICITY: {jnp.min(state[1]):.4e} | {jnp.max(state[1]):.4e}\"\n", + " pbar.set_description(msg1 + \" - \" + msg2)\n", + "\n", + " if t % (freq_log * dt) == 0:\n", + " saved_states[\"q\"].append(state[1])\n", + " saved_states[\"p\"].append(state[0])\n", + " saved_states[\"t\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "id": "98fb638c-5efa-4404-9e30-4c2947a28849", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "546e67c6-5101-4e3d-8e3f-5a3eb0880666", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (time: 53, layer: 3, x: 97, y: 121)\n",
+       "Coordinates:\n",
+       "  * time     (time) float64 0.0 1.2e+06 2.4e+06 ... 6e+07 6.12e+07 6.24e+07\n",
+       "  * layer    (layer) int64 0 1 2\n",
+       "  * x        (x) float64 0.0 4e+04 8e+04 1.2e+05 ... 3.76e+06 3.8e+06 3.84e+06\n",
+       "  * y        (y) float64 0.0 4e+04 8e+04 1.2e+05 ... 4.72e+06 4.76e+06 4.8e+06\n",
+       "Data variables:\n",
+       "    q        (time, layer, x, y) float64 -0.4522 -0.4529 ... 0.4412 0.449\n",
+       "    p        (time, layer, x, y) float64 0.009725 0.02492 ... 0.007248 0.003341
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 53, layer: 3, x: 97, y: 121)\n", + "Coordinates:\n", + " * time (time) float64 0.0 1.2e+06 2.4e+06 ... 6e+07 6.12e+07 6.24e+07\n", + " * layer (layer) int64 0 1 2\n", + " * x (x) float64 0.0 4e+04 8e+04 1.2e+05 ... 3.76e+06 3.8e+06 3.84e+06\n", + " * y (y) float64 0.0 4e+04 8e+04 1.2e+05 ... 4.72e+06 4.76e+06 4.8e+06\n", + "Data variables:\n", + " q (time, layer, x, y) float64 -0.4522 -0.4529 ... 0.4412 0.449\n", + " p (time, layer, x, y) float64 0.009725 0.02492 ... 0.007248 0.003341" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "\n", + "ds_results = xr.Dataset(\n", + " data_vars={\n", + " \"q\": ((\"time\", \"layer\", \"x\", \"y\"), np.stack(saved_states[\"q\"], axis=0)),\n", + " \"p\": ((\"time\", \"layer\", \"x\", \"y\"), np.stack(saved_states[\"p\"], axis=0)),\n", + " },\n", + " coords={\n", + " \"time\": ((\"time\"), np.stack(saved_states[\"t\"], axis=0)),\n", + " \"layer\": ((\"layer\"), np.arange(3)),\n", + " \"x\": ((\"x\"), np.arange(0, domain.Lx[0] + 1, domain.dx[0])),\n", + " \"y\": ((\"y\"), np.arange(0, domain.Lx[1] + 1, domain.dx[1])),\n", + " },\n", + ")\n", + "ds_results" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "f85d69ec-2ce4-4639-acd3-7f6aec53dff5", + "metadata": {}, + "outputs": [], + "source": [ + "from xmovie import Movie\n", + "from pathlib import Path\n", + "from matplotlib import ticker\n", + "\n", + "\n", + "def custom_plot_p_layers(ds, fig, tt, *args, **kwargs):\n", + " sub = ds.isel(time=tt)\n", + "\n", + " xlim = kwargs.pop(\"xlim\", None)\n", + " ylim = kwargs.pop(\"ylim\", None)\n", + " vmin = kwargs.pop(\"vmin\", sub.p.min())\n", + " vmax = kwargs.pop(\"vmax\", sub.p.max())\n", + " cmap = kwargs.pop(\"cmap\", \"viridis\")\n", + "\n", + " fig.set_size_inches(15, 10)\n", + "\n", + " ax = fig.subplots(ncols=3, nrows=2)\n", + "\n", + " for i in range(3):\n", + " # NATL60\n", + " pts = sub.p.isel(layer=i).plot.pcolormesh(\n", + " ax=ax[0, i],\n", + " cmap=\"viridis\",\n", + " add_colorbar=True,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " # **kwargs\n", + " )\n", + "\n", + " loc = ticker.MaxNLocator(6)\n", + " levels = loc.tick_values(vmin, vmax)\n", + " sub.p.isel(layer=i).plot.contour(\n", + " ax=ax[0, i],\n", + " levels=levels,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " alpha=0.5,\n", + " linewidths=1,\n", + " cmap=\"black\",\n", + " linestyles=np.where(levels >= 0, \"-\", \"--\"),\n", + " )\n", + "\n", + " # ax.set_aspect('equal')\n", + " pts = ax[0, i].set(xlabel=\"x [m]\", ylabel=\"y [m]\", title=f\"Layer {i}\")\n", + "\n", + " xlim = kwargs.pop(\"xlim\", None)\n", + " ylim = kwargs.pop(\"ylim\", None)\n", + " vmin = kwargs.pop(\"vmin\", sub.q.min())\n", + " vmax = kwargs.pop(\"vmax\", sub.q.max())\n", + " cmap = kwargs.pop(\"cmap\", \"viridis\")\n", + "\n", + " for i in range(3):\n", + " # NATL60\n", + " pts = sub.q.isel(layer=i).plot.pcolormesh(\n", + " ax=ax[1, i],\n", + " cmap=\"RdBu_r\",\n", + " add_colorbar=True,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " # **kwargs\n", + " )\n", + "\n", + " loc = ticker.MaxNLocator(6)\n", + " levels = loc.tick_values(vmin, vmax)\n", + " sub.q.isel(layer=i).plot.contour(\n", + " ax=ax[1, i],\n", + " levels=levels,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " alpha=0.5,\n", + " linewidths=1,\n", + " cmap=\"black\",\n", + " linestyles=np.where(levels >= 0, \"-\", \"--\"),\n", + " )\n", + "\n", + " # ax.set_aspect('equal')\n", + " pts = ax[0, i].set(xlabel=\"x [m]\", ylabel=\"y [m]\", title=f\"Layer {i}\")\n", + " plt.tight_layout()\n", + " return None, None\n", + "\n", + "\n", + "from pathlib import Path\n", + "\n", + "\n", + "def create_movie(\n", + " var,\n", + " name,\n", + " plotfunc=custom_plot_p_layers,\n", + " framedim: str = \"steps\",\n", + " file_path=None,\n", + " **kwargs,\n", + "):\n", + " if file_path is not None:\n", + " file_name = Path(file_path).joinpath(f\"movie_{name}.gif\")\n", + " else:\n", + " file_name = Path(f\"./movie_{name}.gif\")\n", + "\n", + " mov = Movie(\n", + " var, plotfunc=plotfunc, framedim=framedim, **kwargs, dpi=200, input_check=False\n", + " )\n", + " mov.save(\n", + " file_name,\n", + " remove_movie=False,\n", + " progress=True,\n", + " framerate=3,\n", + " gif_framerate=3,\n", + " overwrite_existing=True,\n", + " gif_resolution_factor=0.5,\n", + " parallel=False,\n", + " )\n", + "\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a5a1d23-1cc6-4a3d-9e51-b4cf45bd4558", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "06b4c4c0-3b49-44b0-b11a-d11431fc67a9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "mov = Movie(\n", + " ds_results.transpose(\"time\", \"layer\", \"y\", \"x\"),\n", + " plotfunc=custom_plot_p_layers,\n", + " framedim=\"time\",\n", + " input_check=False,\n", + ")\n", + "mov.preview(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "5b6f4726-ca13-40a7-a7e1-8c54b66b2a0d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d68bcec017244b0ae325e54d9b2d5b3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/53 [00:00 Nz 1 1\")\n", + "# mean = True\n", + "# laplace_dst = alpha * F_elliptical.laplacian_dst(nx=domain.size[0], ny=domain.size[1], dx=domain.dx[0], dy=domain.dx[1], mean=mean)\n", + "# print_debug_quantity(laplace_dst)\n", + "\n", + "# helmoltz_dst_mat = laplace_dst - beta\n", + "\n", + "\n", + "# print_debug_quantity(helmoltz_dst_mat[0])\n", + "# print_debug_quantity(helmoltz_dst_mat[1])\n", + "# print_debug_quantity(helmoltz_dst_mat[2])\n", + "helmoltz_dst_mat = F_elliptical.helmholtz_dst(\n", + " nx=domain.nx, ny=domain.ny, dx=domain.dx, dy=domain.dy, alpha=alpha, beta=beta\n", + ")\n", + "print_debug_quantity(helmoltz_dst_mat[0])\n", + "print_debug_quantity(helmoltz_dst_mat[1])\n", + "print_debug_quantity(helmoltz_dst_mat[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "51faa09b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(helmoltz_dst_mat)" + ] + }, + { + "cell_type": "markdown", + "id": "bacab1f1", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Inversion" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "f9316167", + "metadata": {}, + "outputs": [], + "source": [ + "# # constant field\n", + "# constant_field = jnp.ones((A_mat.Nz, domain.size[0], domain.size[1])) / (domain.size[0] * domain.size[1])\n", + "# print_debug_quantity(constant_field)\n", + "# #\n", + "# s_solutions = jnp.zeros_like(constant_field)\n", + "# out = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0,0))(constant_field[:, 1:-1,1:-1], helmoltz_dst_mat)\n", + "# s_solutions = s_solutions.at[:, 1:-1, 1:-1].set(out)\n", + "# print_debug_quantity(s_solutions[0])\n", + "# print_debug_quantity(s_solutions[1])\n", + "# print_debug_quantity(s_solutions[2])\n", + "\n", + "# # homogeneous solution\n", + "# # ignore last solution correponding to lambd = 0, i.e. Laplace equation\n", + "# homogeneous_sol = (constant_field + s_solutions * beta)[:-1]\n", + "\n", + "# print_debug_quantity(homogeneous_sol)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "bd8c2e66", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:18:19.400\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1m: (2, 97, 121) | -3.576361e-12 | 4.449322e-06 | 4.449322e-06 | 8.520065e-05\u001b[0m\n" + ] + } + ], + "source": [ + "homogeneous_sol = F_louis.homogeneous_sol_layers(helmoltz_dst_mat, domain, A_mat)\n", + "print_debug_quantity(homogeneous_sol)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "72632456", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(homogeneous_sol)" + ] + }, + { + "cell_type": "markdown", + "id": "7e67f679", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Alpha Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "84f56108", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:18:24.674\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1m: (2, 2) | -2.558977e+05 | -1.140663e+05 | -1.140663e+05 | 2.813377e-11\u001b[0m\n" + ] + } + ], + "source": [ + "alpha_matrix = F_louis.compute_alpha_matrix(A_mat.A_mode_2_layer, homogeneous_sol)\n", + "\n", + "print_debug_quantity(alpha_matrix)" + ] + }, + { + "cell_type": "markdown", + "id": "903d7d5e", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Forcing" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "6d7b558b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:18:29.884\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mTau: (2, 97, 121) | -1.999326e-05 | 3.348584e-22 | 3.348584e-22 | 2.000000e-05\u001b[0m\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:18:29.902\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mwind_forcing: (95, 119) | -7.908487e-10 | -9.833974e-26 | -9.833974e-26 | 7.908487e-10\u001b[0m\n" + ] + } + ], + "source": [ + "# def init_tau(domain, tau0: float=2.0e-5):\n", + "# \"\"\"\n", + "# Args\n", + "# ----\n", + "# tau0 (float): wind stress magnitude m/s^2\n", + "# default=2.0e-5\"\"\"\n", + "# # initial TAU\n", + "# tau = np.zeros((2, domain.nx, domain.ny))\n", + "\n", + "# # create staggered coordinates (y-direction)\n", + "# y_coords = np.arange(domain.ny) + 0.5\n", + "\n", + "# # create tau\n", + "# tau[0, :, :] = - tau0 * np.cos(2 * np.pi * (y_coords / domain.ny))\n", + "\n", + "# return tau\n", + "\n", + "# def calculate_wind_forcing(tau, domain):\n", + "# # move from edges to nodes\n", + "# tau_x = F_grid.x_average_2D(tau[0])\n", + "# tau_y = F_grid.y_average_2D(tau[1])\n", + "\n", + "# # calculate curl\n", + "# dF2dX = (tau_y[1:] - tau_y[:-1]) / domain.dx\n", + "# dF1dY = (tau_x[:,1:] - tau_x[:,:-1]) / domain.dy\n", + "# curl_stagg = dF2dX - dF1dY\n", + "\n", + "# # move from nodes to faces\n", + "# return F_grid.center_average_2D(curl_stagg)\n", + "\n", + "tau = F_louis.init_tau(domain, tau0=2.0e-5)\n", + "print_debug_quantity(tau, \"Tau\")\n", + "wind_forcing = F_louis.calculate_wind_forcing(tau, domain) / (params.f0 * heights[0])\n", + "print_debug_quantity(wind_forcing, \"wind_forcing\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "ac4709c7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "pts = ax.pcolormesh(wind_forcing)\n", + "plt.colorbar(pts)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d4a91ca0", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Vorticity" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "d2510426-d992-4f44-8f59-509b98596376", + "metadata": {}, + "outputs": [], + "source": [ + "# lap_fn = lambda x: fdx.laplacian(x, step_size=domain.dx, accuracy=1, method=\"central\")\n", + "# lap_p = jax.vmap(lap_fn)(p)\n", + "# print_debug_quantity(lap_p, \"LAPLACIAN\")\n", + "# lap_p_ = laplacian(p, params.zfbc) / (domain.dx**2)\n", + "# print_debug_quantity(lap_p_, \"LAPLACIAN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "a5291d7b-e424-41e6-a002-968f3abe67e2", + "metadata": {}, + "outputs": [], + "source": [ + "# plot_field(lap_p)\n", + "# plot_field(lap_p_)\n", + "# plot_field(np.abs(lap_p_ - lap_p))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "dacff20e-74b9-413b-85d8-6885d98bd6e1", + "metadata": {}, + "outputs": [], + "source": [ + "# lap_fn = lambda x: fdx.laplacian(x, step_size=domain.dx, accuracy=1, method=\"central\")\n", + "# lap_p = jax.vmap(lap_fn)(p)\n", + "# bcs = F_qgml.laplacian_boundaries(lap_p, params.zfbc / (domain.dx**2))\n", + "# lap_p = F_qgml._apply_boundaries(lap_p, bcs)\n", + "# print_debug_quantity(lap_p, \"LAPLACIAN\")\n", + "# lap_p_ = laplacian(p, params.zfbc)\n", + "# lap_p_ = lap_p_ / (domain.dx**2)\n", + "# print_debug_quantity(lap_p_, \"LAPLACIAN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "4f6fea9c-5655-435f-90ee-a483bb06d520", + "metadata": {}, + "outputs": [], + "source": [ + "# plot_field(lap_p)\n", + "# plot_field(lap_p_)\n", + "# plot_field(np.abs(lap_p_ - lap_p))" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "aa358ae1-79cc-4093-859f-831a6a88d75e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 97, 121)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if domain.nx == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.x)\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "p.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "49c2defa", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:19:23.534\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 16:19:23.761\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mVORTICITY: (3, 97, 121) | -4.657202e-01 | -6.788409e-06 | -6.788409e-06 | 4.963626e-01\u001b[0m\n" + ] + } + ], + "source": [ + "print_debug_quantity(p, \"PRESSURE\")\n", + "q = F_louis.pressure_to_vorticity(p, A_mat(), domain, params)\n", + "print_debug_quantity(q, \"VORTICITY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "b1dded12", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(q)" + ] + }, + { + "cell_type": "markdown", + "id": "b30c8523-b8e2-4dc5-a0bd-dde652607df2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## RHS" + ] + }, + { + "cell_type": "markdown", + "id": "3b1e4ab0-86ee-427b-8460-96bb65ee8bd8", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Determinant Jacobian" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "da5fa4c1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:19:45.906\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS DET JACOBIAN: (3, 95, 119) | -1.564097e-06 | -1.405445e-12 | -1.405445e-12 | 1.195297e-06\u001b[0m\n" + ] + } + ], + "source": [ + "rhs = 1.0 / (params.f0 * domain.dx * domain.dy) * F_louis.det_jacobian(q, p)\n", + "print_debug_quantity(rhs, \"RHS DET JACOBIAN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "605cc3ff-ac2f-4e51-bb3d-4e251c24cce2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "markdown", + "id": "5d901bd0-f3dd-493e-9109-02620a5b488b", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Extra Terms" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "58009998-8c5d-4193-af2b-5cfe9eace282", + "metadata": {}, + "outputs": [], + "source": [ + "# def advection_term(p, params, domain):\n", + "# return (1./ (params.f0 * domain.dx * domain.dy)) * F_qgml.det_jacobian(q, p)\n", + "# def diffusion_term(p, params, domain):\n", + "# return params.a_2 / params.f0**2 / domain.dx**4 * F_qgml.laplacian_interior(p)\n", + "\n", + "# def hyperdiffusion_term(p, params, domain):\n", + "# return - (params.a_4 / params.f0**2) / domain.dx**6 * F_qgml.laplacian_interior(F_qgml.laplacian(p, params.zfbc))\n", + "\n", + "\n", + "# def bottom_friction(p, params, domain, height_params):\n", + "# return params.delta_ek / (2*np.abs(params.f0)*domain.dx**2*(-height_params.heights[-1])) * F_qgml.laplacian_interior(p[...,-1:,:,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "21eb5e7d-30b3-4342-9e65-3389a21c4bd5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 16:51:46.306\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS ADVECTION: (3, 95, 119) | -1.564097e-06 | -1.405445e-12 | -1.405445e-12 | 1.195297e-06\u001b[0m\n", + "\u001b[32m2023-07-12 16:51:46.332\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mLAP P TERM: (3, 97, 121) | -2.852461e+00 | -9.280515e-05 | -9.280515e-05 | 3.835035e+00\u001b[0m\n", + "\u001b[32m2023-07-12 16:51:46.352\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS HYPERDIFFUSION: (3, 95, 119) | -7.209133e-07 | -4.914557e-12 | -4.914557e-12 | 6.775439e-07\u001b[0m\n", + "\u001b[32m2023-07-12 16:51:46.355\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mWIND FORCING: (95, 119) | -7.908487e-10 | -9.833974e-26 | -9.833974e-26 | 7.908487e-10\u001b[0m\n", + "\u001b[32m2023-07-12 16:51:46.359\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mBOTTOM FRICTION: (1, 95, 119) | -1.221567e-09 | 4.609835e-13 | 4.609835e-13 | 1.503295e-09\u001b[0m\n", + "\u001b[32m2023-07-12 16:51:46.364\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS: (3, 95, 119) | -7.208723e-07 | -4.760896e-12 | -4.760896e-12 | 6.775439e-07\u001b[0m\n" + ] + } + ], + "source": [ + "# Calculate Determinant Jacobian\n", + "rhs = jnp.asarray([0.0])\n", + "rhs_advection = F_louis.advection_term(q, p, params, domain)\n", + "print_debug_quantity(rhs_advection, \"RHS ADVECTION\")\n", + "# calculate Laplacian\n", + "delta2_p = F_louis.laplacian(p, params.zfbc)\n", + "print_debug_quantity(delta2_p, \"LAP P TERM\")\n", + "\n", + "# Add Diffusion Term\n", + "if params.a_2 != 0.0:\n", + " rhs_diffusion = F_louis.diffusion_term(delta2_p, params, domain)\n", + " print_debug_quantity(rhs_diffusion, \"RHS DIFFUSION\")\n", + " rhs += rhs_diffusion\n", + "\n", + "# Add HyperDiffusion\n", + "if params.a_4 != 0.0:\n", + " rhs_hyperdiffusion = F_louis.hyperdiffusion_term(delta2_p, params, domain)\n", + " print_debug_quantity(rhs_hyperdiffusion, \"RHS HYPERDIFFUSION\")\n", + " rhs += rhs_hyperdiffusion\n", + "\n", + "# Add Wind Forcing\n", + "print_debug_quantity(wind_forcing, \"WIND FORCING\")\n", + "rhs = rhs.at[..., 0:1, :, :].set(rhs[..., 0:1, :, :] + wind_forcing)\n", + "\n", + "# Add Bottom Friction\n", + "bottom_term = F_louis.bottom_friction(p, params, domain, A_mat)\n", + "print_debug_quantity(bottom_term, \"BOTTOM FRICTION\")\n", + "rhs = rhs.at[..., -1:, :, :].set(rhs[..., -1:, :, :] + bottom_term)\n", + "print_debug_quantity(rhs, \"RHS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "290759db", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs_advection)\n", + "plot_field(delta2_p)\n", + "plot_field(rhs_hyperdiffusion)\n", + "# plot_field(wind_forcing)\n", + "# plot_field(bottom_term)" + ] + }, + { + "cell_type": "markdown", + "id": "6163923d-6b08-4112-a0a1-47828be943c7", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Full RHS" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "b20facfd-89c9-4414-b52d-47f384428d28", + "metadata": {}, + "outputs": [], + "source": [ + "# def rhs_pde(q, p, params, domain):\n", + "\n", + "# # Calculate Determinant Jacobian\n", + "# rhs = advection_term(p, params, domain)\n", + "\n", + "# # calculate Laplacian\n", + "# delta2_p = F_qgml.laplacian(p, params.zfbc)\n", + "\n", + "# # Add Diffusion Term\n", + "# if params.a_2 != 0.:\n", + "# rhs += diffusion_term(delta2_p, params, domain)\n", + "\n", + "# # Add HyperDiffusion\n", + "# if params.a_4 != 0.:\n", + "# rhs += hyperdiffusion_term(delta2_p, params, domain)\n", + "\n", + "# # Add Wind Forcing\n", + "# rhs = rhs.at[...,0:1,:,:].set(rhs[...,0:1,:,:] + wind_forcing)\n", + "\n", + "# # Add Bottom Friction\n", + "# rhs = rhs.at[...,-1:,:,:].set(rhs[...,-1:,:,:] + bottom_term)\n", + "\n", + "# return rhs" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "dcb94271-72d2-4386-86c5-6ce443007608", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 17:04:20.270\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS: (3, 95, 119) | -1.502200e-06 | -6.166340e-12 | -6.166340e-12 | 1.339342e-06\u001b[0m\n" + ] + } + ], + "source": [ + "rhs = F_louis.rhs_pde(q, p, params, domain, A_mat, wind_forcing)\n", + "print_debug_quantity(rhs, \"RHS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "74b75cc9-6be6-41e2-8864-0af73bbbc043", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5d6b492e-197c-4cb5-af13-74e5c2120208", + "metadata": {}, + "outputs": [], + "source": [ + "import functools as ft\n", + "\n", + "rhs_fn = ft.partial(\n", + " F_qgml.rhs_pde, params=params, domain=domain, A_mat=A_mat, wind_forcing=wind_forcing\n", + ")\n", + "rhs_jitted = jax.jit(rhs_fn)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "2e39d659-27cd-484a-a046-b05ac4d29934", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "17.2 ms ± 294 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "136 µs ± 2.11 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n" + ] + } + ], + "source": [ + "%timeit out = rhs_fn(q, p)\n", + "%timeit out = rhs_jitted(q, p)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "ac870b43-889d-414c-8c0f-9b7ff8cb1fae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 95, 119)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rhs_fn(q, p).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "00afcdf3-a150-44f6-b032-0909dadf5d43", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 17:29:00.964\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -5.939378e-12 | -5.939378e-12 | 1.339342e-06\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.965\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mrhs_helmholtz: (3, 97, 121) | -8.917592e-07 | 1.125180e-12 | 1.125180e-12 | 9.745410e-07\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.978\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp_modes: (3, 97, 121) | -4.214963e-06 | -1.693218e-08 | -1.693218e-08 | 3.790947e-06\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.980\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1malpha_matrix: (2, 2) | -2.558977e+05 | -1.140663e+05 | -1.140663e+05 | 2.813377e-11\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.981\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdalpha: (2, 1, 1) | -5.508387e-05 | -2.625952e-05 | -2.625952e-05 | 2.564827e-06\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.983\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp_modes: (3, 97, 121) | -4.214963e-06 | -1.702047e-08 | -1.702047e-08 | 3.790947e-06\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.984\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.169436e-06 | 2.948032e-08 | 2.948032e-08 | 5.236780e-06\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.988\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdelta_p_boundaries: (3, 432) | -3.056796e-08 | 5.116894e-11 | 5.116894e-11 | 2.598716e-08\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.995\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.169436e-06 | 2.948032e-08 | 2.948032e-08 | 5.236780e-06\u001b[0m\n", + "\u001b[32m2023-07-12 17:29:00.996\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -8.475099e-12 | -8.475099e-12 | 1.339342e-06\u001b[0m\n" + ] + } + ], + "source": [ + "def rhs_time_step(q, p, params, A_mat, domain):\n", + " # calculate advection - interior only\n", + " dq_f0 = F_louis.rhs_pde(\n", + " q, p, params, domain, A_mat=A_mat, wind_forcing=wind_forcing\n", + " )\n", + " # pad - original domain\n", + " dq_f0 = jnp.pad(dq_f0, ((0, 0), (1, 1), (1, 1)))\n", + " print_debug_quantity(dq_f0, \"dq_f0\")\n", + " # pressure\n", + " rhs_helmholtz = jnp.einsum(\"ij,jkl->ikl\", A_mat.A_layer_2_mode, dq_f0)\n", + " print_debug_quantity(rhs_helmholtz, \"rhs_helmholtz\")\n", + " dp_modes = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))(\n", + " rhs_helmholtz[:, 1:-1, 1:-1], helmoltz_dst_mat\n", + " )\n", + " # pad - original domain\n", + " dp_modes = jnp.pad(dp_modes, ((0, 0), (1, 1), (1, 1)))\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + "\n", + " # ensure mass conservation\n", + " dalpha = alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1))\n", + " print_debug_quantity(alpha_matrix, \"alpha_matrix\")\n", + " dalpha = einops.repeat(dalpha, \"i -> i 1 1\")\n", + " print_debug_quantity(dalpha, \"dalpha\")\n", + " dp_modes = dp_modes.at[..., :-1, :, :].set(\n", + " dp_modes[..., :-1, :, :] + dalpha * homogeneous_sol\n", + " )\n", + " print_debug_quantity(homogeneous_sol, \"homogeneous_sol\")\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + " dp = jnp.einsum(\"ij,jkl->ikl\", A_mat.A_mode_2_layer, dp_modes)\n", + " print_debug_quantity(dp, \"dp\")\n", + "\n", + " # UPDATE VORTICITY @ BOUNDARIES\n", + " delta_p_boundaries = F_qgml.laplacian_boundaries(\n", + " dp / (params.f0 * domain.dx) ** 2, params.zfbc\n", + " )\n", + " print_debug_quantity(delta_p_boundaries, \"delta_p_boundaries\")\n", + " dp_boundaries = jnp.concatenate(\n", + " [dp[..., 0, 1:-1], dp[..., -1, 1:-1], dp[..., :, 0], dp[..., :, -1]], axis=-1\n", + " )\n", + " dq_f0_boundaries = delta_p_boundaries - A_mat.A @ dp_boundaries\n", + "\n", + " dq_f0 = F_qgml._apply_boundaries(dq_f0, dq_f0_boundaries)\n", + "\n", + " return dq_f0, dp\n", + "\n", + "\n", + "args = F_qgml.QGARGS(\n", + " A_mat=A_mat,\n", + " domain=domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + ")\n", + "dq_f0, dp = rhs_time_step(q, p, params, A_mat, domain)\n", + "# dq_f0, dp = rhs_time_step(q, p, params=params, args=args)\n", + "print_debug_quantity(dp, \"dp\")\n", + "print_debug_quantity(dq_f0, \"dq_f0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "273b40b8-d0e1-4a9f-9a39-1e098e7f64a2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "97" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "domain.nx" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e0eee8e7-1131-42c6-bdb4-5f0d70e77d21", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 00:54:27.691\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 00:54:27.697\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mVORTICITY: (3, 97, 121) | -4.657202e-01 | -6.788409e-06 | -6.788409e-06 | 4.963626e-01\u001b[0m\n" + ] + } + ], + "source": [ + "rhs_time_step_jitted = jax.jit(F_qgml.rhs_time_step, static_argnames=(\"params\", \"args\"))\n", + "\n", + "\n", + "# vector field\n", + "def vector_field(t, state, args):\n", + " q, p = state\n", + "\n", + " q, p = rhs_time_step_jitted(q, p, params, args)\n", + "\n", + " return (q, p)\n", + "\n", + "\n", + "if domain.nx == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.x)\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "q = F_qgml.pressure_to_vorticity(p, A_mat(), domain, params)\n", + "print_debug_quantity(q, \"VORTICITY\")\n", + "\n", + "state = (q, p)\n", + "args = F_qgml.QGARGS(\n", + " A_mat=A_mat,\n", + " domain=domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "d36f0d83-644d-46a6-a194-20ec3e74d505", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 00:54:28.090\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.169436e-06 | 2.948032e-08 | 2.948032e-08 | 5.236780e-06\u001b[0m\n", + "\u001b[32m2023-07-12 00:54:28.091\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -8.475099e-12 | -8.475099e-12 | 1.339342e-06\u001b[0m\n" + ] + } + ], + "source": [ + "dq_f0, dp = vector_field(0, state, args)\n", + "print_debug_quantity(dp, \"dp\")\n", + "print_debug_quantity(dq_f0, \"dq_f0\")" + ] + }, + { + "cell_type": "markdown", + "id": "dc9508f4-3ddd-4a46-b3fd-6110267f9ff2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Time Stepping\n", + "\n", + "We're going to use the Heun method.\n", + "I'll also be using `diffrax` to handle the time stepping :)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "988e4234-c444-49a0-a17b-15dad9e8bfae", + "metadata": {}, + "outputs": [], + "source": [ + "dt = 1_200 # LR #600 # HR #\n", + "n_years = 2\n", + "n_days = 365\n", + "tmin = 0\n", + "tmax = pd.to_timedelta(n_years * n_days, unit=\"day\").total_seconds()\n", + "ts = jnp.arange(tmin, tmax, dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "70d59ba6-3cb1-4557-a7ce-379269c31548", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "52560" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ts)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "25a0510c-a635-4b48-bc80-ea59da75e70c", + "metadata": {}, + "outputs": [], + "source": [ + "state = (q, p)\n", + "args = F_qgml.QGARGS(\n", + " A_mat=A_mat,\n", + " domain=domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + ")\n", + "\n", + "solver = dfx.Heun()\n", + "solver_state = solver.init(\n", + " terms=dfx.ODETerm(vector_field),\n", + " t0=tmax,\n", + " t1=tmin + dt,\n", + " y0=state,\n", + " args=args,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "ba30e79b-1ec6-4d91-add1-382910d41ce4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2000" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_check = 2_000\n", + "freq_log = 1_000 # LR #50 # HR #\n", + "n_check" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "5355e16e-6862-4bd1-af6f-593293208943", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "715401312af940eca031b1218d0fc4ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/52560 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (time: 53, layer: 3, x: 97, y: 121)\n",
+       "Coordinates:\n",
+       "  * time     (time) float64 0.0 1.2e+06 2.4e+06 ... 6e+07 6.12e+07 6.24e+07\n",
+       "  * layer    (layer) int64 0 1 2\n",
+       "  * x        (x) float64 0.0 4e+04 8e+04 1.2e+05 ... 3.76e+06 3.8e+06 3.84e+06\n",
+       "  * y        (y) float64 0.0 4e+04 8e+04 1.2e+05 ... 4.72e+06 4.76e+06 4.8e+06\n",
+       "Data variables:\n",
+       "    q        (time, layer, x, y) float64 -0.452 -0.4532 ... 0.4413 0.4489\n",
+       "    p        (time, layer, x, y) float64 0.009725 0.02492 ... 0.008548 0.00464
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 53, layer: 3, x: 97, y: 121)\n", + "Coordinates:\n", + " * time (time) float64 0.0 1.2e+06 2.4e+06 ... 6e+07 6.12e+07 6.24e+07\n", + " * layer (layer) int64 0 1 2\n", + " * x (x) float64 0.0 4e+04 8e+04 1.2e+05 ... 3.76e+06 3.8e+06 3.84e+06\n", + " * y (y) float64 0.0 4e+04 8e+04 1.2e+05 ... 4.72e+06 4.76e+06 4.8e+06\n", + "Data variables:\n", + " q (time, layer, x, y) float64 -0.452 -0.4532 ... 0.4413 0.4489\n", + " p (time, layer, x, y) float64 0.009725 0.02492 ... 0.008548 0.00464" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "\n", + "ds_results = xr.Dataset(\n", + " data_vars={\n", + " \"q\": ((\"time\", \"layer\", \"x\", \"y\"), np.stack(saved_states[\"q\"], axis=0)),\n", + " \"p\": ((\"time\", \"layer\", \"x\", \"y\"), np.stack(saved_states[\"p\"], axis=0)),\n", + " },\n", + " coords={\n", + " \"time\": ((\"time\"), np.stack(saved_states[\"t\"], axis=0)),\n", + " \"layer\": ((\"layer\"), np.arange(3)),\n", + " \"x\": ((\"x\"), np.arange(0, domain.Lx + 1, domain.dx)),\n", + " \"y\": ((\"y\"), np.arange(0, domain.Ly + 1, domain.dy)),\n", + " },\n", + ")\n", + "ds_results" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "f85d69ec-2ce4-4639-acd3-7f6aec53dff5", + "metadata": {}, + "outputs": [], + "source": [ + "from xmovie import Movie\n", + "from pathlib import Path\n", + "from matplotlib import ticker\n", + "\n", + "\n", + "def custom_plot_p_layers(ds, fig, tt, *args, **kwargs):\n", + " sub = ds.isel(time=tt)\n", + "\n", + " xlim = kwargs.pop(\"xlim\", None)\n", + " ylim = kwargs.pop(\"ylim\", None)\n", + " vmin = kwargs.pop(\"vmin\", sub.p.min())\n", + " vmax = kwargs.pop(\"vmax\", sub.p.max())\n", + " cmap = kwargs.pop(\"cmap\", \"viridis\")\n", + "\n", + " fig.set_size_inches(15, 10)\n", + "\n", + " ax = fig.subplots(ncols=3, nrows=2)\n", + "\n", + " for i in range(3):\n", + " # NATL60\n", + " pts = sub.p.isel(layer=i).plot.pcolormesh(\n", + " ax=ax[0, i],\n", + " cmap=\"viridis\",\n", + " add_colorbar=True,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " # **kwargs\n", + " )\n", + "\n", + " loc = ticker.MaxNLocator(6)\n", + " levels = loc.tick_values(vmin, vmax)\n", + " sub.p.isel(layer=i).plot.contour(\n", + " ax=ax[0, i],\n", + " levels=levels,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " alpha=0.5,\n", + " linewidths=1,\n", + " cmap=\"black\",\n", + " linestyles=np.where(levels >= 0, \"-\", \"--\"),\n", + " )\n", + "\n", + " # ax.set_aspect('equal')\n", + " pts = ax[0, i].set(xlabel=\"x [m]\", ylabel=\"y [m]\", title=f\"Layer {i}\")\n", + "\n", + " xlim = kwargs.pop(\"xlim\", None)\n", + " ylim = kwargs.pop(\"ylim\", None)\n", + " vmin = kwargs.pop(\"vmin\", sub.q.min())\n", + " vmax = kwargs.pop(\"vmax\", sub.q.max())\n", + " cmap = kwargs.pop(\"cmap\", \"viridis\")\n", + "\n", + " for i in range(3):\n", + " # NATL60\n", + " pts = sub.q.isel(layer=i).plot.pcolormesh(\n", + " ax=ax[1, i],\n", + " cmap=\"RdBu_r\",\n", + " add_colorbar=True,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " # **kwargs\n", + " )\n", + "\n", + " loc = ticker.MaxNLocator(6)\n", + " levels = loc.tick_values(vmin, vmax)\n", + " sub.q.isel(layer=i).plot.contour(\n", + " ax=ax[1, i],\n", + " levels=levels,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " alpha=0.5,\n", + " linewidths=1,\n", + " cmap=\"black\",\n", + " linestyles=np.where(levels >= 0, \"-\", \"--\"),\n", + " )\n", + "\n", + " # ax.set_aspect('equal')\n", + " pts = ax[0, i].set(xlabel=\"x [m]\", ylabel=\"y [m]\", title=f\"Layer {i}\")\n", + " plt.tight_layout()\n", + " return None, None\n", + "\n", + "\n", + "from pathlib import Path\n", + "\n", + "\n", + "def create_movie(\n", + " var,\n", + " name,\n", + " plotfunc=custom_plot_p_layers,\n", + " framedim: str = \"steps\",\n", + " file_path=None,\n", + " **kwargs,\n", + "):\n", + " if file_path is not None:\n", + " file_name = Path(file_path).joinpath(f\"movie_{name}.gif\")\n", + " else:\n", + " file_name = Path(f\"./movie_{name}.gif\")\n", + "\n", + " mov = Movie(\n", + " var, plotfunc=plotfunc, framedim=framedim, **kwargs, dpi=200, input_check=False\n", + " )\n", + " mov.save(\n", + " file_name,\n", + " remove_movie=False,\n", + " progress=True,\n", + " framerate=3,\n", + " gif_framerate=3,\n", + " overwrite_existing=True,\n", + " gif_resolution_factor=0.5,\n", + " parallel=False,\n", + " )\n", + "\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a5a1d23-1cc6-4a3d-9e51-b4cf45bd4558", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "06b4c4c0-3b49-44b0-b11a-d11431fc67a9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_46186/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_46186/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_46186/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_46186/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "mov = Movie(\n", + " ds_results.transpose(\"time\", \"layer\", \"y\", \"x\"),\n", + " plotfunc=custom_plot_p_layers,\n", + " framedim=\"time\",\n", + " input_check=False,\n", + ")\n", + "mov.preview(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "5b6f4726-ca13-40a7-a7e1-8c54b66b2a0d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# create_movie(\n", + "# ds_results.transpose(\"time\", \"layer\", \"y\", \"x\"), #.sel(time=slice(\"2017-02-01\", \"2017-03-01\")),\n", + "# name=\"pressure_vorticity\",\n", + "# plotfunc=custom_plot_p_layers,\n", + "# file_path=\"./\",\n", + "# framedim=\"time\",\n", + "# cmap=\"viridis\",\n", + "# robust=True,\n", + "# )" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "jaxsw", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/dev/eman/QG/multilayer_qg_refactored.ipynb b/notebooks/dev/eman/QG/multilayer_qg_refactored.ipynb new file mode 100644 index 0000000..632ebd1 --- /dev/null +++ b/notebooks/dev/eman/QG/multilayer_qg_refactored.ipynb @@ -0,0 +1,2453 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d5bca1fd-b90e-43b2-90ba-4cf6ea2a6884", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "# Multilayer QG - Refactored" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ef9b5897-79b7-41ac-8476-44ccc04243e1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eman/miniconda3/envs/jaxsw/lib/python3.11/site-packages/equinox/_ad.py:733: UserWarning: As of Equinox 0.10.7, `equinox.filter_custom_vjp.defvjp` is deprecated in favour of `.def_fwd` and `.def_bwd`. This new API supports symbolic zeros, which allow for more efficient autodifferentiation rules. In particular:\n", + "- the fwd and bwd functions take an extra `perturbed` argument, which indicates which primals actually need a gradient. You can use this to skip computing the gradient for any unperturbed value. (You can also safely just ignore this if you wish.)\n", + "- `None` was previously passed to indicate a symbolic zero gradient for all objects that weren't inexact arrays, but all inexact arrays always had an array-valued gradient. Now, `None` may also be passed to indicate that an inexact array has a symbolic zero gradient.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "import autoroot\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.scipy as jsp\n", + "from jax.config import config\n", + "import numpy as np\n", + "import numba as nb\n", + "import pandas as pd\n", + "import equinox as eqx\n", + "import finitediffx as fdx\n", + "import diffrax as dfx\n", + "import xarray as xr\n", + "import einops\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from einops import rearrange, repeat, reduce\n", + "from tqdm.notebook import tqdm, trange\n", + "from jaxtyping import Array, Float\n", + "\n", + "from jaxsw._src.domain.base import Domain\n", + "from jaxsw._src.operators.functional import advection as F_adv\n", + "from jaxsw._src.operators.functional import geostrophic as F_geos\n", + "from jaxsw._src.operators.functional import cgrid as F_cgrid\n", + "from jaxsw._src.operators.functional import grid as F_grid\n", + "from jaxsw._src.boundaries.helmholtz import enforce_boundaries_helmholtz\n", + "from jaxsw._src.models import qg_louis as F_louis\n", + "from jaxsw._src.models import qg_ml as F_qgml\n", + "\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=0.7)\n", + "config.update(\"jax_enable_x64\", True)\n", + "\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1441015d", + "metadata": {}, + "outputs": [], + "source": [ + "from loguru import logger\n", + "\n", + "\n", + "def plot_field(field):\n", + " num_axis = len(field)\n", + " fig, ax = plt.subplots(ncols=num_axis, figsize=(8, 3))\n", + "\n", + " for i in range(num_axis):\n", + " pts = ax[i].pcolormesh(field[i], cmap=\"coolwarm\")\n", + " plt.colorbar(pts)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def print_debug_quantity(quantity, name=\"\"):\n", + " size = quantity.shape\n", + " min_ = np.min(quantity)\n", + " max_ = np.max(quantity)\n", + " mean_ = np.mean(quantity)\n", + " median_ = np.mean(quantity)\n", + " logger.debug(\n", + " f\"{name}: {size} | {min_:.6e} | {mean_:.6e} | {median_:.6e} | {max_:.6e}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "0dc829a9-a35c-49ca-8f95-aedb5ff5f61c", + "metadata": { + "user_expressions": [] + }, + "source": [ + "In this problem, we are looking at sea surface height (SSH) in relation to the Quasi-Geostrophic (QG) equations. These equations are a simplified form for the Navier-Stokes equations with approximations like *hydrostatic approximation*, *small aspect ratio*, and a *small Rossby number*. Ideally, these equations might be a decent approximation at mesoscale (100km - 10,000km). In this application, we will see how SSH propagates with the QG equations." + ] + }, + { + "cell_type": "markdown", + "id": "692a7d6b-1de0-462e-9fe8-34a5105eec5b", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Equations\n", + "\n", + "\n", + "$$\n", + "\\partial_t q_k + (u_kq_k)_x + (v_kq_k)_y = F_k + D_k\n", + "$$ (eq:qg_form_adv)\n", + "\n", + "The term that links each of the layers together, $\\mathbf{A}$, is a tri-diagonal matrix that can be written as\n", + "\n", + "$$\n", + "\\mathbf{A} =\n", + "\\begin{bmatrix}\n", + "\\frac{1}{H_1 g_1'} & \\frac{-1}{H_1 g_2'} & \\ldots & \\ldots & \\ldots \\\\\n", + "\\frac{-1}{H_2 g_1'} & \\frac{1}{H_1}\\left(\\frac{1}{g_1'} + \\frac{1}{g_2'} \\right) & \\frac{-1}{H_2 g_2'} & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\ldots & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\frac{-1}{H_{n-1} g_{n-2}'} & \\frac{1}{H_{n-1}}\\left(\\frac{1}{g_{n-2}'} + \\frac{1}{g_{n-1}'} \\right) & \\frac{-1}{H_{n-1} g_{n-2}'} \\\\\n", + "\\ldots & \\ldots& \\ldots & \\frac{-1}{H_n g_{n-1}'} & \\frac{1}{H_n g_{n-1}'} \\\\\n", + "\\end{bmatrix}\n", + "$$ (eq:qg_A)\n", + "\n", + "In the paper [[Thiry et al., 2023](https://doi.org/10.22541/essoar.167397445.54992823/v1)], they use the following method\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\text{Hyperviscosity}: && \n", + "\\boldsymbol{D_1} &= \n", + "-a_4\\boldsymbol{\\nabla}_H^6\\psi\\\\\n", + "\\text{Wind Forcing}: && \n", + "\\boldsymbol{F} &= \n", + "\\frac{\\tau_0}{\\rho_0H_1}\\left[\\partial_x\\tau_y - \\partial_y\\tau_x, 0\\cdots,0\\right]\\\\\n", + "\\text{Bottom Drag}: && \n", + "\\boldsymbol{D_2} &= \n", + "\\frac{\\delta_{ek}}{2H_{N_Z}}\n", + "\\left[0,\\cdots,0,\\Delta\\psi_N\\right]\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "Source:\n", + "* [Geophysical Fluid Dynamcis - Pedlosky](https://doi.org/10.1007/978-1-4612-4650-3)\n", + "* [Atmosphere and Oceanic Fluid Dynamics - Vallis](https://doi.org/10.1017/9781107588417)" + ] + }, + { + "cell_type": "markdown", + "id": "21f846ac", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4e9d4f12", + "metadata": {}, + "outputs": [], + "source": [ + "a_4 = 5.0e11 # 2.0e9 #\n", + "params = F_qgml.PDEParams(a_4=a_4)" + ] + }, + { + "cell_type": "markdown", + "id": "f589e7b9-e033-41e7-b122-6d0a9ca6e8c8", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Domain" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "070b4a1d", + "metadata": {}, + "outputs": [], + "source": [ + "# Low Resolution\n", + "Nx, Ny = 97, 121\n", + "# High Resolution\n", + "# Nx, Ny = 769, 961\n", + "\n", + "Lx, Ly = 3840.0e3, 4800.0e3\n", + "\n", + "# initialize domain\n", + "domain = Domain.from_numpoints(xmin=(0, 0), xmax=(Lx, Ly), N=(Nx, Ny))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7345b7ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((40000.0, 40000.0), (97, 121), (3840000.0, 4800000.0), 1600000000.0, 2)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "domain.dx, domain.Nx, domain.Lx, domain.cell_volume, domain.ndim" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "563e5026", + "metadata": {}, + "outputs": [], + "source": [ + "# # initialize domain\n", + "# # domain = Domain.from_numpoints(xmin=(0, 0), xmax=(Lx, Ly), N=(Nx+1, Ny+1))\n", + "# domain = F_qgml.Domain(nx=Nx, ny=Ny, Lx=Lx, Ly=Ly)\n", + "\n", + "# domain.dx" + ] + }, + { + "cell_type": "markdown", + "id": "6575c549", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Heights\n" + ] + }, + { + "cell_type": "markdown", + "id": "22482952", + "metadata": { + "user_expressions": [] + }, + "source": [ + "$$\n", + "\\mathbf{A} =\n", + "\\begin{bmatrix}\n", + "\\frac{1}{H_1 g_1'} & \\frac{-1}{H_1 g_2'} & \\ldots & \\ldots & \\ldots \\\\\n", + "\\frac{-1}{H_2 g_1'} & \\frac{1}{H_1}\\left(\\frac{1}{g_1'} + \\frac{1}{g_2'} \\right) & \\frac{-1}{H_2 g_2'} & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\ldots & \\ldots & \\ldots \\\\\n", + "\\ldots & \\ldots & \\frac{-1}{H_{n-1} g_{n-2}'} & \\frac{1}{H_{n-1}}\\left(\\frac{1}{g_{n-2}'} + \\frac{1}{g_{n-1}'} \\right) & \\frac{-1}{H_{n-1} g_{n-2}'} \\\\\n", + "\\ldots & \\ldots& \\ldots & \\frac{-1}{H_n g_{n-1}'} & \\frac{1}{H_n g_{n-1}'} \\\\\n", + "\\end{bmatrix}\n", + "$$ (eq:qg_A)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f8be78a1", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.domain.qg import LayerDomain\n", + "\n", + "# heights\n", + "heights = [350.0, 750.0, 2900.0]\n", + "\n", + "# reduced gravities\n", + "reduced_gravities = [0.025, 0.0125]\n", + "\n", + "layer_domain = LayerDomain(heights, reduced_gravities)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4d2e629f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[ 0.11428571, -0.11428571, 0. ],\n", + " [-0.05333333, 0.16 , -0.10666667],\n", + " [ 0. , -0.02758621, 0.02758621]], dtype=float64)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "layer_domain.A" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3aa8fcc3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array([ 2.28183707e-01, 7.36882145e-02, -4.04361683e-18], dtype=float64),\n", + " Array([[-0.43193138, 0.92242719, -0.49049581],\n", + " [-0.65802762, -0.50089268, 1.15892029],\n", + " [-0.15155445, -0.32475953, -1.25573684]], dtype=float64),\n", + " Array([[-0.70499319, -0.92396019, -0.57735027],\n", + " [ 0.70260146, -0.32821664, -0.57735027],\n", + " [-0.09662189, 0.19639605, -0.57735027]], dtype=float64))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "layer_domain.lambd, layer_domain.A_layer_2_mode, layer_domain.A_mode_2_layer" + ] + }, + { + "cell_type": "markdown", + "id": "ac3e4aab", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Helmholtz Matrices" + ] + }, + { + "cell_type": "markdown", + "id": "9c3e969b", + "metadata": { + "user_expressions": [] + }, + "source": [ + "We can precompute the Helmoltz matrices\n", + "\n", + "$$\n", + "\\text{Helmholtz}:=\\left(\\alpha\\boldsymbol{\\nabla}-\\beta\\right)u\n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\alpha &= \\frac{1}{f_0^2} \\\\\n", + "\\beta &= \\lambda\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8bafc984", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.operators.functional import elliptical as F_elliptical" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c6733cba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([ 2.28183707e-01, 7.36882145e-02, -4.04361683e-18], dtype=float64)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "layer_domain.lambd" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9552abdc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:29.460\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mhelmholtz: (95, 119) | -7.969477e-01 | -5.126282e-01 | -5.126282e-01 | -2.283086e-01\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:29.462\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mhelmholtz: (95, 119) | -6.424522e-01 | -3.581327e-01 | -3.581327e-01 | -7.381310e-02\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:29.464\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mhelmholtz: (95, 119) | -5.687640e-01 | -2.844445e-01 | -2.844445e-01 | -1.248847e-04\u001b[0m\n" + ] + } + ], + "source": [ + "# create Helmholtz Matrix\n", + "helmoltz_dst_mat = F_qgml.create_qgml_helmholtz_matrix(\n", + " domain, layer_domain.lambd, params.f0\n", + ")\n", + "\n", + "print_debug_quantity(helmoltz_dst_mat[0], \"helmholtz\")\n", + "print_debug_quantity(helmoltz_dst_mat[1], \"helmholtz\")\n", + "print_debug_quantity(helmoltz_dst_mat[2], \"helmholtz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "51faa09b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(helmoltz_dst_mat)" + ] + }, + { + "cell_type": "markdown", + "id": "bacab1f1", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Inversion" + ] + }, + { + "cell_type": "markdown", + "id": "38ec22c4", + "metadata": {}, + "source": [ + "We are interested in solving for the Helmholtz equation which is given by\n", + "\n", + "$$\n", + "(\\boldsymbol{\\alpha\\nabla}_H^2 - \\boldsymbol{\\beta})p = q\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0c044b45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 95, 119)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "helmoltz_dst_mat.shape" + ] + }, + { + "cell_type": "markdown", + "id": "3e8c94d6", + "metadata": {}, + "source": [ + "#### Homogeneous Solution" + ] + }, + { + "cell_type": "markdown", + "id": "cbe1b411", + "metadata": {}, + "source": [ + "First, we need to use the scheme to solve the homogeneous Helmholtz equation for the baroclinic nodes.\n", + "The homoegeneous equation is given by:\n", + "\n", + "$$\n", + "(\\boldsymbol{\\nabla}_H^2 - \\boldsymbol{\\beta})p = 0\n", + "$$\n", + "\n", + "Let's reformulate the pressure to be:\n", + "\n", + "$$\n", + "p = \\mathbf{L} + \\beta s\n", + "$$\n", + "\n", + "where $\\mathbf{L}$ is a known solution of the Laplace's equation with non-zero boundaries.\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\boldsymbol{\\nabla}_H^2\\mathbf{L} &= 0 && && x\\in\\Omega\\\\\n", + "\\boldsymbol{F}_{BC}(\\mathbf{L}) &= b && && x\\in\\partial\\Omega\\\\\n", + "\\end{aligned}\n", + "$$\n", + "\n", + " which is non\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "103c99e6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:30.258\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1m: (2, 97, 121) | -3.576361e-12 | 4.449322e-06 | 4.449322e-06 | 8.520065e-05\u001b[0m\n" + ] + } + ], + "source": [ + "homogeneous_sol = F_qgml.helmholtz_homogeneous_sol_multilayer(\n", + " helmoltz_dst_mat, layer_domain.lambd, domain\n", + ")\n", + "print_debug_quantity(homogeneous_sol)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "72632456", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(homogeneous_sol)" + ] + }, + { + "cell_type": "markdown", + "id": "7e67f679", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Alpha Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "977e4e24", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:30.618\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1m: (2, 2) | -2.558977e+05 | -1.140663e+05 | -1.140663e+05 | 2.813377e-11\u001b[0m\n" + ] + } + ], + "source": [ + "alpha_matrix = F_qgml.compute_alpha_matrix(layer_domain.A_mode_2_layer, homogeneous_sol)\n", + "\n", + "print_debug_quantity(alpha_matrix)" + ] + }, + { + "cell_type": "markdown", + "id": "903d7d5e", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Forcing" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f316ab30", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:30.658\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mTau: (2, 97, 121) | -1.999326e-05 | 3.348584e-22 | 3.348584e-22 | 2.000000e-05\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:31.571\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mwind_forcing: (95, 119) | -7.905821e-10 | 4.311263e-13 | 4.311263e-13 | 7.905821e-10\u001b[0m\n" + ] + } + ], + "source": [ + "from jaxsw._src.forcing import wind as F_wind\n", + "\n", + "tau = F_wind.init_tau(domain, tau0=2.0e-5)\n", + "print_debug_quantity(tau, \"Tau\")\n", + "wind_forcing = F_wind.calculate_wind_forcing(tau, domain) / (params.f0 * heights[0])\n", + "print_debug_quantity(wind_forcing, \"wind_forcing\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f51f9db0", + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_wind_forcing(tau, domain):\n", + " # move from edges to nodes\n", + " tau_x = F_grid.x_average_2D(tau[0])\n", + " tau_y = F_grid.y_average_2D(tau[1])\n", + "\n", + " # calculate curl\n", + " dF2dX = (tau_y[1:] - tau_y[:-1]) / domain.dx[0]\n", + " dF1dY = (tau_x[:, 1:] - tau_x[:, :-1]) / domain.dx[1]\n", + " curl_stagg = dF2dX - dF1dY\n", + "\n", + " # move from nodes to faces\n", + " return F_grid.center_average_2D(curl_stagg)\n", + "\n", + "\n", + "wind_forcing = calculate_wind_forcing(tau, domain)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0b88b88f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "pts = ax.pcolormesh(wind_forcing)\n", + "plt.colorbar(pts)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f0f5575b", + "metadata": {}, + "source": [ + "## Pressure" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "16df2ab7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 97, 121)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if domain.Nx[0] == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "p.shape" + ] + }, + { + "cell_type": "markdown", + "id": "d4a91ca0", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Vorticity" + ] + }, + { + "cell_type": "markdown", + "id": "37ce0a2f", + "metadata": {}, + "source": [ + "$$\n", + "f_0 q = (\\boldsymbol{\\nabla}_H^2 - f_0^2A)p + f_0\\beta(y-y_0)\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2c69a72f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:33.131\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:33.167\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mVORTICITY: (3, 97, 121) | -4.657202e-01 | -6.053233e-06 | -6.053233e-06 | 4.963626e-01\u001b[0m\n" + ] + } + ], + "source": [ + "import functools as ft\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "print_debug_quantity(q, \"VORTICITY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b1dded12", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(p)\n", + "plot_field(q)" + ] + }, + { + "cell_type": "markdown", + "id": "b30c8523-b8e2-4dc5-a0bd-dde652607df2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## RHS" + ] + }, + { + "cell_type": "markdown", + "id": "37e6fb82", + "metadata": {}, + "source": [ + "$$\n", + "\\begin{aligned}\n", + "\\text{Advection}: && \n", + "\\boldsymbol{D_1} &= \n", + "-\\frac{1}{f_0}\\boldsymbol{J}(q,p)\\\\\n", + "\\text{Diffusion}: && \n", + "\\boldsymbol{D_2} &= \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\\\\\n", + "\\text{HyperDiffusion}: && \n", + "\\boldsymbol{D_2} &= \n", + "-\\frac{a_4}{f_0}\\boldsymbol{\\nabla}_H^6\\psi\\\\\n", + "\\text{Wind Forcing}: && \n", + "\\boldsymbol{F} &= \n", + "\\frac{\\tau_0}{\\rho_0H_1}\\left[\\partial_x\\tau_y - \\partial_y\\tau_x, 0\\cdots,0\\right]\\\\\n", + "\\text{Bottom Drag}: && \n", + "\\boldsymbol{D_2} &= \n", + "\\frac{\\delta_{ek}}{2H_{N_Z}}\n", + "\\left[0,\\cdots,0,\\Delta\\psi_N\\right]\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "3b1e4ab0-86ee-427b-8460-96bb65ee8bd8", + "metadata": { + "user_expressions": [] + }, + "source": [ + "#### Advection Term\n", + "\n", + "$$\n", + "\\boldsymbol{D_1} = \n", + "-\\frac{1}{f_0}\\boldsymbol{J}(q,p)\n", + "$$\n", + "\n", + "Here, we will use the (determinant) Jacobian to calculate this." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "38fd3114", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.operators.functional.advection import det_jacobian" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "96146c01", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:33.874\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:33.876\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mVORTICITY: (3, 97, 121) | -4.657202e-01 | -6.053233e-06 | -6.053233e-06 | 4.963626e-01\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:33.919\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS ADVECTION: (3, 95, 119) | -1.564097e-06 | -2.804566e-12 | -2.804566e-12 | 1.195297e-06\u001b[0m\n" + ] + } + ], + "source": [ + "rhs_advection = (1 / params.f0) * det_jacobian(q, p, domain.dx[0], domain.dx[1])\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "print_debug_quantity(q, \"VORTICITY\")\n", + "print_debug_quantity(rhs_advection, \"RHS ADVECTION\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "48526664", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs_advection)" + ] + }, + { + "cell_type": "markdown", + "id": "2ef48ac3", + "metadata": {}, + "source": [ + "#### Diffusion Term\n", + "\n", + "$$\n", + "\\boldsymbol{D_2} = \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "0b2167a9", + "metadata": {}, + "source": [ + "#### HyperDiffusion Term\n", + "\n", + "$$\n", + "\\boldsymbol{D_2} = \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "e47f41ef", + "metadata": {}, + "source": [ + "**Wind Stress**\n", + "\n", + "$$\n", + "\\boldsymbol{F} = \n", + "\\frac{\\tau_0}{\\rho_0H_1}\\left[\\partial_x\\tau_y - \\partial_y\\tau_x, 0\\cdots,0\\right]^\\top\n", + "$$\n", + "\n", + "**Bottom Friction Term**\n", + "\n", + "$$\n", + "\\boldsymbol{D_2} = \n", + "\\frac{a_2}{f_0}\\boldsymbol{\\nabla}_H^4\\psi\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "b94a3cce", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:34.327\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mPRESSURE: (3, 97, 121) | -4.332182e+00 | 3.335592e-02 | 3.335592e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:34.706\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mRHS: (3, 95, 119) | -1.502200e-06 | -7.205300e-12 | -7.205300e-12 | 1.339382e-06\u001b[0m\n" + ] + } + ], + "source": [ + "print_debug_quantity(p, \"PRESSURE\")\n", + "rhs = F_qgml.rhs_pde(\n", + " q, jnp.asarray(p), bc_fn, params, layer_domain, domain, wind_forcing\n", + ")\n", + "print_debug_quantity(rhs, \"RHS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "74b75cc9-6be6-41e2-8864-0af73bbbc043", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "markdown", + "id": "04719607", + "metadata": {}, + "source": [ + "## Time Step" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "54d52da6", + "metadata": {}, + "outputs": [], + "source": [ + "import typing as tp\n", + "\n", + "\n", + "class QGState(tp.NamedTuple):\n", + " q: Array\n", + " p: Array\n", + "\n", + "\n", + "class QGARGS(tp.NamedTuple):\n", + " params: tp.NamedTuple\n", + " domain: Domain\n", + " layer_domain: LayerDomain\n", + " wind_forcing: Array\n", + " helmoltz_dst_mat: Array\n", + " alpha_matrix: Array\n", + " homogeneous_sol: Array\n", + " bc_fn: tp.Callable" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "bec25f44", + "metadata": {}, + "outputs": [], + "source": [ + "if domain.Nx[0] == 97:\n", + " p = jnp.asarray(\n", + " np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + " )\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "import functools as ft\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)\n", + "\n", + "state_init = F_qgml.QGState(p=p, q=q)\n", + "\n", + "args = F_qgml.QGARGS(\n", + " domain=domain,\n", + " layer_domain=layer_domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst_mat=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + " bc_fn=bc_fn,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "43d0178b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:47:35.234\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.185125e-06 | 2.919435e-08 | 2.919435e-08 | 5.175048e-06\u001b[0m\n", + "\u001b[32m2023-07-12 18:47:35.235\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -8.966964e-12 | -8.966964e-12 | 1.339382e-06\u001b[0m\n" + ] + } + ], + "source": [ + "import typing as tp\n", + "\n", + "\n", + "def pde_time_step(t, state, args):\n", + " # unpack state\n", + " p, q = state.p, state.q\n", + "\n", + " # RHS of PDE for Q (INTERIOR)\n", + " dq_f0 = F_qgml.rhs_pde(\n", + " q,\n", + " p,\n", + " bc_fn=bc_fn,\n", + " params=args.params,\n", + " layer_domain=args.layer_domain,\n", + " domain=args.domain,\n", + " wind_forcing=args.wind_forcing,\n", + " )\n", + " print_debug_quantity(dq_f0, \"dq_f0\")\n", + " # pad for original domain\n", + " dq_f0 = jnp.pad(dq_f0, ((0, 0), (1, 1), (1, 1)))\n", + "\n", + " # PRESSURE (INTERIOR)\n", + " rhs_helmholtz = jnp.einsum(\"ij,jkl->ikl\", args.layer_domain.A_layer_2_mode, dq_f0)\n", + " print_debug_quantity(rhs_helmholtz, \"rhs_helmholtz\")\n", + " dp_modes = jax.vmap(F_elliptical.inverse_elliptic_dst, in_axes=(0, 0))(\n", + " rhs_helmholtz[:, 1:-1, 1:-1], args.helmoltz_dst_mat\n", + " )\n", + "\n", + " dp_modes = jnp.pad(dp_modes, ((0, 0), (1, 1), (1, 1)))\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + "\n", + " # ensure mass conservation\n", + " print_debug_quantity(args.alpha_matrix, \"alpha_matrix\")\n", + " dalpha = args.alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1))\n", + " dalpha = einops.repeat(dalpha, \"i -> i 1 1\")\n", + " print_debug_quantity(dalpha, \"dalpha\")\n", + " print_debug_quantity(args.homogeneous_sol, \"homogeneous_sol\")\n", + " dp_modes = dp_modes.at[..., :-1, :, :].set(\n", + " dp_modes[..., :-1, :, :] + dalpha * args.homogeneous_sol\n", + " )\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + " dp = jnp.einsum(\"ij,jkl->ikl\", args.layer_domain.A_mode_2_layer, dp_modes)\n", + " print_debug_quantity(dp, \"dp\")\n", + "\n", + " delta_p_boundaries = args.bc_fn(dp / (params.f0 * args.domain.dx[0]) ** 2)\n", + " print_debug_quantity(delta_p_boundaries, \"delta_p_boundaries\")\n", + "\n", + " # apply boundaries\n", + " print(delta_p_boundaries.shape, args.layer_domain.A.shape, dp.shape)\n", + " dq_f0_boundaries = delta_p_boundaries - jnp.einsum(\n", + " \"ij,jkl->ikl\", args.layer_domain.A, dp\n", + " )\n", + "\n", + " dq_f0 = F_qgml.apply_boundaries(dq_f0, dq_f0_boundaries)\n", + "\n", + " return dp, q\n", + "\n", + "\n", + "out_state = F_qgml.pde_time_step(p, q, params, args)\n", + "print_debug_quantity(out_state[0], \"dp\")\n", + "print_debug_quantity(out_state[1], \"dq_f0\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "e71b5af3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxAAAAEaCAYAAACB/bGyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9fZQkV33fj78+996q7p7ZXe2utAJhBFoBEdIS4ItMIh/iYBkbsBMkY/NkG46DiZDhGAcFnBgsG5sYA8ccHgIYYzCObTg8x5FkYmESwUmCj+NfJGxsSWAEkgDrYZG0q92d6e6quvf+/rj3VlX3zOzMSKvV7ux9n9Nnprvr4VZ11aeqPu/P+/0R770nIyMjIyMjIyMjIyNjA1AP9wAyMjIyMjIyMjIyMk4e5AeIjIyMjIyMjIyMjIwNIz9AZGRkZGRkZGRkZGRsGPkBIiMjIyMjIyMjIyNjw8gPEBkZGRkZGRkZGRkZG0Z+gMjIyMjIyMjIyMjI2DDyA0RGRkZGRkZGRkZGxoaRHyAyMjIyMjIyMjIyMjaM/ACRkZGRkZGRkZGRkbFh5AeIjOOG7373u7zmNa/hB37gB1hYWEBEuO222477OMbjMb/+67/O4x//eAaDAY94xCP41//6X1NV1XEfS0bGqYocDzIyMvrIMeHkgnm4B5Bx6uCWW27hU5/6FBdeeCE/+IM/yF/8xV8c9zFUVcWzn/1svv3tb/OGN7yBCy64gO9973t84QtfwFp73MeTkXGqIseDjIyMPnJMOLmQHyAyjhv+5b/8l9x9990AfPjDH35YgsM73vEO/vZv/5Ybb7yRs88+u/38p37qp477WDIyTmXkeJCRkdFHjgknF3IJU8Zxg1IbO9zuueceXvWqV/F93/d9DAYDnvjEJ/L7v//7x2QMH/jAB3jhC184ExgyMjKOP3I8yMjI6CPHhJML+QEi44TCoUOHeMYznsHnPvc5fuM3foPPfe5zPO95z+NVr3oV733vex/Usr/97W/z3e9+l3PPPZfLLruMHTt2MBwO+eEf/mFuuOGGY7QFGRkZxwo5HmRkZPSRY8KJg1zClHFC4T3veQ+33347f/d3f8cTnvAEAH7kR36EgwcP8pu/+Zu86lWvwpgHdtjecccdALz97W/n6U9/Op/4xCeYTqe86U1v4lnPehb/8A//wJ49e47ZtmRkZDw45HiQkZHRR44JJw4yA5FxQuHaa6/ln//zf87evXtpmqZ9Pec5z+Hee+/lpptuAuBrX/saIrLu65xzzmmX7ZwDYGFhgWuuuYYf//Ef5/nPfz6f+9znWF5e5j//5//8cGxyRkbGGsjxICMjo48cE04cZAYi44TC/v37ueWWWyiKYtXv7733XgDOPfdcbr755nWX11/O6aefDsAznvEMFhYW2s/PPvtsnvjEJ/J3f/d3D2boGRkZxxg5HmRkZPSRY8KJg/wAkXFC4fTTT+fMM8/kPe95z6rfn3feeQCUZckTn/jETS373HPPZTQaISIrvvPeM5lMNj/gjIyMhww5HmRkZPSRY8KJg/wAkXFC4bnPfS7vfe97ecxjHsOZZ555TJddFAX/6l/9K/7X//pfLC0tsbi4CATh1Ne//nUuvfTSY7q+jIyMB4ccDzIyMvrIMeHEgXjv/cM9iIxTB5/5zGcA+J//83/ye7/3e/zu7/4ue/bsYc+ePTzzmc/k/vvv56KLLsI5xxVXXMF5553H0tISX/va1/jf//t/c9VVVz2o9d900038s3/2z/j+7/9+Xve61zGZTPjN3/xNvve97/HVr36VRzziEcdiMzMyMjaAHA8yMjL6yDHhJILPyDiOAFZ9PfOZz2ynue+++/xrX/taf8455/iiKPyePXv8v/gX/8K/613vOiZj+Ou//mv/Qz/0Q340GvkdO3b4Sy+91H/jG984JsvOyMjYOHI8yMjI6CPHhJMHmYHIyMjIyMjIyMjIyNgwso1rRkZGRkbGccJ3v/tdXvOa1/ADP/ADLCwsICLcdtttG5rXOcdb3vIWzjnnHIbDIU95ylPako+MjIyM44n8AJGRkZGRkXGccMstt/CpT32KXbt28YM/+IObmveNb3wjb37zm/nFX/xF/vzP/5yLLrqIF73oRVxzzTUP0WgzMjIyVsdJXcJ0zjnnsH//fobDIXv37n24h5PxMOHWW29lMplw5plnrprJ+9mf/Vm+9rWvbWqZT3ziE/nYxz52jEaYcTyQ40FGwrGOCccyHjjnUCrk7j784Q9z2WWXceutt840tFoN+/fv5+yzz+ZXfuVX+M3f/M328x/+4R9m//79/P3f//0xGd9WQo4JGZDvER4qnNQ2rvv372c8HjMejzlw4MDDPZyMhxn79+9f9fOvfe1r3HDDDcd5NBnHGzkeZMzjRIwJ6eFhs7j22mupqoqXvvSlM5+/7GUv4+d//ue59dZb803yHHJMyOjjRIwHJzNO6geI4XDIeDxmOBzyuMc97uEeTsbDhG9+85tMJhOGw+FRpxsgPFrKo07zXV8x5aQl5U5ppHgwGpScd86jH+7hZDyM+Ppt32U8rR50TDiR4sGNN97IYDDg8Y9//Mzn+/btA4L9ZH6AmEX/HuEJ5+Z9c6riG9+6Nd8jPAQ4qR8g9u7dy4EDB3jc4x7HVVdf/YCXI+tUcflVuhICeL/65w8GIivHstr45DgdwJ7ZbZzfFw9mH8xva387N7p9HuGSSy/lxhtvXPfiebYe8L7Tzj3qNL94/7e4xeZukycjUjw475xH87//y7ugd6x6iVnf/vEbjzfxrn3f/g/Q/z8hLqe/vFWX3U638rMVmFtPex54NzvGNL44fTud68Z/1LGvgQ3Hv/52KhU+F4VXOuyD+L6dZ63tnVm4W7G97ba6phufi/uiP/38GJUO41Kaf/Hy1/E3X//Wg44JKR7cfPPNXHjhhetvT8QrX/lKLr/88g1PvxEcOHCAnTt3ruiSu3v3bgDuu+++Y7q+rYAUE57wuL389//6Kbyo9pqWzluPtNeb/vkvhGMx/J2LDRFe1Mw57pF2Hf3l9/8P863W6VhWvSb2x9Yf0+xnfvb7FDdYIw4c5Zyf3wczs83tO0RwEs7/8De+p/u82wcyc7/gUTPjS9s+v83K23a7VHof/+Jn90f/fiX8NhqnNM/+qZ/l7266Od8jHGOc1A8QGRmbgoAy6zzwHPtnwoyMjBMV68WE+NV4PN5UicOdd975IAe2Et77FQ8P6fOMjIxjgHyPsClsqQeI9HTr1zGXSk+9In7D2bf5Zc886W7wiOo/zc/+3z2F97MQq2Xkj5YdeCjQzzh4pB3TbNZl5T5Z7X1CO24fszxp+2Vl9mHFPHNj2sw+EAEpjv5brUE2ZZxUELzS7Y8ZMuS6lzWLf2MWy3uHOIs4G45JZ8P3rmMAuqx7XF56icYrE7JrSofFzmUg12I9UlZt5jNnu+8cQMq8+/Z7nIM03rgd81n6/rpWHNSrMQPz88zsTWbYBXTYdtJLO9BF3BcaJxpE4eJvsFomdmb57fZalLOIa1CuARvHbesQF5xFbA3WzjIsopA4Jq+LMKYNYr2YkHbdaDTi/PPP3/ByzzrrrA1Pu1Hs3r2bAwcOrHiQSLX9iYnIWB1OdPdC4VG43r2C4FESzimNRXmL9g7lbMx6d9cqTzi+Q5czwaoCACsGh8IS/jofYoFzCpeuW73rYv/6pfAoiedC/D/MFcalAPFhfOnamDLyylmUq8M4XRyra8Ly5xlLNsCMrjJP+3mPZUzxzymNUwanChpdYpWJ+zxMa73B+bA/0n5JW9qH4Nv9EPaJQyuLpkFjMa5CrEN7i3INuqnCdsb90t8mpwqcNliOXpI0M1u+R9gUttQDREbGUZGzCxkZGX1skIE4//zzuf7664/PmNbAvn37mE6nfPOb35zRQdx0000AXHDBBQ/X0DIytgbyPcKmkPtAZJw6EEGKo79yeiEj4xTCOjHhRIoHz33ucynLcoV15Ec/+lGe9KQnZQF1RsaDRb5H2BS2DANxtBKjPtYqeVmtRKa/7ECsycyrv95Vl5lKkdYpXeoLp8R70iTzpTxrvV8PD6TEan5ePydSSvsDoVdOoGb3zSqU7fy6JErYWqpVaEubVkyb1tMrQVmtJGLN7RPQg3XK23Js2BqIJUYQShe6kqPw+7elQ06hXA3YrvwniZJdjxaPAsFUJmN1iTMlVpdYVWCVwUoIp0lQ2M4aS3SUt225gY60u/auO59TqYSzbYnSqmVL3iHWduNL/6fSHmu7bWj3hwrnjeqVIqWDvW8r2i/bSueb82G+3r4VrRFtwn42JpQOmQKnG8SUOGWQWOKQ9kUSNCaxZYoLSQTaL8XQtkLH309Eob3vttc7aOpunEqHfWJof/ONYr2Y8FDFg9Q9OrEaf/7nf86ePXvYs2cPz3zmMwEwxvBzP/dz/MEf/AEAZ555JldccQVvfetb2b59O0972tP45Cc/yXXXXcdVV1310Ax0iyCJeq0yWG+w6La8CGiv6jr+4CLheEzf9QW7wTAgLVNR6yF1LJOpfUHlCxpnqJ2mdhrnBOtnjzEtDqU8JpbqaGUx4jCqwYhty5e0NGjXtGVUqWRJuzqMrRczlK0RbxHbtO9TTJB+aSN0ZUip1LNvitCPkTBrXLBaWafqygedMhgzCHFRl9R6AECjShqKsA4PFoV14TdovIr3WL3fIt4TGQklTIU0FKqm1KoVvavWZKHb5rZsVRRKh/Gn8rKNIN8jbA5b5gEiI2NdCCid6cmMjIyI9WLCQxQPXvjCF868f/WrXw3AM5/5TL70pS8BYK3F2tna7re85S1s27aN97znPdx1112cd955fOpTn+J5z3veQzPQjIxTCfkeYVPYUg8QbVa8fS9sNEvfnwdmxdNJbOWRNmuxGgsxwyQka7WQTqeTDAUhVl/APSOWXkM4vBoLMb9tqwucJST15zL1/af92WXMWUq2M9gZC7z2ve/b1nm8Fxx6VdZh1sKt22fdfgkibSVBzNpnGgS/KbZhLYjKZ/+pgGQnCMywD+1xKWql8I450WDfqlXHDJspsWZIY4Y0ekBlRjSqoPEFjY/CQRTeSXtsKxxGGozUQQQoIQZoV6OaCm2rsBpbx1dkILwH18wKpHtsBLbHQNgGnMXb8LnvZwrjNog2iNYdm6A0aDPLSngXGIfExLSszFwcVdLOL1ojxoApkKLEmwGqCAyN0yWYMK/VJRDYBytmxuYRaBkaY6v2NwPQ8TdL3II4Bzrtk43b1a6FhyMmbMQ5abVptNZceeWVXHnllQ/FsLY0nOiWfbA+ZL8TRDyaVeJBy7wrBNtag1plaHRJrQZUDJi4kGmf2JJJUzKuDdNGUVuhsdKRZQqM9pTaUxrL0IR1KnEo5TBiKaWioMK4CmOrlq1smQbXmQjMM5aJdRBbI00d4oJtIhMxGw9QClEaTNEaI3hdBIF+YiXnjBlmGFAI3/WZCF1gjMGZAd6UNCb0XbBmQK2HVHpILQMET6XA2XAPUTuN9YJzs+eiUQ6tHIUyDLTGqWjO0Id3aO9n72QeBE2Q7xE2ji31AJGRcTSICKLXoydz8MjIOFWwXkzI8SAj49RBvkfYHLb0A8SK7Ho/oz/XsKXPPHgveN+zHkRmLdnWsiDzgQOJK2tr+VpbNmzLPPQbv8wuY2VGbS0mYk3mwvcYh1ir2dZu9ra1//9R95X3eJGZjK1HVrAQiXkQ8TivZ1iadiytViWwQ97LCkrQed2yNGE2obW8TOtfZVs2gnXpyYytAVGsaPoG3XHkfWsZ2maxkxXrfLNEZfDa4HSJNQOsCczDVC9QU1K5ktoZGpcYiHCca/Ft/a6IR0uwVTS2QjdTTDNBVWNUPQ2rb6qQNezrGRL70A6mxwjYUAM8wzzUdfjfeXw/JmgN2uK1Rooibq6K267b7Ud0CCA2bol33fLS+tI44jyiFGiNmCK8yhKKElUO8eUQVY4AUGaIKiyiB6CT3W1n9ehEoWLccEpjpLPF1cpE7UWB0gaxTcfOEFlXZdhQ87o55JhwaiBVEcxXDLQ1BlF3AD02P2onvBIkXt+sMlhVUEtJ5QP7MG4CA7FcFyxVhuWpYloL0wqsC2ySVkJRwLAENYDCS2tXWijLQFUM1ZhBs0zZTDB2gmoqlKt7NtMrm122DGXSTTkbNEJNDU0T/qZ4kpjExCAWRYg3RQmFRB2i7hpBSrRuT5d+8e04gg7JtUyoQIgFSqNNgTdBDwHgyiGDckRTjKiKRSZmEaNGTHGIlOF3seG+yvruN7Je0E7hdLj/slpjVWAirCpoVEGhB2hboVyz4h4hWW1vBjkebBxb+gEiI6MPEdBFFkhlZGQErBcTcjzIyDh1kO8RNoct9wAh+KNk1Vc2bFvRKM6vdBLqax/67EO/pr/NZvSyGh3zEFrLKFzrNrJZJ6UHi37996pagp7D0SybEcan3Mr6UB8zmIm1UWJjkx6N4Fdt1tMSBr3NTixEYiWSHqLvRiW4kN3oYb0mgCsggqwrkMrRYcugbYYk0dnLtm4kLfvXcxjxovBazRwDKYPlovNSchap9IiKQXBdcUWo4XUxY56OY7Fouvpq42rKZoxpxhTVEqpaRk3HSDUJK6urqGewHbuQMHfsM69xgKB7SP/PZxudBx0yhNJrCIcpwMTMfb/uWVuwGpo6aKhcbzw2MB5+TuAbnJkCwyGDYe8Vtk8NRmi7gCpGgY3Qts3m9pvMtdqVeK460WhVoswA5RqUrdfOym5WE7FeTMjxYMsgsf+pWRswc42OdQYArQNTajyXrp9ONBZDg6F2BVNXMrUFy3Vg9ZYrzfJUsTwN7EPTeKyLMqNoBqQVGOUZmoaRCW5KC3rMSJYZVYcp6yVMtYSqp0HT0NRd08h2Y9a4hidGIDaf7LRMbuZ8FacC0xh2TDz/g47JmTIysT0NYly/aiq8CIoqMBdNdICr6xmtRBiiRsrAQKiixA9HmMECxWCRcrCNabGNcbGdQg0xasBUFVTWYJ1qXatSiLNewEUGyAu1NxQywKgFjG4w1GjftL9bavwHq1d1HOUgyfcIm8CWe4DIyDga5h9CMjIyTm3kmJCRkZGQ48HGsaUeIASHR6FWcVNYDclhCVjBOPQdluY/C+vybTa97RIR9Q7ATE1lYh+Ut20N9nxN/8y4jlLH63sMgU/1iWvMk7zWO5ektVmI2V4MqnU+gpUOUO088Wm/c2KK2yZBbyGicdJt50wvDen298yYV9OW4AHdZRTm3Kw2DNmAw0JOLmwJiLNd0r51DOnVN8+fe6KC0xKCV1HLEJ2AnGhczJQ3qmg9zV30Lw/+8R6lehk+8WixlKqmlIqBHzOsj1DUyxTVEnq6hEyXkck4MA/Q1Sr3M/vJIcm5rpcDhDRm2gYbmU9tgnkZ4SKYGIkZjUJhoAhZQYyBchDm07rTjaSMY1NDY6DWiFQQh5k0EUEXMctEJBZCVRUynSDDEVIFjYeuK2QQXrqYYMww9NOIfTSc0jNxKjERTmsaXfbiZtczQqInvrJNYCWaKmRtN3ygrBMTcjzYMlDegTSongairQiYu7al48+pAud1uIpH56baG2zs8VA5Q9Vopk04LxsngexTYDSoeJ1TCgYlDEvP4sCyrazZVk5Z1MsALHAksA/VEUy1hK7GSF0hvV4OSZMQejbEc1+ZznVRNOIIzCKAcuFVADY6LrU7QwX2sQh6JRf1Sq6I56QugiZMVOf8BCgzRTUVVDrcOTkHBPbBNzW+rrv4pVSIbxBiz2SMDMfIaIKqJ+jBBDOYMigWGOgFpmpIrQOj20QGwkZ3plTx0TiF9QVTW6CTy504jAr3W1rCugvV9JzvjmE8iNNkBGypB4iMjKNBWF8glWNDRsapg/ViQo4HGRmnDvI9wuaQHyAyTh2IoMw6jgy5vjEj49TBejEhx4OMjFMH+R5hU9gyDxCdeHn98qX50qW1GsOl79t1xLIlvYrlafuSroQpWbfONJFbxbp1Zmy90qLVLErbhmqt6HmN5cyVLs1/tnK9uhUvt3vHu7h8taLcqiujUl3pEwokCJhSW5dZ+9hOcN0vZ2rH1hOmr2XP2rfGVUgrmtooHu4mMc997nP5/Oc/z6/+6q/yW7/1Ww/rWLYyxEY71PQ+WqKuZvOHCiVKThfhFUuYrCqCaFKZVkzpom0xhOZPhdTouWMw0epBbllT2AllM6GolzD1GFUtI9UEqauubAm6xmjpGO2VLKB7osZuA2amEyWI1qGkyLvuDBIVbFyNCbaNRRk+LwZ4Y/BmEBpJJTFlbBQlukDUtF1vu7y4L0MpUxBp+iTYju9jNIj7Pn1nUU1onudMiS7KtuGUUwVOhzKxVC5m0+8Qm84lU4YEJRblHcZVFHZK0YwpADZTwsTDHxMyHnoIHuOqzuBgpkQ3/HWiurI5VWDRbYPI2geb5tppGhcsRcPf0CguwSjPwgBs4fHDuG4JnxfGM9CWUdEwMtMgnPZLAAybJYp6OcSHehLigms6C2elY+lSsCtOTRa7kqZQzuydxjuLKButm/WsJbT0YoYp8EUZzr9YvtTEskKry3ZfiHftdVbbAUaN0XH97X2CjSWPEGKDczPlmN65dlrxDu0s0tQoW1EUY8pimVFqzFkU1D7EqPl9n/a/dQrrgqA6QYun0GF/lbphqBtGZsJIljd3rOR4sGFsmQeIjIz1ILIBevIhjB0f//jH+du//duHbgUZGRmbwnoxIScbMzJOHTzc9wgnG7bMA8S8pWfXgr7HJqyS/d5M5htobd6gz3rMinu7/12vcVyXse9bprZjW5UV6DXAaoXI0rEQsKpt4WqMw+xnvX0S7Wzjl20G0onuMga9fdn+vx5T4kPGIeyR3m/hk6XsLBvRWr0KrWXuWgyM+I7t6Wck14dsILvw0ESHgwcPcsUVV/Cud72Ln/mZn3lI1pGR4BFbo3wvK96PDylrFy1bvdKhQVzMvDUq+C0mBqLPOuDDeW98PWOE0P9f+ZAZV0ng6xp0U6GbIB6Upte8TutubEogNqObYSH0yuZ2YYCRuRAfprdBbC1az8YYEdAmMBCmCC8I2UcdGj55XYRzWiQwNdohtkZEUK29a4xtUTg9sx6VbKwFMUFI3Y45jbOOGUpnUaaCqUbFdSf7SGdKnB7QmAG1CQ3ovI7Nu7yh8SYwETFuaSxF/J3EO7Sq2FzbqPViQr5b2BLwUNhpYB58uDZ3X6kg4JfuOmnR1JRMXUntgr1o7TS1VW2js5TQV8pj+k3pVDJVSWYKUegrDqOa1lih9BNKGyyOQyO0mK1XBjE+2krPnsfJ7KBrFCutsYqHaG2s8DYaIigdDBFaJiPeB0SDCN9jARP70OhBy7qm9SQGwqTPRLVWsSoyDdI2sPRdt+Yo6BZtOkMI78P0TYWegNgGXS/jdMkw2mU3JtA3tR5QqwGVCg37JrbE+5LKCdNGUTUdAyQChQm/w7DQ2EIh4inMZhjJh+8e4WRE9qvKOHUgwZHmaK+HKjb8h//wH9i3bx8//dM//dCsICMjY/NYJybke4WMjFMID+M9wsmIrcNA9HQF/br71ZiI9L7PPvRr8Vcsr1d332cY5qcL72cZCvGxsd0qzMNm2qDN2LeuwQTMb19//PT3ie8a6PVtUL1Iy0KIt+24A4OQshyrMyXztqz9/d/avbb7OI492r8mq1dHqHOe/836mpS0+sBrbP5MfjjqG//P//k//PEf/3EuXzpe8AQLxJTZTw2WIBzPsZ64ZR8i85CaxDUq1N9aQlPEdKImPZN2DdrV8W+wD1XetkxCynK2Deu87TU9czFtafAFoalbZATwvssUQtfYbZ59SNOpHsNCbAyVwoGT3vyqs3ZM+4OQrUQU2BifFLOMXsxgeqU7DQWANYgturFqjbjAgogoxIRpRZtgG5vqtZUKLEbSfYjExnYCpkCZAlcMceUQKRdmYqsTjRUTN1+wYbBBc4VrdRL+AdQX5JrnrQ/Bhyx/OhfT9VAEqwqCslHaY6whNImrbMnEmsBAtOxDWKYWj1aeQllKnexDLUY1GLFosW3TuvlmdcpbjKs6TZYI1pShSZsyON81Sew2Qrp7h95xLt6Ha6T3IQaIQ2Jsw6dze+7eQ+kVuirlLF5ZtGviNV3N3DdAtLZ2GqcNypT4osbbGmlqKC0CQYflXYhtKe6khpWRAfWpeaX3qHoKtkbJBK8MRmlKHfVPZkhTjJiaBbTejsK3dq61TVav0jbr634bodadBeymjpUcDzaMLfMAkZGxHkQEZdZrUx+Cx80338yFF1644WW/8pWv5PLLL1/xeV3XXH755bz+9a/nvPPO29yAMzIyHlKsFxPkATyQZGRknJzYzD1CxhZ5gEg/Z99hJWUYuoz4GvqHOfZhBcMgM1PPaBs2gjZT4Duno/6c67VZn2/m1v9sI/O12UZ6mf/OZ6l9359vfkyBiYDVKt76zENfZ7HqNrTbYuO+pnVrmZkn6iCS3iQ1xJvRl/Sa9m0GG+0yOR6PueGGGza83DvvvHPVz9/+9rczHo/51V/91Q0vK+PBwncZf5ip//VCy0J4XUT3n+D806giZrLjcex72TlscFVyFcZWGDtF2wrdTFGugZjVXDGSvlZIFOgi1DhrjfgSb+wsI9BvdpeQxp8a4CW3pvnP+5g/zq0NKbraQxPPtaYOLIHSISOY3F36F8jemNplqujqVBSzYxUJbERRRMaimM1ytrEwjtcDTRPG1TRgapTtMsT98zvsuxCPGzHo+Nsktyvtm5Bd9g9dTMg4meHbhoPtOSYepw1IaBqXGkQC1L4I2ofWeUlm2AejguNPcvspdeiyOFAVBRXG122zw3YEcw6ITnTQYREy+8pZlLYtS5L+AiuaX840d43sp7SMp2/Pse7cnHdwc6EBpQuOSN7WKKXRTYiFxgxwMR4kN6Y0DuXqNlYlJzsxRTc+G5gIUgyAtmmd1wVem85RKm2bS9qUptN6ACo2hpTSImXQZvXvWkV0IDbjqpMDa2ECM6QfwH1Cjgcbx5Z4gMjI2BA24LCQ4vtoNOL888/f8KLPOuusFZ99+9vf5i1veQsf/vCHmU6nTKfT9rvpdMrBgwfZvn07Wm9O9pmRkXGMsF5MyMnGjIxTB5u4R8jYwg8Qq2kD5nsPJKR6+hmNQ99Voe3j0DEP/UzXvKtRf33dOlZxb/K+ZSXa71ZhGjbLPvSXNbOlSYsgqq3r7jMH8/POI3lN99/3lzGvf+gmXJtlaXtISHBMSG4PwWFpTlcRnVfm2aDNYKP1jeeffz7XX3/9ppY9j29961tMJhNe+tKXrvjuHe94B+94xzv4yle+wlOf+tQHtZ6MDSBmvHzMtjtTht4P8a9VxYxGCEKfAaB1VJphH5oKZaeopmqzcWm+1E+h9WpPjier6JL6TEn7v7WhhjgtV6nOy93awAr0naW8C9qCtc4z24S/zSrTpB4S2gT2QOvWcz45MoXeDp2ne9w5K7QVEvtVSHJ6MmaWgWjdnFy3DX0m1/vA5NgaqTUqzlcQ4pHRFbUZtHoHCHXb2jcYW1E0Y5TbXA+IMO58R3BKYEZPEJyXrCpoVNA+1TKg9pGBcCb0G4iOS0rARB2BFo9RjlJbBrpmoCtKCQxEyRTjqqCN8p3WIvQxCVUIwd1NzfSjEhxi/Kx7m3fx7ywjMcNG+HAuhdjRhO/sbDxaDSG21G32v4VSrUNTckZr38/NL7YJ7ECyo9Im7OM0bY+BCP0mBp3jm4pxIfXnSaxjj7FJv5lyDaaZtvcYYjxaLKVuWCiCQ1bqB6FjPAm6lIaRnmDIfWEeKmzZB4iMjHlIFG2uN82xwlOf+lS++MUvrvj84osv5qUvfSmveMUrePzjH3/M1peRkbE5rBcTcr1zRsapg+N9j3CyIz9AZJw6ENYVSB1LenLnzp380A/90KrfPfaxj13zu4yMjOOE9WJCvlfIyDh1cJzvEU52bKkHiNWam7VlNl5WL1+aawaX/p9vDjdfKrNa2VIqkZofQ0BnT5oa2XhiE7cZVbViXgw+P76NYH6+GTqzt/xk3bpRq7PN2CR2v0GvzGFuO2bKOvoN4nr0bm/m3r+dEG7jWD+7kKPDFoEoWg10pMu78qVBEFDr1CguNjvyLli1+o5GF3wsKYjWrbZC2aYTEkLbWKk9ElOplNI4Feh6p4uuXDA1a4vlCiqWGClXh/KdWBrgrUJs3ZYezoqoe2UMbk4o2afgXbR2jc2evLX4JlL61uJj+YKkkiWtg7Ba665MqS9+hq5kKs7nXSyzEhWsG+d+h7bMqW1qN7es/rQSGl2Ks8HeMf4uYmuMWqKM+7MrN4viS9e0YvbNYb2YkOPBVkEQBHdltsE4IZUvlTQYrA/HqovBQ4sHbdtrvBKHliDQLXRNIQ2F1BgJ51TbDE6CJWw655MNcUMR7BicxvlgDJ0geLQEm1ejG4wEq2jjKkyMPRoQ23TX9VT6k0qWUjmSRMMImDVFSFbTjq4ksqnjqwHbBCvWWI6oYilTK4bWui3RDMtzoYHcnJFCGsMKRHvYcA7PnsdpH8zHhGTPLN6FZoB4jKoZmgKrDRbd/j79+zmNRRP238aR7xE2gy31AJGRsR5OhPpG/wCcYjIyMh4anAgxISMj48RAjgcbx5Z4gPCszKC3tq3+KPWtc6xD//+VmXIVWIO5zPgKoe8qwl+YzZSH5as2u4lwVMFTf3mz23gU8XOPyZBk8baKKHveenXWdnJjJ1IrCE3zzzWfmWlEc5Sn95VsydGziR6BTdyLh8TJevWNG19exokKwRflzCeJEfDRstVFBiI0aPSt4FHTzJwnqwkYxQXGIFgSRpFg38Y4sQ8SGAirDC6+T9Ol8zExG0DIMMaXbzRKpqQmeAKzwmnoMnyacOAmFqEfF1KWUaKQuieE9k1gI3wTmAkgWLSKhGZwUVQd2IiOiVjtHApMhmvXJ9aCNYERSL+FKUA03hSdyHwDJ5w0Nbquuu1ZdSLV7oN5wedRl71OTMjxYGvAIzR6EP5PjIAygRWQIjADXreMgEShtHiPIZB4ShxKHCY2iNMSGkuqeF8A0KgCKNr7BJdeXmGdpvYm/HWhyVliOpIOWYkLAm3VUKqaQtWUxuDslCJeO1cTGoftCtnz1sShZfR6LEfPMlriOdU2rGtqfFUFhjLFgx4rCSCFCSYJyWyhzza0wu7ELs7aUou1eGeRwuJ8GQXaBqdjE0il23urte49xHuKZkrJeHZdcdtm7okk/gbHMB6kaTICNm14++Uvf5lnP/vZnHnmmezYsYOnPe1pfOQjH5mZZjwe87rXvY6zzjqL0WjERRddxJe+9KVjNeaMjAcOkaO/MjaFHA8yTnrkeHBMkWNCxkmNfI+wYWyKgfjqV7/Kj/zIj3DRRRfxoQ99iIWFBT7zmc/wile8gslkwqtf/WoAXv7yl3PttdfyO7/zO5x77rm8//3v57nPfS5/+Zd/ydOe9rSHZEP6Wofwd/WmZgnzLMN6GgMfq+rWYxrmP+8tYGa9IiE/4dAhAyq2m67HHqzGMsysZ+57SVmKaEzb2c8KytkV2znb6KZrcxeWv5KNWIspkXY+3ylGZNY2N7FCYbrOvg5otSCpkd28te1MU6mebexa+2f1QQrKrJONyAFiwzhh44FIaz8Y3quuIVK0byQ1J4znmYm6AMH3mje5tsY4IdTvGmzPmrVlG6KWwvXeOwmVuA6N62mk0vmvlMX4sO5CTymaKV5pDAQr12TbCoEF8G5ljbFSbTbQi4DqhfVkjRjrnMVMkagtcCJQCd5NW32Em8aspFKIkrYpnBRRFwEx+zinjYjsiOtrKrRGyhIpouZiMAwvQjMpVwzwySayF7dCXXXQgQBIXSHNNGRMU6120mEknYYxUAzw5RA/GG3qWDlqTMjxYFM4kWNCZUatFiEwA7plB9LfdJ3RYtFiGeAD84Br/6ZrarqGRdUCANZpGh/0Dc4rmvTXKawLf8NLaOysJlPwaEVoUGcsQ10wNBVOKbySlrH0SuNtOl9oM+0oHZpg9vRXbs6CNcU25SyqnKLqKcpMUMnGWSRUEFiLq/tMRLxep1hQFEhZds0i+1n+Vqs1p2fQGlEaGQyRcogMF6EEpw1WRy2KHuJE4XxfNxn3cNSCFHaCbqaYZoKqJ1E3ZjsaB/AmMMy2GNEUxzAexGkyAjb1APGJT3wCay3XXHMN27ZtA+BHf/RH+du//Vv+5E/+hFe/+tV85Stf4ZOf/CQf+chHePnLXw7AM5/5TPbt28eb3vQmrrnmmmO/FRkZG0Subzx2yPEgYysgx4RjhxwTMk525HiwcWzqAaKqKsqyZGFhYebznTt3cuDAAQCuueYaiqLgxS9+cbcSY3jJS17C2972NqbTKYPB4BgMfRap5nBtF6RZ1qH7u9LNZ74Z3HzrsuTolNYxs04/u85U8588WlIjNOUdTlSb0ZgZ52pN3HqMw7zDVH+9qX5PfGA5xLu2QVvKYqSa7zTC+XV7UW0mcL651vwYV2hFfMcKJBaiYyeElc38VDumlGlov/G9TPA8A4EPGd+jNKlbgQ14POfswsZxwsYDAVcMcSroE5w2KxirdPwqb8E1gZ1zDeK7xm4zeoPEOIjCmhKrShpdYqOTixOF9SGcJqYhZSG9FyyqjRuJgdSEOurEXHitol7JoqRaxdFIQrOmVONsYvhWBq8N3hRd06e5Jk3KBgZClROItc9qMIHpBCkn+MkU39TItOr0EASdBISLatobolRgHHqN4XxkMLA2aCq8D1qKokANw++rmiaMR1RgHmLm0RbDyA7FWOkadFNBM4m/kUOawJIwnUI9xdcN3jaBKTEFlElnsUlZ33oxIceDTeFEjQkeYapGNBQ03kTWobsOpSuTSc0jI+OQnHyUtz2HpaihABoKal9QuRBrKmuonKG2mtoGpsE6oXGCc9DY8N4mI7V+iFFgtGdQCEMn+CK4NGqxmNbRSVbooLyOTTIluL1ZXWJ1jE+x6WJfdwWgXY1xNaaZYOoxejhGT5dRgyVkvIRMxsh0gq+qwERE1zWfNFVKQd2EGCUKpMv+992dfB31Yjae+4mVHC6gmxoWXYjTZkSjSioGVK6k6blhJd1JoWoGahK1alPE1qjpGDVdDs0ybdOxskWJlMOwjKhT2xDyPcKmsKlo+2/+zb/hAx/4AK997Wt5wxvewGg04r/+1//Kddddxx//8R8DcOONN7J3794VAWTfvn1UVcUtt9zCvn371lzHBz/4QX7/939/Q+O5+eabNzP8jFMcwZ7u6Cd/Dg0bR44HGSc71osJD0U8+M53vsMVV1zBF77wBbz3POtZz+Ld7343j33sY9ed95xzzuH2229f8fmf/umf8hM/8RMPwWg3hxwTMk5m5HuEzWFTDxBPetKT+OIXv8hP/uRP8t73vheAoij4wAc+wEte8hIADhw4wK5du1bMu3v3bgDuu+++o67jzjvv5IYbbtjMsEj5A5cU/HN1hfNThr+u8wz2XS+GVkvRW1Y/o9hnIWDWVehovRQcHQvRH8t8j4n5THv7f5tBlY5t8bJinYkpaLUPSqF813NCeRvqN3uahtUYj7TO7n9ZyULQzSs9JwifdAzKYzGtLqPvDjPPFCVvKy8+/BfHHNazOgJbsnGHhTCEfPofK5yo8cAjNGaI1SErbXU5436kvI0ZxabNzivXhFpaZ2dcTrxIcFsi1BQ3ZkBjhqFeVw2oKWmis0rKmrWxwocze56VDFlFj49uLvPncBpf647iXcx6KVCC18FNKnmz22KIN2WoedYrM47K1vFV4cth676i6gmUE9SwgphtVFXM7vd6PaCkc2OCVv+QekAAYVprcXWDr2tcy1xMUVVYn7Y2sAkiSFEibkjyebe6bJkYpWzr/Q5gvEOaBjEN6AqaXhxx0aUqajDWc7NbDcczJiwtLXHxxRczHA75oz/6I0SEK6+8kosvvpivfvWrbdnP0fCc5zyH3/iN35j57LzzznuIRrw5nMgxofIDpr6ktgW2xwYaFR2Vou4BwNBgqDGuQrumZcM9ElzVtMZiqFzJxA4Y23AujmvDpNZUjVA1Qt0EtsHaQNo5T2vj3SvZR0QwGnwhaAVWS0s0qHR347seNS3Lr0zbV6ExQxo9oNYDKjWcZVtiDNISzled+liYKUU5pWzGmMEYM1xCL4yR6TJSTZHpBFVNg+6IyEBAdGbTUBSzbkyJVnF1YCWrqLeqqth3xiOFQY0mqKZGex+cmExJZUZ4ERqvmcb9aZ1uxzvQOlRRGBfc65opyhh8o5HYS6frjWM798nNVCmQ7xE2g009QPzDP/wDP/VTP8WTn/xkfu/3fo/RaMQ111zDL/zCLzAcDvnZn/3Zlrqex0a9788666wNi6huvvlmxuPxZjYh41SGSHcTdJRpMjaGHA8yTnqsFxOOcTz40Ic+xK233srXv/51Hv/4xwPw5Cc/mSc84Ql88IMf5HWve926yzjjjDO46KKLjum4jhVyTMg4qZHvETaFTT1AvPGNb2QwGHDVVVdRFOEJ8VnPehb33nsvv/RLv8RP//RPs3v3br797W+vmDfVP6Ysw1q4/PLLufzyyzc0ngsvvPABsBUZpzLW7zKZsVHkeJCxFXA8Y8LVV1/NRRdd1D48AOzdu5dnPOMZXH311Rt6gDiRkWNCxsmOfI+wcWzqAeLv//7vefKTn9wGhoTv//7v56Mf/Sj79+9n3759/Omf/inLy8szNY433XQTZVnOBM5jib7IeTXMWra6KDDuyn36dqx9MfZ8+VISX7Xr9Gs/jfbbqqsonGyLrcR1I5ajU+9BtKXaxnj9Uq2jCcWJpUBOFMnSNZUytaVHvf/XxcyqwrKFftmUQyJF65RGuSDcbrfDqyBw9Xpmn6dtcahoYxsMZPujWtnYb5MWrnH869KTObmwYZy48UBwyrSNo6wyXXmMt3ivEBuPWRdLmZoqCI17AmJEIAqTrS6xpqQxQyo9pFJDakpqV7TNoZq2KdQa56X42IAqCCML1VBITUmg+Us7pmjG6KaK5VRNR8mrXpM6XeDKULYE0BSjVjhpVRGsHOM6lbNo1aB1hW4MXmlUslzUGtFFsHUdDEPJgrNQ16EMob8vIFimQleK6B3ifGg85X0rvvYu/O+T8NL1SjSVCuVQpkDpAq2j1aRoXLShtTJ7WZKe2lSJgDFIWUWL2yjmNkX7W20K68WEYxwPbrzxxlW1Cvv27ePTn/70hpZxzTXXsLCwgLWWpz71qbzhDW84IfQPcGLHhMYbpragsgbrwjGslMdjEeUR1aDiVccQ7EKNq6P9uWsbQzaqpKak8qF8abkpWa7CMbtcayaVMKmEuobGeupmTvcs0X1YusofraAsYFB4hoVjobSMioahrihVRenDWFpb6baEKZgmNHpIbQZM9QIVAyZuEGKT022zumATG0u0xFEqQ6MM1oSGeqUKAmxTLKAHiyEm1tNQHhSbZ7Z2qe2GqFmL9yieJpYd+t7NeGpY6a1NtVwoUWhjKLRhqEuaQUkjBpsssaXXhC9ugyiPlDG2KIM2A3Q9CTbV/VLqogzlp5uJCfkeYVPY1B3YIx/5SP7mb/6GKta0Jvzf//t/GQ6H7N69m0suuYS6rmeCYdM0fPKTn+TZz372Q+LAlJGxMUj0zD/KK0eHDSPHg4yTH+vEhBgPbr75Zi688MINvz74wQ+uuraj1f+nDPzR8LznPY/3vve9fP7zn+djH/sYo9GI5z//+Xz0ox99UHvhWCHHhIyTG/keYTPYFAPxi7/4i7zwhS/kec97Hq9+9asZjUZcffXVfPzjH+eKK66gLEue+tSn8uIXv5jXvva11HXN3r17+cAHPsCtt97Kxz72sYdqO1a1Uu1bs64374w4OWXDYYZ9mM+Yr8Y+9Ne5GvOQGkiF93bFGOfZgBn2oceMHI1tOeq2RnvHJD4WPKwjRO5btrbjEyDma1oWw6vZeSQIuNt1p+8F8KuzRmF/h8ZSiUpMjMWq9rabYCFkA9mFXN64cZzQ8UBUJzTsNXmDnpFCOp7mmh0lOF3gTYk1w1Y83WcfGm9a9sH6fpNE6XqcxfPfSLSFVJZCGow0lEwpXBAwAhg7xVTLqGaKio3TJIoBoWMfQmbNtCJxp4sgoJbQSKqzqp1jEFbdT4FlCY3fTCfanploLo5G4TKxyZ3UoQmVSqlVwnnmGtsJsQkZSDeZhGmVRqXspHchy1uMWlFoGFv4LRoziGJ2gxqMUE0VhOCuCRlRCJnQuaZZG8F6MSHFg/F4vKlSmDvvvPMoy3zg9f9JmJzw/Oc/n4suuog3vOENvPSlL93w+B4qnMgxwaamcV5h07XIdYYiMBsbWvtxEZwUNKqg1kMqBkzdgGU7YBLZh0kTjrtJJVR1YB+q2rd2rQlapT6MQllAEe/AEvMQ2Ieaka4ZmQlDmTBwy5R2grZVYFBFkW49vNJYVVKbAZUeBWbElS37UDvdxiWjXHfPIrT3JQltU0xt8DJCdImUCyvY/358kBQvkl10PUWaKugIRKH6FQii8E0dmEnv8HWNnywjRwxGGQbx3JXSoc1i2F9uQOMMNhpSNM4wAbwSmmFBWSxQDGNTuWjH3Y5RVNukbqN4OO4RTmZXtk09QLzgBS/gv//3/87b3/52/u2//bdMJhMe97jH8f73v3+mJvEP//AP+dVf/VWuvPJKDh48yFOe8hSuvfbah6wLdUbGRrGuQCpjw8jxIGMrYCMxYTQacf755294mWedddaqn+/atWtVl6G1mIn1oLXmhS98If/xP/5H7rzzzjXXe7yQY0LGyY7jeY9wsruybbLrDvzYj/0YP/ZjP3bUaUajEe985zt55zvf+YAHtln0a+o3zDwky9aoLehnxFPd4HwDuZl1zrENsLJhXHrNaB7wKElN0vyq2fV+w7i1trf/N/0/b1Mr3tO3al1NS5DWN/9Zt6zu/ez/0ZLRh887W9x+AzrX1cm5GhGHiEbEh8xOZBtWMitqRhcSMrmzTf82bdmYm8Qcc5yw8SDatQIIZuZ86epkO10B3uMk6mpiJswpgy2CHWyto3WrlDQUWK+xXrUMgwZEuoy/gp7mwWLEYiRYQxa+omimFHaCbqboJmgglK1Cdr2pQ2bf2cgWSmgWF+0SfWrelLbVWTQV4i3GxdKR2CyytXBNOo9U0wxdBt/1dR+q1RK0Denmz4k4NnGx3rmokbpATIFUFaoscVWF7jWVgy7z7qcVTpZQgGpqpJmiB2N0OcKaIc4ELUdiIJwqooXusLW3TY3/lGu68Xi3kj1Z90DZWCO5888/n+uvv35zy14F+/bt48Ybb1zx+U033cQFF1zwgJY5v38fbpyoMUHjMOJoxKHjrlIqVghI1+wUAmvZqLLV41hVBM2TL5i4AVNbMG4KprVm2iiqJs7nIvuooCyk74RMlO9gNJTGMyw9pQnH66hoGJmaga4ZqimlBN1D0UwxtkK5OsSz6P06w64qPXPNNtKAAqMUg57+wfRtaqWhoKJwUwrby+Dbutdktlt+asYW7JX1jO5BcO28uqyQpkKXk2DVPAjN3NRw0lpFp6ZyiASGcjpBlu6n8A6xDXo4ZVBuB2BSbKNSAyofmss5ryIjoZnIAM02tLHowhKMdevwW8f91Y/3G8Jxvkc42V3Zstw845SCKDnqKyMj49TC8YwHl1xyCX/1V3/Ft771rfaz2267jS9/+ctccsklm15e0zR8+tOf5jGPeQyPfOQjj+VQMzJOSRzPe4T1XNlOdGyagThR0c/uH62RXMpup4fS+cx3YhqOpjUILEMvO96rJZzJdK6hd0isQPg/ZCDabOhc9r+dHg/M1mt6Lyuy8YLvMgh+tpZzNbRuRpE16BgJ6Y0lOTjNshGIDsuPGoj2aT9+3o3fxf3WjS/Vpa/GRPQdsPpov02sTa8Z4IaxWeemjJMQHm2rGRas31wtNVOEoB9AFKjw1/Xq6K0qaXRJE51XLAaLxsZjVeEhahtgJfuoxaJwGKkxrsbYwDyYZhyaINkKsSFzF1bYa2LXui+ZmXMe51DUeNegZBImnTumxbuwnLg8sXVgCproMtX0mi4lhySVirN10EQUJRjwWuFjPXN/f3rvEGsRXUDRIMUAyhppaqRpUE0d6p3rztmqdV8BfFXhrEWmU2S8jIwWUKPFwEIMFlDFCFsM29/BKoNTgzZehd/RhUyja9C2avepamYFvOviOMaEyy67jPe9731ceuml/NZv/RYiwq/92q9x9tlnr7AmNcbwcz/3c/zBH/wBAB//+Me56qqr+PEf/3HOPvts7r77bt7//vdz/fXX8/GPf/y4bcPJCU+hahyCEkcTGz2mpo7pGmljM0ikpJEiXJtQNN5QuaJ1capsYB5qq2hsdxqJQGlo76wkag20AqM9hfaU2jEoLEPdMDThWO2zDsZVkXVoetfVeJ+gumaVCdrViHcYVzPosQOQ7jXcbHNKCHqK2FyyjUFzLkYojSsGQQeW4lIxxIpe1e1NaRuWaxqcGaDKUXsuSl0hSddVV10sSq5OkzHSNBTVBDM4RDkKpTujwXamg+1Mim1M1AKVL5naksqaqGUJ26oElDiK6DJVqJpS1cHlzk82d6gcx3hwsruybZkHiIyMdSEbyCCcIGUAGRkZxwHrxYRjHA8WFxe57rrruOKKK3jZy142I5qcr3e21mJ7Vrp79+5l//79/PIv/zL33XcfCwsLPP3pT+faa6/lOc95zjEdZ0bGKYlN3CMkZ7aN4pWvfOWKJMGxcGV7+tOfzt69e7n77rt53/vex/Of/3z+5E/+5LiYKmyRB4i+b9Ls0/laU69gHrys+Hwe/b4O7WdprrnvWuZBbMcg+FnGQXpZ/9mawriMtoZvVr+wVt+G7vs+e7H6tJ3TSdz25PSUxsOsBqP9v2VK0jo73UliI9J6kwOT9P6Kj9u+ChPhUDj0zG8ys+60v1tXK5mp11wPwvoCqfz4cPJDvEc3kzbblur5V9MVeaVpovOPF41VBqtCWGxi5tv6wDzMu7EpCUerknDkJg95JbbNjmvfxDrmCbqedA5LTdNqHGYHH33VVREuVNHlRLxHmsmMz3rLJFjbsQlx+s5r3eGcazN93rmOBfAOSVlEE/QVUpaIKaAsQw2zKVo/dUkOR6lGWCk8JrAWykBRtswHziK2QZoGqqDxoGlw1TT8rWt83UBVBQZieQk1WkItLCIL21Cj7e257UsJv4MYGlXG3jxhDJoG4ypKO6FQmqLysAkGYr2Y8FDEg8c85jF89rOfXXe6eWemiy66iOuuu+4hGNHWh+AZMMGoBqsCi+hQK3SNluj85Uzr2lQ7TeMMU6upGh1YByc0FqyTGZcloz1a+dCaRIX/jfIY5Si0o9RNq3MYyITShex4iBHTGZYgaR2cxPMLgttRX99lg1Nbmk9sHV+27d/Q6pxsL96kng3zsSOuV7QBY1CDIb4o0ZENdOUQVwxpTNCGzbqmKZwK+imnDMoP220JuqUa1VSti5pUE6gmUFVQT8PfyTJiDmGGIwD0aBGzuJNitJNicBpL5rTgwOQVtdVUVlNZ1UoqSh22r9SWBVMxMpNWO7mx42Tj9wjHypntZHZl2yIPEBkZG4F0Nz9HmyYjI+MUwXoxIceDjIxTBxu/RzgWzmwnuytbfoDIOHWQu0xmZGT0sV5MyPEgI+PUwSbuEY6FM9vJ7sq2ZR4gFA7fE9R25S+z9qTzQt1+6VL/s3n0S5Rm7FJ7dq2hbCkJKqP4ya2kz7qypVnBU3+cSfTUtyJLgirlggjUH8VEa/77+fV4UhlDX0S9spyp3W9rCIt8v6Qpiarjmh3MNJLrSqws+GAJNyPwFmJh0qwQPo2h9yZOK0fdB6sii6hPAXj0dAndo9YRaUuZWppdF8GqVRUzJTI2hkWLxrlYnOTDGQ1BLJ3KloJFa92WLAFo32BshbYVppmi62VUPQm0fSwvCAtSsUFaEd9rvNZ4ZdryJXGxDMhOoa5g6TB+Ogni5FjC5KYVbjLB1U1o1mZtexGU+eO9d3EUpYKzSOhshWiNFAZVFGAMUkRrVlMgxoCJ4zRFsJNVSVwtUdwZGt1REMqunA2WtEVs5FRXKCWhmVxd463FT8I+k6LAT6aoKtjY6l7tv5GwriY1zkO3pSYOhdfSxkUtEzbt4p5jwpaHeM+oPhxLFQUnGisGq7sSxcYbGt+VMFXWhGZsVjG1mrqRWLoksUFcV75r4kFntKfUnkK7+LIUylKqhlLVDNSUgR8zaJZD48gmlDAlG2Ivqo1LLsYlF0sHVSxVCtbF4dzXzQQ9XUJNlpDJOJQEjce46QQ7meDrJpYz9swS6N1cxhgQPlQxFkg493sljRLPYVUOoCgxpsSXwXLZ6TI03Yxloi6erxZN/2QUZ1GlRTVVGHdRorQOY6unbXlj2JGHw/oWFjHVNJQ+OQsj8EaovaESh/Ma58Lv4jw0NmyLNVEgryyl3uRt7nGMB5dccgmvf/3r+da3vsW5554LdK5sb3vb2za9vOPtypYjZ8aphWDXsPYrIyPj1EKOBxkZGQnH8R7hsssu45xzzuHSSy/lqquu4uqrr+bSSy9d05XtFa94Rfv+4x//OC95yUv44z/+Y774xS/yiU98gosvvpjrr7+et7/97cd0nGthSzAQQmclBsxlznuZdjoLtHnmoc86uF62W/Uy5GsxD8mmNbEOsNI+NWXxk2A6rF+1auTEXCCzQuogto5MRBJT4mKjqHrVdbTjlY6FEB/sUldYPuIDI8As85IyNe24ewLr/jRpvWlZLZsRuMDIdKQx2BlRt0q/i5J2eUpsu0+STZz3yUb2QZ68Iut3mcwuTCc/vEdNx61gMB37KIMvypA1K4YhY4bCKkOtBjRStE3iIGS3bRJO97KN6QANIuoG5V1rvQi0mUVTj1HVMqqaIvW0a9gmCm8MXncCZSC87zeF8hbVSBBcex/E01EE7cZj7JFlAOxkgp1U2GmNreq2EVLKLOrSgFIorRGjQ9YPVqaPnMPXDbZuwrwxI9kKrCMDIYWBYtCyEmIKvDFdszsRkK7hXXtGeRem1w2iNX5aBRbCeUiZ0jgsURoV12cic1SKxhvBawkMJl18aI0oNps9XC8m5HiwJSA4BvWRmOn3oTmaMlhdUpkRUzWKTGM45mqnmVhD1SS7VqFuBOsS+xCWq2OfRRXvM7TMCqaHuqHUFUM1ZeiXGdTLlM1yMFSIjGUYoMLqEqtLGhOaVjaq7KxSvUcpi/YNZTNGx1ijmiqwD0cO4Y8cwh0+gl1aolke04ynuKrBNYGRVCaey4DSGlUaRGtUUSBGd+wDGqzFA34yQVQFMg7jiNMoU4Ap0EUJRYkrhzOMhDWDILBubWcVXik8ursHiTFNmSIYMXiPS7bPaRprUT7cxRQiDFU0utDB1ML5JIRXWDd7fx8aBG/y/D3O9wgnuyvblniAyMjYKNbtMpmRkXFKIceEjIyMhOMdD05mV7Yt8wAx03DF2zZb7lIRXszsz1uT9t+7VTLcDplhIUIDqc5WdZ596Fuu9hkBl7L4Peu4fuY+rTll251oEN3WVVtl0K5p2YLW4jDpNtTsU3NiHhLrsBpzsGLf9cbf34ctG+FD7Wi3Dt8yDfPL6u+vmffRvrYPFWs/+9skvf2MdPsFOvZn0whdfdafJuPkhvehWVEd7UOtDRcFpUMt72AhHG+qQHRnq+yiVWvKbNuU4ZrT3ziRwJ61GhwbGzlFBqKZYKoldDVGqknQATg7yzxEO0Qb64eBln0I2imLsjUiTZjHFUg5jPXCVccM0OkclFGIKnFNtE5UCj0oUGXRah1UUaCKEPbFRFahn7ZzPrAC1uJtNVM7nTJzSSchZYkMhq3la8tGRG1EWF7TpWvDoEKWU6lQjy1h/wH4xobmc9UUmYxbxkMpHViItJ3e0qhy5r32TYgfa9hWr4n1YkKOB1sDnsAI1p29s9MFthihBhaKcI1VEs9FL21t/Tz70Jc1Oh8YM9dmurtrlFEOoxqGasrILzGsj1DUy+hmGq7j0fYUoDEDajOiMiMqGdJgAhPqu/sMLZYB43hvEK/7usCbQdApxJggOrx0PM+ViSyG1qgyrE8PStSgRBUmzDso4/wxHvQYgBALgjbBV9PZ89kYVDlADYYwGKCHC7hyhI7xLW2f053dq7J1rKboN7E07bh9z27W1w1+OkEmy6hyQFEMGeoSOzCt9smokqkNWoh2WCo0ldPKbu5eId8jbApb5gEiI2NDyNnGjIyMPnJMyMjISMjxYMPYMg8QKXvePm16B72stkMjuJjb9jOZ8bYxFH5VFgKiPkBY8TTbNpGbe8h1omf1Dr3MZrvMHgORmJLwPzN6Cic6Zt0KVPw/MQGruSP1WYNW+9BjQ+YZAInTqcg6tFoLb+O8vtVA9PdZy0DE+drl9dig1diI1cYcpo3MQ8quJO0E3TbM7PfIMW0KOXtwaqDpXIpa7YA24Gw4qrQGpXHaoFSJUjYwW+JnGjGuhpnmk/F4UtF1CGKGzTahlheC25LWeDMIGoxiiDVDrImNmObc0sR7FCFL58yg/U55hzQ1srCINoEBANCjEYW1uKrCJ/bB6JZpQHdZSbRGiqhlEBX2Q69hnbcWX1X4aRWW51xwd+qlXZXRuKJAlWVwTRoMw1hMdG8yRXcRdq7TfjR1/C1C1ycpDMo5vAlOLKIjc5GaXNWxzns6DjXSBCcabarWoQZCLNCuRttqU40lW+SYsOUheMTWbRMzvEN00bERomnKkjoyEIWyGKXRotAKrALng/1fOl0gnjZe2vIS66W9hxA8RiyGGuOq4J4EeGVwUmB1SW1Cw7TKjJjKiMqX1M5gXcdGKnEocZRAIwVKD+ZYfcGIoIoStbgdtWMZM53im6AnSOeuqHi+w0zDSEwRnNKiCxyEao1wDk6R6RSZBrcoN50E7VJT451HlOD0GFWWyHCITKeo4QQ1CAyEj+5NThfdeeYjw1pPERtjs5LAhJQOUaobc4oJLrDKuhpT6sN40Ujp0cZSqgGVLiJ7HKAAoxpKqVFsMibkeLBhbJkHiIyMdZE6bK4zTUZGximC9WJCjgcZGacO8j3CprBlHyAE37IQ6X3KLqaneudVfwa8l6OyECuWDzMZ8NTbAZhhHub7TPSnT0xD+s6hkKjdKKiwsYYw9YSoVdH6Rc/rC9LnAMZVWAke0itqACOL0c4TqJUZnUHKhIZsbNgjiYkI36uOgQBYJfM3v97k0DT/WcritpoSb8N4Zhy0Vjo+Ca7tz7FhZGvGUwfpWEtZcO+jFZ9GqglKabQyFNExyGtJlm4tHB5L0i/1dEQ99mGe0QsfSuiVIOEs8KaYcSixOrIPPU1QOqe1bwIT2fNWRyT0j1hQIXM4cqhtO+Ig47ln7ezFrWm6493akGXUOjAx0Gb1cRZsA02DVNNuE3wo+BbnQ0bQRUa0CSyOcy5kcpvQ76GtoZ53MUnbZ23UWIRMrGiNDIf4pBsTFXQdxnRjBqinrXNU0IZM214ebV21s6Fnhu0522wUOSacGvA+xoImnEs+1ARopSl0wUAV2Kgrclq1bEK4+imIV0EXtRD9xc4yEuH/xGhCuG652N+lic5vSe8AUPuCyhU0zsxk0rV01zyLpqYENeuAaFWBNUP0YhVcpmwd/jobXIxcTxvU9saJfXF06N3iY++JFI+Ua1D1BDUdI2a5PUdSTPA+7EffhHPaOY/yPjAFTR16vhSTNhboHrsBhP0fx0cTz1ljUEraOAOE9UZmE4CmRtdjSmXCXZKpKfSIRhVY9IzrUnDJsxi/yZiQ48GGkYu9Mk4ZCBJuUo722sDD42bw2c9+lhe96EXs3buX0WjEE57wBP7dv/t33Hvvvcd0PRkZGZvHujHhGMeDjIyMExcPxz3CyYwty0BkZKyAsH524RjHht/5nd/hUY96FG9+85t5zGMew80338xv/MZvcO211/KVr3yFhYWFY7vCjIyMjWO9mJDvFTIyTh08DPcIJzO29ANEW8YE0RaUxELiUEctYzrqMnsIzeBCGZBIr8SnZ/84L/7tl+HMf5/eD/wY5W1bwuREY8WE0ob4Wdsgi07kbXwdBGGmwCQLWDFdSVIUNycRtoKZEgrpCal9rxxiVetXv/p3R4NTK5u0zOyfnvi9X7bUL2cCNl+61K7g+JJu11xzDXv27GnfP/OZz+QJT3gCP/IjP8JnP/tZXvaylx3X8ZwyaC1C4/+priBS5lJNUKLQ8+J/4xEJwj+RggYDHmzPQKAth+wXJ/bKmLwyOFN21sqicMq0JUnJhjEZFbTzCa1Vc1uOGMctzuK1xg4WYNsuzJEDrUDRi7Ri69Aoy7VlT3p8pIuBzoayhd64kiJU1ROYTkJJkgvmCaI1XqnQhKooulKkXolBEm17H0XQTNb0UffOzXwnWkOhgolD+r2UdOLuhCioVhBE8KZq9yWpeZx3rThz0zjOMSHjYUIsoxFrwrHifTiemimmXmagdHc91QpMuM4oPAqDoFAiNDYYj3SlSl3lYPq/fw/h0NR6iI3lxzaW2zQUND7cgjU+WEiH9YXSKpFQah0sXHtW6z3TFqtCmXIThdVWmXi97yyOja3auNKWLs/FCSddOaB4h7ZVuDmM5UwSy4ykqNvmbg56RhESyhzTdN5BNe3MFPoNJeNyW6TzryhABnEHpvkklFwq3QnAbY1uJu12GFOHEiZVrLDcVn6TNq798WSsiy39AJGRMYNYl77uNMcQ/YeHhKc//ekAfPe73z2m68rIyNgk1osJWTCZkXHq4GG4RziZsWUeINqGZnPWoQmJjdgICwHMiHFStrvfyKy/Xk8QKrs12qb3bWPTq7+8eUvZkiBkHKttlEwR74J9G26mtX3FAOfC+0JqBNc2nPOoYPvqXWyw1FnLHu3wn7dancmszo0zYS3rxJaB6Qu35j5bbfp23/SEX6kJYGfTe5SNOBo2mF24+eabufDCCze82Fe+8pVcfvnlG5r2i1/8IgDnn3/+hpefsUmonhi3L6aGIN5rakQmrWXwDFJUjIJqG8/vPvulsWgJecQ+gwepaVLvOJfZYz40ils5n7FuJoOufAPeoesxXhTNaCfF+CBSV0x3noWZHArzRztYAGsGweq0WgKgWdiBnixF9iFuVlpHimOuCYzDHHMgqXmcc4RmbzEDmK6vqRkcRLvIcM4652e7bdFNL8mu0XSWshItdTtxd0rn9hikmN1UgPceZW17offzv+FmM4g547jlkUTMogu8jsd/YuasRTUVRpYZpOtTKelw78GQZKMitEJqrcDocC6V2lNqh1LhfeM1igIrOlQoiLTNKZMVNIAWh5HIDvTuEcK60l2GRYlFzZk2GBvsjiszolElNSU2NsVEQBWOggrja0obMvdFM565bgcW1cZGvJHJcxaxdtbWOlnBGhPOxcQKqC7O4R2+bkDZThDtXWAoerRNspUVU0ShdHxpgzddc832/EzMhKjAHNkpJo5dq3qGRTla49x1kePBhrFlHiAyMjaEDTosjMdjbrjhhg0v9s4779zQdAcOHOCKK67gn/7Tf8rznve8DS8/IyPjIUJ2XcnIyEjI8WDD2JIPEPOaAuhq62kblgU2wqFWNIJLeoZ23lVYg/l1zdu0zk+fjNkEh0fRt38NhEh46k0ZzYkscFp9D14UZb3EeHAatRq0Dd/GskhBRRMb3zQYRn6JhtBgSbxHx8Y1qUb7gTRZmmkQt4p+o/1uFXvW/vTz3/Ub262HVKu51r7fOGQD2YWwzNFotCmG4Kyzzlp3mslkwk/+5E9y4MAB/uzP/gy9HlWa8cCQaGhf9D5rZq0MrQUdMo9EXYBRJmgUXLJy1OG8lE5v1DZ2wmGo0b7pmlVGFsCLXpG9FAK7oLxF2TCW+fMxaRRapOZ0IjhdMrz7W/jBCGlqhnd/k8mZewEw0yMo7aiHO+K4DVoEPVmK+g+HVxpVx0ZuqW656dkbpsxgVQW71QQlgS2AtllW2MW9DF+ribDR4tEHbcScdaSo+LtojaARbWabWSm9fhdY50Aie5O0GmkdMUO5BhG8BtaLCflmYktAOm0S3gcLYWtnNEbKVpgmnMODqFVySmFRWKexXnVN4iQwD+lvocOxXmhHoSw63j9Yp5lK7x4hHpwqMg46sg6BzQwMQz/j31lF+1YX2L+Wl1ELAFDYKU40JRMaKXCiI3PRtHFKR12kthXKWZSruzjjfY+BaJCmQZppiBMtc5BYSY+P4+r2cV9/4MDSxZLU0M75oJcSBdGyOTCQwV6b2GhzpgHdXExM40j3c8qGppvSYyDSeDxqVd3l2tj4PULGFn2AyMhYFcL69Yvx6/PPP5/rr7/+mK26rmte8IIX8Nd//df8xV/8BRdccMExW3ZGRsYDxHoxId8rZGScOtjEPULGFnqAaJuUzbmqzHzfQ3BM6rEL0YFpRWZ9znml/9lqzeHWnLfX9ExIziVdg7TESKioY1iwh6nMCO1qjgxPx7iKwk1DczjRLPgjeKRlILbbAzSqpHQTSjuhUQWNKlsXAvGzDetWjNGnBnJr60j60z8QJNah/zetc9VmXA8FHoasv7WWn/7pn+Z//I//wTXXXMMznvGM4z6GUw1eaUTFY8pA36kHYMY6JWbexDWhgZJLWcEanxooScckKrFo17TNHVVkyOyc1icd10JgA7X34CL74Oou6xfX55WeYUrT2Lw2DO79LtWZj0VVY1wxQFdjBgf+EYBm++moesKwGiPVJCzH1uGcbmoYL4VlGhOayyXmITbYm2EcUqO3lJnVOmQaE2vThwtNpVqNApGlWE3/AK1monVZSoyEKUKTO1PMMjDtj+lmM539z1unNtcTZ2wSmQk8JeC0CedVAeIMou1cPOjdI8SMvyIyBcpilKbUAigi4YBSHi2+x0AE9kGJw3uh9hpPbA4XV2VUYCmMWJSE+Qw1xtehIWLvOt3XIrYuiUhbXbA02ImLGkHlLcZVNCpk77c1BxlO75+Z39TL8X3QK4ltUNWkbT5H0imk+NNv+JagNFIQzt+oe/K9c779fz4WRPahj9Z9LcYEZ0pcOcQVg/ibDaKmTHXsSNKu9FwogcjQ9O/N1AO72c/xYMPYMg8QGRnr4/jTk845fu7nfo6rrrqKz3zmM/zoj/7oMV1+RkbGg0EuYcrIyEjIJUybwZZ4gEi5Kd/P3BFrkfvT9Q4Mv0qh7IzzwZwLwvxn/XrG9H5mmt7iV8vat+4LNLP9FhCc1zSqpKHA6UWONIucqe6iUkOGdokjeicjGmoZsHt6FwCHh7vxXtCiGKuCbZN7UaZzbVLedb7PzNZWpvfzLMRaY18N8wxPP4OywiWFjo3o/u+1ud/AOjevfyD8JuvVWB/j2PCa17yGj33sY7z2ta/lEY94BH/1V3/VfvfoRz+aRz/60cd2hRkBolonD3Eq1NH2s40EBxGvC7wJ2oe+d3r6q30T2MroACbeteyD9LJhToU+LUDrR56O+5QtVEnjkFyQ4vxt1l3pyJL0Ypg26GrM8iMeF5iFYoTVJUPbIMUQIPSEMCXqvrtDTXHTBLZBoktSOcTfuz9k1qxtL5DeNuF9YhDmz42+M5P4TlyYHJfSGOeZCaXiKqJDS4o1yXnJ6FCDHvUQQbsQfwttoo5BZmvBe5nRfsxKv/WMd/xmsF5MyPcKWwSh1wGmxDvd9kFI8KJwusDqkL1v9GCmr4AWj1EO64UBHq+jHkqFz01kEpS4th+U84rGKxqnqK0K12flKZQFA1o0OumnROOku+Z2WfbOqS25KGrfcFCfAcDUlSyoMSVTjKsQPKP6MIPpYczkEGq6HBi+dju7675Uk6BpqCZQTzu2od1lq5wXSkAVYBUSY5m3Nug4+y5LK3a/IIXpTielghtbYaL7kml1UF7ptteVNSVWlTilZ2Jw6qGzmvYyrW/z+gcelnuEkxnZryrj1EIqXVnrdYzxuc99DoB3v/vd/MAP/MDM68Mf/vAxX19GRsYmcRzjQUZGxgmO43yPcDJjSzAQGRkbw/GnJ2+77bZjuryMjIxjiVzClJGRkZBLmDaDLfcAsVYpTfguli5E8XJfBJ2E1O3/rP5/W5rje03R4nJmSm884Vhs51FRtD1r49pQoGlwPlBtmiY2rgo2kXdOH8FiMWZJ7aCgotbDIJ5WBdur+5gUiwAMmyXKZsyk2Ba+14NobRbH1itfgrVKlzp6s522J6heky5cdV+v3jxu3r61X+oxv5xVhZMPBsIGukwe21VmPByQUBYUywRnhLl9u89Il3td4JTB6WB9mKC8A1ejUoMn79rGjPOlBVZMK15sKHCo1pTBiQYF3giF7Q4wiTaLMzHISyui9vH7ZrCNqgzn9aTYxrA+gi1G7RjM4QNIUYcygGm0XWxiudJg2JZE+fE4rDg1YJtWrahRtA6j6JczpSZRSQwZS5VCaLNRkz4nlFQqlCzFpnGhjEq6daTmcalpVBJQxrIlVCglCQ2kZkXubcnXnKjazwtgN4P1YkKOB1sCHnCqwHsFquiuh71SFycaG62YUwlx4w02dmBU4igUrbFCEksbca0YOqxLqGP50rQxTJtQwhSW4Sm14GIJtNOp+aTCim4topWKJZIxPoRPQzyYMOK+6jQAjGpwXrGgFUYqhtP7GUzuR2yNqiao6RjvLF4XoXwwmSPUFTJe6kqWqgp65gltSaDWs+dWslpOJaFNjYgKdwjJVGF+GfH/JJietW2NBgrFIJYwxqaSqSmnaJzSNKrAqq4UK1nZptLs1RrcbrqBHOR7hE1iyz1AZGSshdUeVlabJiMj49TAejEhx4OMjFMH+R5hc9gyDxDzP2qfbWg/87NtzteyNF3vs7YNfXr5bnl9wbXyQcQ825o+2baGrILG4r1go+Cw9BMKJRy22ymlptQNHmHZjljUHouhoGJUH0G8a5/KxXk8isJO23E2qsCLQnnbiomMrWYsVGFW5JxOoJnxrmHrOiPKnrOda/f/Bk+21UTtbWZWjiETkdvUb33ELJKXXngTFY57pVuhnkdCc6kk3BM9I+bvMw0z4j1ilk0EKwqrAvtQExkIb7Be4xC0uMBGiITGdJGx0KpsRYAtwxebxomziLM0xQhTj3G6YLnYQcUAjWW5DA3jholZOR3UdBzsZ48cgjMeGdiCI4dgOsE3Nb6ukbLE171GckpQqsDVNW4yRQqDKopW2NxaLEJgMVRqCBfbYjoPdR0E1dF+VhSBfUhsQxROhxklNI/ToYFUaiqXWA/x0YQxiarj9vUZmmB9u7pYc97mcePHy/GNCd/5zne44oor+MIXvoD3nmc961m8+93v5rGPfey68zrneOtb38qHPvQh7rrrLs477zx+7dd+jRe84AXHYeQnMyReA3XLgrt4LibmwXoT28sSz1+F9QobqwMCAxGOOy3B1l3Nsw9eaJyhcYF9WK40k1rRWFoRdW2Exilsoahj08ra6dCALtm7+rDcxEB4H+4XBM+hepFxnWKbYVQ0TG2BKxRSRjvZagmxNW5xB9XCrtAos1pCj4+EvVFNAvuQ2Mb+OWNtYPkSQ6iZOYcDYxgNH0SAKpxz1uKbpm0Yh5L26t+yjsm2OZ37SThdlHht8MrM3I+Id4GBiSyvQ7X2rImX6VvVr/zVT/x4cDLjAe2pP/uzP+MHf/AH2bZtGzt27OD7v//7ue6669rvx+Mxr3vd6zjrrLMYjUZcdNFFfOlLXzpWY87IeOBIJRNrvTI2jRwPMk5qHMd4sLS0xMUXX8zXvvY1/uiP/og/+ZM/4ZZbbuHiiy/myJEj687/xje+kTe/+c384i/+In/+53/ORRddxIte9CKuueaaYz7WB4McEzJOWuR7hA1j0wzE7/7u7/JLv/RLvOY1r+HXf/3Xcc7xN3/zNywvL7fTvPzlL+faa6/ld37ndzj33HN5//vfz3Of+1z+8i//kqc97WnHdAMSZrLoXsCD7z0frdb0bbMMRJ9x6P+f2tsrfJdJF0LGINYxrmYFq3AIDofGEJo7TWSB06p7oISJG7GolzlYb+f08iC1L9BiMeJpVIET1TIXy7KLhUEZrNyi1aTgQ60l0tYKWlVgbNUyEuItDt1qFdqMR0/T0TWX6+2XNgM4q62YZzPa+VdBaprVMUKzv1e7/tYZd64JzWaZCVmfnswuC5vDiRoPnC7a39LHjFnLMijd6R1iDfRqx0Wos+0Yh/laW6vKtmFjTUntAxtYe4ONmUUnrtdYTnBK0ahwnmrXtLW8AErCe9EKdIFyDXW5SFEtsW16gAODR6BpGLsFSj1hOtjRbmupD6HqCX7PWdjFnThTUhQlMh0jh+9vWQc1WsBVgaVURYE9dChsqxLcZArOowYlUpahZro9d7u6ZA9I1ER4CHoN54HOAlKUgDLRtjXWLisJ7EOyl52PC362hjrpUfoWuy0LFONbmk98iL2BodjoUcL6MeEYx4MPfehD3HrrrXz961/n8Y9/PABPfvKTecITnsAHP/hBXve616057/79+3nXu97Fr/zKr/D6178egIsvvphvfOMbvOENb+B5z3veMR3rA8UJGROkY+Rb1gGNQwfG0GmsV7hYpeC8WnF/YMSBdFatutccNukkrNfUTrfsw7hSTGuhaUk/wTrBOo910JiwjlorSmNjgzmHVrZlIPpwcYzpsNTimDQG72Hc7GKpWGDH6DC79N2owfY141tiOWfsm52D8VLQRdloz+odqCEkNlebjoXoN+51rtWXeWsDA9F3d456CtFlZB56tq2pgaQK86cmd+Fn8y3DALS/V5+VTLoREd/eI4j4trmeptnEcZLvETaDTT1A3Hrrrfz7f//vecc73sFrX/va9vPnPOc57f9f+cpX+OQnP8lHPvIRXv7ylwPwzGc+k3379vGmN73phMuUZJxi2KwvdMaayPEgY0vgOMaEq6++mosuuqh9eADYu3cvz3jGM7j66quP+gBx7bXXUlUVL33pS2c+f9nLXsbP//zPc+utt7J3796HbOwbQY4JGSc98j3ChrGpB4iPfOQjaK35hV/4hTWnueaaayiKghe/+MXdSozhJS95CW9729uYTqcMBoMHPuKjoNMi9BqUsTIjPo+1XJdmlh0r7lItokfarMMKB6bV1ueZaUgFoLBt3XRiIDyO+4sz2FHdy1AtMTGLLJiCe6udjEzIHE79MCQEvW/nDyyDZapGeBRDWUK7BuNrrDJIan7lGqwybXOroHcILlGCD9Mm15ZQaDjTYG6+njB81zEJqb38uuxD330m2FOFPlE9fcqK5nytfiSOz8smWYieK8TRpsnYEE7ceCCt1gFYlXnw0d2j77qUGIZ0jCtvIWaxUn19yFAFLUWjS2o9pGJA7QsqF5sfeY330tZG23Ru+cT0qSAtIjSFEjd7DAcHNU/ZHEH8BKcLRsv3MFraz327HsdIlhnLtpn4IqVFFnfiTcl0GBxaZJtFDRdRw0Vkukxz6y3obdtR28P3zV13YpfHeGsx2xYAcJNJ2HaJ9cum56IU2c7EFPioc/DW4ptYN91YlDc4QIkKOork5iRFm6VsM5jomAWNWcfY4Mv34kynT+mxEJSIsygXYhpYBIUXjzDX2G6dY+XoMeHYxoMbb7yRn/iJn1jx+b59+/j0pz+97ryDwWDm4SPNC3DTTTc97A8QJ25MCA0eE/NgCToli6bxGus0jVczekYI157ktpQ0Dxo3ww44OuaicoZxU7BUGZangX2o6jZ0QDQvcg4aJ9BExiNd97TglcUBRkIM8Ui7Xi+ega7RKjqixfEeqQYsFlNqp7lnugsGsOgOMVbbONRsZ4c5jC/PZNHeD8BgYYnFe29HTZaiHsHAgXvwVRWW6xw0Db6uUc53TIM2vXO459AUGQ1vG0QUzlYhRiTmM8a4tnlkQuvSlLRWqVlkZBKcRSnbshDpPqzxeub+QUcWQktqAurQ0gT2ZRV95drI9wibwaYeIL785S/zxCc+kU984hP8p//0n7j99tt57GMfy2tf+1pe85rXACHI7d27l4WFhZl59+3bR1VV3HLLLW3AWw0f/OAH+f3f//0Njefmm2/ezPAzTnUIG6Anj89QtgJyPMg46bFeTIhf3XzzzVx44YUbXuwrX/lKLr/88hWfHzhwgF27dq34fPfu3Rw4cOCoyzxw4AA7d+5sO3v35wW47777Njy+hwo5JmSc1Mj3CJvCph4g7rjjDu644w5++Zd/md/+7d/mcY97HJ/+9Kf5pV/6JYbDIZdddtlRAySsH+TuvPNObrjhhs0MC5hlH1ZzWZr/f6OOS2n6vhNCYh/a1upxrTBbl7/W8rrlRm9oumxG4adMZcSh4nQKKobNEo0uWPIjJk2JGM82NQ4e9YCO2TYRzz12D7v0ASyKQ7KLbfoQ2tUYW/X0DFHnEE+S4KVs2+yMjgzFqj0f5nUQqd7QBz/4kF31OHR3ks31nwjTr/ysW97K2tOVzFHXR2PTyCKoY4YTOR6gNC56uq/mtOTa//t6HxWdkVJtfcc+SPRL97F+utZDajVotQ+VK1q3FqB1Z1Hi2uxYqNENObS+9qGPdF4YO0HXy7EfgkJsjTjLGftv5L49T8RQzWTkla2x5QLWDHDRmW152yMYjg/gRzvR1RJ6tB2569v4pcNhjIsLkXHQ2PEUV9fgfNQzgEquS2WZNir81YE1CG5KGurIxDYW5xpcXaOKJuoZXNBLAFI6VDkI83sHTgVthkirYwjpWTvrpuQ9Xqn2d0v7Lnm8KAgsTs81a1PYQEwYj8ebOg7vvPPOtVe3yg2K30DPG+/9A573eOFEjQkewYoJzAM6sA8+sA8u9mxwcwxE6g3l4pU6sQBabKtrdD44NVUuxJrluuTINLAPk0qom459KEw4XQrj0cqjFcQ2ECvuH1T8P8WMUurQc8IL2liMhIqF2of4M9DhvY3T177gAGdw33g7tVUcVkP2jO5nP2cBsDhcZnzWDk47/I8U4/tRhw9AWSLW4qYTsLaNB/ieOlEk9JaRzj0NpYKewVpEN3gV2AdXN62Wwdc1qgkOcGItMkzCRhXOYgk6DVEuHOe+672TmEbV04V4BOt01IN4rHTsQ5gR1KaYhx7yPcKGsakHCOcchw8f5r/8l//CT/7kTwLwwz/8w9x22228+c1v5rLLLnvQQe6ss87asIjq5ptvZpyaI2VkrAtZs6SqP03GxpDjQcbJj/ViQjh2R6MR559//oaXetZZZ636+a5du1a9QV7rprqPxFLMn1OJuUg34A8nckzIOLmR7xE2g009QJx++ul84xvf4Ed/9EdnPn/2s5/Ntddey4EDB9i9ezff/va3V8y70SB3+eWXr0r9roYLL7zwgWUnM05Z+CyQOmbI8SBjK2AjMeH888/n+uuvf9Dr2rdvHzfeeOOKz2+66SYuuOCCdeedTqd885vfnNFB3HTTTQDrzn88kGNCxsmOfI+wcWyKq1mrLjFlDqbTKfv27ePWW2+dsWyDEOTKslwhADuW8KuUv6yG9UqLVrNudV6tEE+n0iXdE1jNtZjrXj0b10TBtSVAeCoGVAxwohm5IyhCA6qpXmBHfS+PLv+RM8oDLKhxKJsgWEFur+9jex0yWjt0KE2waEqpUN7SqJJJsQ2rTCsY1a4OVojet2VU2tVtuUbfNm39ne5juUEohVLOhmU521nY9kVRm/BY7O/B9P5BQYjir6O9HtwqTiWcyPHAKx2aEs2VL/Ut+JIlqErWoGuVv/RMBJxoGj2g0kMqGVL5si1fSkerFkupagaqYqimlFJRSkVBRcmUwldo38QxeLSr0a4GEUwzQdsKqwqachFz5ABmfAjVVEg1QU3H7PnG/2H3fbdwxvdu5ozv3cxgcn889xqKaonR0n7EW4pmTFMuUJcLiLO4cog/8/uQR8RXUaAGJaoweGtDyQHg6hq7PMYtj/FVFV7JmjG9IAikiZatgHceV9c04yn1kSXqQ0eoDx3BLi1jl5Zx4zFuOglCzaYG24QSJms7ZWkUaIffxnbN9nxnhxsafxXxN+5d7B9Q+RLHNR5ccskl/NVf/RXf+ta32s9uu+02vvzlL3PJJZccdd7nPve5lGXJxz72sZnPP/rRj/KkJz3pYRdQwwkeE0Ric7jYJK53+6OgvU63pYaSypM7tNfxWL5Ue0NlS5bqAUv1YEX5EkBZwMIQFoaebSPH4sCxMHCMCsswvgaFpTTBwrUrfQxN5QqJhideGMkyi/Z+dkzuYcfkHh556B945PQ2zpnezNnNN9mj9yPiWZQjjNSYHeUyO4djtHIsNyMmtmRiS8ZuyFht477TzmH5tEdRnflY/M49MBqhBsNw7Dsf4sK0wo2XceNlGC/BNDahS+dtu3OC4UKKCykWNOMp9aEjVAfupz5wP/bg/bjD98PSkbC8ukLqKWIbpAmlmun+RJztysS9DeWfvXsoB6EpXyxniq3legLr1Zvgrol8j7ApbOoB4vnPfz4An//852c+//znP8+jH/1oHvnIR3LJJZdQ1/WMo0TTNHzyk5/k2c9+9kPmwJSRsT6i+8tRm8Tk6LBR5HiQcfJjnZhwjOPBZZddxjnnnMOll17KVVddxdVXX82ll17K2WefvSKrbozhFa94Rfv+zDPP5IorruCtb30r73znO/nSl77Eq171Kq677jp++7d/+5iO84Eix4SMkxv5HmEz2FQJ04//+I9z8cUXc/nll3PPPfdw7rnn8pnPfIa/+Iu/4A//8A8BeOpTn8qLX/xiXvva11LXNXv37uUDH/gAt95664rMyfFEvwHUepjPeq/GPkAQPiWrxnmmYa11K1y7fIWjdgVGNW1DuJoSr4WBXW6fuhtdol3NAhVNbF7lvKbSw9aOdcEdRvAcUadhaCj8lGW1HYVjZA/TqBKJDInqCUXD/9KyB05plLOhDrC3q44mTkxP+d4LiG/FjT5+lprWJUG14LsmNHPN5B7ob7YReNZ3WDhx5IgnPk7YeDD/E0uXjfIoRBzK0Yr+YW1jhTS/j1nvRg+ozGiGfXBetRlDgFJqjDQY6mDT2rOHnbGMjuzDzKq8b0XQdbGIGW3HHLkPWT4Cy0u4w4dwjUXfux8ZDAHQWsP2neH8Kkq8GTByFlcMWVrYw2hyEG9KxNbU23dT3L8/rGtxO2bHTlg6jDp0iAJwy2NcVeHqGplIK4KWomjtF31qIud6Vqve4azFVg22CjFJTWrMsGqZDVPX+LpBDQcoP5xpMIdtZv3XYwYSCFlIHeKWXyVWzJzTmxQUrxcTjnU8WFxc5LrrruOKK67gZS97Gd57nvWsZ/Hud7+bbdu2zUxrrcXaWaH9W97yFrZt28Z73vMe7rrrLs477zw+9alPnTBN5E7YmABtA9j0fxJJq7b5mLQiarfGIeF9aDSWBNiBfShZmkbjgh77oBQMChiWjmHhKY1loC1KxYy6dNe4foWCjixIElYnpmNBjzGuYlQdYng4nMP68AHK79xKc/gIC2efzbbdZ7JnuMjSaY9mtLSfPWbIvaedw1QPOdIstutzPQv65cFOajNipApKpZFmijpyCDlyCHf4CL6pcdHeFaIlq7NBOC0SzjlrZxhA7wN7YadhPpdiwniKXh5TTCboxSlq+zbEWhgE62rKIUopbGp0q5JRSzSeiBa6GocVh/caJ10M7zfyfSDI9wibw6YeIESE//bf/htvfOMbedOb3sSBAwd44hOfyMc+9jF+5md+pp3uD//wD/nVX/1VrrzySg4ePMhTnvIUrr322oes62xGxoaRHRaOGXI8yNgSOM4x4TGPeQyf/exn151uNVGx1porr7ySK6+88qEY2oNGjgkZJz3yPcKGsakHCIAdO3bwvve9j/e9731rTjMajXjnO9/JO9/5zgc1uAeCmQZlc1qG/merZbVXs31djX1QM/WRfXvGWQvX/vIcqmUfrNcscIQj7AgWZOjWjlVh8V5YVtsppKK0k2Cv6h1lvcxCcx+DI/cwPu0s7h89giZmKws7ZVxsZ+SXcKI5wg4GTBFcqBdGsKrEi2Bc3TIK2gtFMw0ZPwmNnUK21MZsi5rZptkd5meyqy2j4EP2xXvfMhpAYCLWsnCNzeRCFqPLjqy63gcMmWkcttY0GRvHCRkP5g8XH6tle8cn4hFPYBdQq2edRKIlcbB+bXS5QvuQ2IdCNZQSsm0lUwo7wbRaINsuL60r6SkApib44S+O72V5tJtKDynclLJexmuDHywg1uIPHcRNJnjnaQ4foTmyBICdVlRHJiw+8nSGjz0btX0Hsv00/I49bDv0j9hixGRhN+XkEKqZ4ovAXPidsbHbaWegT7sfDh1EDYfYQ4fwR5bb7KE0FikapOhdLmJ9tO/ZvkLQQXhrcY3F1QpXN+iYfXRVjWksOuopZOjCma5N20Bq9nfrZR9dsG3VsIFzeDNYLybkeLBZnJAxgZDlT7q8oFeM1uwSGpImdgGCBWjKaCd2wHvBisL5UJUwtQXLTWAfjkzCNWtSCdYFy9Zh6RmVjm2DhlHRUKoGrToLWOiYgGAHK/Ev4DQoqK1magsWzTTYzCLoeoIaB71j861/YLr/XlRhqG6/Hb7zHezSmOFogN69i2L3GTzq/ru5+9EXYo3GRD1FsnoV8YjyDJpljiycwdAMgpZqxxLm8L3oxQP4QwexSyHWuMkUby2qqYO9c2IRnWt1Ed651mXLNyH2NZOgo5KxQhVT7LSimFYUTY3aVqPsIoyCO5dXGjFdLOhXP6R7Lo1FS2jIKV4dvQJkU9qofI+wGWz6ASIj46SFsH52IceGjIxTB+vFhBwPMjJOHeR7hE1hSz1ASGz5Mp/9D9/NMg9rMRF916X++3n2IdXidY3kVj7l9luvJ/YhNT5pKDhcLbCzPIz1uq2fNr6mlkHQSHjHQTmdXe57DOollLeM9t+KNwWj++9E2Zql0ekAVGaE9g3KWyoZMlLLNL4AFAM/plFlYFK8YioGrUImwvoiuDGJhIZzbdbPx6ZNK5tddRsYtnym6QuxGZazIB7laDUQSWMRWIijP+XPsw5HrVHfMGTd+sYcHbYGUsYaAp/lJepzUmYsnptJE4HvWIj2GPEKryQ6L5XUKjil1b6gdgbnFVpZSqkZyISBC37zZTPG2CkqNn9LTZK8qOAGpQxNPP4nxbY2Bi2PdnNA7aGQGi0NjR4wAJwukGKALCxiFhaxd99Nde8BjtxxDwD/eMM/Mr2/YtfeHTzin97PaRc8HiWCEYU0NWrbTrStOsei6JKiJktM9pxDefh7LH/fEylOP0RxcD9a34kajajvOxj0C3WD1A0qMRBKIUpatgHvEFGICBJdWLxrcE0TmIiYhXSNDWU5kbHQSvBKIcZAbMTVZx1SCY94i7J1+7uR6sV77m4eQUTFmuxNHSnrxIQcD7YKVKyhJ2oPEuPQy1+3zkz9a3WC8wp8+DuxhklTsDTVLE0VVR2OE+tCs7jRwLNtaNk+qFg0U4Z6ipFm5t7EeUUTb8EqH3SNwVFIIRLchSaNZmgsEynxCCOzjDNle5Nrdp+OGo3wVcXkzv3cc+PtHPz2QaaHK3Y8ahuPevrj2PHkC9i9fTejhTMomhCjajPivvKReITSjrGqQHnH4dEeCjvBLpzJaOEMRtv2UwzvxNwXYo09dAhfVdg6MJJSlsF1KbK7PjWfUwrRGjFJyyC42uOaGlvVuLrBNxZvLUW/WZ3SiCkQF5pXthqRnqOjEosWoUBQeGxqqDlXBRLYXrWBvg595HuEzWBLPUBkZKyHzQWTjIyMrY4cEzIyMhJyPNg4tswDRKph7LMQsL6DTz8jkGoeE2sAoe4x8Qypxi6xD8l1WKIOIk2f4NDtfK5f1+/hiN/G9mK5nb4/zsJPMVLjRLGN4KCkjGPHgdvwxQD53h3I7j2w7QxMz8Wl1kO0qymowIdabItmohYZuiW8GuDFM3VDBj5kIioZglmgtGMaXWJs6B8BtE41q8GLpERgGHvKAqSsYOuwJEjaRtEt23H032T2N1x1/ShkFdZnXaybXcjYEnCdy7v3Fi86OotFpkHRZc16LAR0x7xTGqsMjSo73YMvsC6c11osA6kYqAnDZolBdQQA00xRdjrDPiAKq0uslMFJTYeMYi0lDaGO+LA6Lbiw0DBVI6wYFlLvCtfAaBEmY4jZ/0N33A9AvVSzfNsEgJ2PWaK65z5KY1BNA7ZBe48qQtbSK40vQnbPDRcZHLyTevturCrQumR85l6GpkDt/0cK76nvO4CdVvhphYouTKo0K2l+JaiyQPugiTCArerQGyIyEKKEZnkamAqjQ/+JIjCgqZ9M/MFmFh16dViwwe1JxHbncc+tyYs8sNxgjgmnBJS3GAEnCuc1Ljp6JW2BE9UeS8mdqX9PYL1gnaaymqW6YHmqWJ4qpp1BEWUBi0PHjlHDjsGUbWbMUE0oqGIvE9Wu34vg4rWxdoF9qKxh0mgaK1SNoFSoemhcASVMzZDx4DTMjjMAMEqjlg6x9P/+H/d/6w6W7lniwI2HsGOH0sLh73yPwc7vMBguUA6+E9zOgOWz97FL9mOaCcpbajNCuSZovPSIKUOmgxGTYpEdZsgwVRF4F/o4TCZQKWQyDUxEjA04H85RJehBGRhKCBoJwNUdK1kvTwNjqXV4lWXbB6LVQ/X1DzEO6BR7hODI5Ht9HxJj0bv/27SLY44HG8aWeYDIyFgPqQnVetNkZGScGlgvJuR4kJFx6iDfI2wOmavJOHUgtDWRa71ybMjIOIWwTkzI8SAj4xTCw3CP8J3vfIcXvOAFnHbaaezYsYPnP//53H777Rua1znHW97yFs455xyGwyFPecpT+MxnPnNsB3gUbCkGohU8tcK6laVMqwms0/ehXGnWsrU/n45lS1psLF+yrTXcSjF292zmUFiv27E4FKXUKHE03qBwoeworucQOznN3YfBM1bbGDAOzWvKBVw5wu08C10tUReL1Dp07SzsNIg9VYl4R2kDNTkutuPEU6sBxoVGdFosYxYB2GYPckTvRCnLoFkOJ4kPNq6CjQVYs6Ud7XZJ3CaROI9bWdrgO2GTSGrbtfHfsMPsch9Q+VJYwQObL+Mkgp+lwUUhYkP5jmhQJhyvuFhWl0rmeqVOgFWGSo+oGLS2rbXTeC8UylKqmoGaMKqPMKiPUFTB6lCaKpYvSaiKEo1TRShh0qF8aaLC+WfR1D6UMAkeI02wjgUGzf1Uwx2ocoGhsygO44eLaO8YOc8j6lC+eMZ5Z9GMp9TLU8rtC/jGUt21H7O0jFpciKVMFhmNkB278NFWOeyPUF6lbYg/upkw2f1oRuMlpKqCreu0wjeWpgrrU3UQR4qo8FcJymgkiquV1thphSpMW7LQ/jLOBfvXJrxwbpVzndjALo6TUBqplANvQ6zul6P1Z5PwO24KOSZseQge4yqc6DbLbJXBeR2s1OP1uW3eRrpehXsC5xTWacZNwXJlODJRLE+lLV8qo5vpsPRsH1pOG0zYXiwzUssUdto2QbQYJC6z8YbKhnLCyhmqRjO1mnGlmNbhfmRYOhqnKJUNomo3QOvTYHtc72gXC+UdLO47n+FZZ3L6/Yc5+wcOMb4nlDea0YDx/gPUh79CsWMb5aMeCcCC3MyCs9jdj6Ae7aQgnDuL0wMsDXahxdJ4w1htQ7Y9EhVLpcu6QtWhsZwdh7JJVRRtSSKiQmNIrVHDIUUqeywK9GBCM55GS9dY0tS4IKiua3wdy5fcXDyIsVq8C/vRq7bEzEWhdLpv6//eD/xgOX7xYGlpiYsvvpjhcMgf/dEfISJceeWVXHzxxXz1q19d0VxyHm984xt517vexVve8hYuvPBCPvGJT/CiF72Iq6666rg0l9xSDxAZGUeHzDzYrTVNRkbGqYL1YkKOBxkZpw6O7z3Chz70IW699Va+/vWv8/jHPx6AJz/5yTzhCU/ggx/8IK973evWnHf//v28613v4ld+5Vd4/etfD8DFF1/MN77xDd7whjfkB4jNQPrCO2FGUB0+WtlgbqZxXGocE9mHeUZBMWvdOsM+JPtHL232sG8H2/8/NZ3zCI0Pu99I043NOyyKe9nDbrmX0k8YyyIL4lhaPBOrDBO1SOVLHnvv/2O6+3EANKpA+warChanBynqJQ4vnElNiSbYx1lVYFyFloaJhOZVE73I0C9TS4nowFyEgUgrbAwN5pizukysBEEkLclqzbUN5nyyVdzEb5iWv6IhzKaawayN9S3aMrYCku0nhN/cq9isTAOO0LBIOlZQYmY7WBOH87JRJTUllS+Z2pLa6da61cTGcYNmmbJeoqiWUHU8d1pRbxAtWzOkMUOsLqn1ACsGh6Ly5Yz1oIp2DQBDt0TRjPFKU5sR9a7HMhzdj7gGt/MshjvvYMejzw7r0waqKf7IIQ5e/3ch++8N1X0HGA5Kpt8LjaaKRz8apmOkjmynKUBrikP3YIqSavF0zPgI4ix25xnoaoJaHqMHJa5qgqUrhIZQjUYZHbToZRBRSqFQgxKcw04r3DTYPbrYSM47F1gKvXaNsfgowuw3lgvpYMSFLK5E1sQrvSKmPxDkmHAKwIN2DZoGJxonoaGbFQ+YVkCt4rUuyfE7UxWorGZca45MFEsTYTL1OAfGCIPIQCwOHNsHFduKMSO13FYC9FmPxhdUvmRiB0xstHFtNJNGM20UjRWcE4z2GOUptGNoLKVuQgM7P2CqzgSgKTSDPY/G7/nnnLV8C6ZeRg22s+ee25G7v0P1j3cwufcg0/uPUB1epnzEHgDGf/s3jB7/ONR0zGA6xpuSZnEnThXscDWTcgfjImS/G1UyHe4EwGy7H7V0GDUeh/N7PMFNK1RR4AclalAiyqCKEFtgBIBaqDFVhRlPsZMJdlIFFlgCY5mspcPEvea1qbIhNQD0DlyNko6JTPvWxbu0dt4HWKVwPOPB1VdfzUUXXdQ+PADs3buXZzzjGVx99dVHfYC49tprqaqKl770pTOfv+xlL+Pnf/7nufXWW9m7d+9DNnbIGoiMUwhtoDnKKwukMjJOHawXE3I8yMg4dXC87xFuvPFGnvSkJ634fN++fdx0003rzjsYDGYePtK8wLrzHwtsGQaiD/G+ZSGOOh2+ZQeA2Ghtpe2XTratPevWBC/J5k2tuqz+uiwK5WkZsMQ82LAGAEo/ZlEvc0+1i3G5GBgML0zUIk4plu2Iga8YqjEHdj+OPTd/EYD95/8wo/pw1EBYJoPT0L5hwR6i1kPEO4yrsKqgbMZ4ExvfKENhpzQ6pFBqPaD049aiNdWHr8YkdLXIOuofIgHo7EyjuJa1WOPES9oJj8wySbM/VljGOr/pesgez6cAvAfb1cGn5nGJVfORLUvNDlsojadrfGjF0HhD7QyNVzivUOIoVcNAVQz8mEGzjKnHSJ/xUBqUxuoSZ0oaPaQ2gXloVBnroH1rE5maSJYybTOW2jV4UQyX7mG8eCaHBqezXOwItdMUFNvPbtlC5S3bD99BcegeTrtgzK1X/x9O/yePQhmFPbJEc2SJ8vRduCOH4eABpIxNmhYWwRTBerkoKQGpJujmIM323WAK1PZtyNJS0DqkZllVgzKRuTE6aEyKAili5hHQzuGrwEIk5sLVwdZVaR0ylaaXeRRpY4z40KAunelBm5KYBqL2QYWmU0nHQS9budnDJceELQ/Bo2Mdv8JiVbj1CY0iVdtgrn99SdaueLBOUzvNpA76hKoOpfpaw2gAC8Nw3G0fVCwWYwYyRbvYrFUMVhXUlNSuoPIFUxteVRNiTW0T8xBOg2HpKI1nsWxYKGqGpqJUsZmiFw5WQUN19+FRCHdO+P/VZ/F9u6Y8YnA/288+k527HsVo+HfUR77K9MBhzGiArwL72CyNcYfuR2kDKjRhLA8fwG3biR0uousJZbmE1SFWpOu5G4xQi9tRh+4PTKJSuGjXjBJUtHSVskQGQzBF9yPYBj2d4qcT3GQS4oJziNaoskSKYqWGkp6Ns6sRcSjpKkR8atLZMjxF+9ul332z2Gg8uPnmm7nwwgs3vNxXvvKVXH755TOfHThwgF27dq2Ydvfu3Rw4cOCoyztw4AA7d+7srm+9eQHuu+++DY/tgWJLPkBkZKwK2QA9mROOGRmnDtaLCTkeZGScOtjEPcJ4POaGG27Y8KLvvPPO1Re3WnJ2rUTq3DQPdN5jhS3zALGRxnGzbc5l1b9uFfYh6RZWtEqfYx5cryJsNSZD4dtsY6q1NDQo6bKlS/o0hn6ZQllqXzC1JZUzFMqGpilisV6HzKer8dt2AHDmDddwz//34wyaZZYGu1isDjLR29h58Damo11Myu1o1zCol1ge7GTQLIf12ymTcjuFDw4VxlU0uqRopjHzN/s03mofEFysQU6fiQ813C4xEqx0veoyibOOTKs6OPV+q36DnweD412S8J3vfIcrrriCL3zhC3jvedaznsW73/1uHvvYxx7XcZySaLPRKtbWh7p6IdbZo4L2Qbpj2InGSgiLFhPYwejIppWlUDawD0wYNMvoZhpYOqUD80DI1lkzwJpB2zTOignLxrTxwkioyS5dYBIKO8XYKdpW6GaKcg14j2nGMICDdif3jLdTWYUi1EYDnLFwmOnOBc5sKszOXYx2LfDN/3Ez5/7weVT3H6bYsS00dGoaJnfejR4OATCnTQIbYS1q23bUkUO4pSXkjDMx3gd2whTo7duw4ykuOaqY0CwuXMCC85IUBjUcogbDkJYVAWfxdYOvpmG/1A2+iUyNqK4BlaiukZxzIE2IB8mFqd8gLsUarfGuCdoWpTvN1gM5TPJTwqkBn9wAHatlplOj2IR03juvaLyisoq6EZKpmDHCaADbRo4dw8A2LBZVcFjEtpoH6w2175iHyhpqp7EusA4AjQvrMjrcGwyMY1Q0bCsmbDdHGPgxxlXUesiYBaqonbjrXuGb31pCBJrG8Tda8aQLzuScPaexd7virJ13ogclw907WN5/ABdto1RZBO1CPY0bEzL36sD+oEkohwy0xpWjVhsB8fo/GKIWFlFHlsK5H1nE1DQuMRAMRzAMWksfG1mKrZG6Qk0nMJ0ERsQHKicwFmbFDby4BmXTfUPvnqStbAgshFVF2wTX9dz0NstCbDQejEYjzj///A0v96yzzlrx2a5du1ZlCtZiJvpILMX8g0RiLhIT8VBiyzxAZGSsh/7DztGmOVZ4sBZtGRkZDy3Wiwn54SIj49TBZu4Rzj//fK6//voHtb59+/Zx4403rvj8pptu4oILLlh33ul0yje/+c0ZHUTSPqw3/7HAlnmAWC3LvZF5+q3qU/1j3w9apHNfmtE+zDEPad6V/SC69zNuS3gMNRqLsVWb9VTimMgCp5lD3N/s4J7xIkNj2WbGHK4X8AgLZsJhvYvT/L34ImQT/ZEjnPGtv+Kux/9LvCimJjz5q3rCqLkbd1qBUxrlLTuW7mrHVBeLLWMgBMeFQbMcWAg7CVmb1WiynvtB+j9lbxITkf6uhT7rEFiGNeqXZ6ZJDjcP7MK+XpfJY4kHY9GW8SAhAum3VqplCPrOPcTjT6IuItXQpjpai277wRhxaGUZSMVARfbBVpF9MDgpcFFH5JSh1kOauCwnCudjDXFkKRWOwk8p3BQVM+2jyUHM5BB6+X6krnDbdoK12HKRoV3ijvpMvntviYpW69HciPu3FZy5bURzRsH32Zpd5z2G27/8He644Xae8LynB32C1rhpRbM0pj4c2MchQcPgG4u7+3s0S2MGu0+j3BZN5rUOmcGiwOzYhosZRu894lzIeikJNcxFEdiH0QjKrvZZnEUS61BVUE/xddOxQ4mt8A7idJJijkoZxN75nvo/eBfYDx3YpAejYzieMSHj4UNbx69mRbGwMkudru2ND9qHqtFUjcI6QST0fSgMLA4d24cNi0XI7Je6Cv2dKIK+0WkqF5kHZ6itprYK64PTUoLzoBUU2lIay2IxZYdZYrs/yOLyfRSTQ+A91cIu3MIjKXQ4F6savvG3tyHxnCjKkrI4m7oe4c56NIOzljnjvP3c/9+vY7hre3veFTu20Rw+gloYtSykOBfOuekElg6DKJR3lGc8kmZxZ9hPkW2VxW3o7cuhh4MbBy2DqDC/1jAYwnABNwpJMjtcxEU9hXIN0lSoahKc6+oKbAxmKW4kNsPWbV1H6K2jZhhjpHNiUt62sduJC/qVB4DjGQ8uueQSXv/61/Otb32Lc889F4DbbruNL3/5y7ztbW876rzPfe5zKcuSj33sY7zpTW9qP//oRz/Kk570pIfcgQmyC1PGKYV+Idrqr2NZ9LyeRVtGRsbDjeMXDzIyMk50HN97hMsuu4xzzjmHSy+9lKuuuoqrr76aSy+9lLPPPnuF4NoYwyte8Yr2/ZlnnskVV1zBW9/6Vt75znfypS99iVe96lVcd911/PZv//YxG+PRsGUYiIyMjeB4Oq7ceOON/MRP/MSKz/ft28enP/3p4zaOjIyMtZFdmDIyMhKOZzxYXFzkuuuu44orruBlL3vZjE5yvsTZWovtuQsCvOUtb2Hbtm285z3v4a677uK8887jU5/61HFpIgdb7AGi39ANYK2OgjNPlL7/ZElbutQ1lPFt+VK/HCm1Tg/N42IJzyrlOunzVL7kvVBITeknaN+gfBBbFS6ImWo1CGJpGrQKB8sZw/u5e7yT+8eh8dQd9y5yZMlx/jmP5Ol7wjh3NhXu9ltYeMwh7h/sAQ07j/wjXheopmrH0+gB6EH7vtaDttGN4GMzOoPyLoiSnCU1ZFmtbKhfytRCgrVkaLTXlTHNlygJvWZR82Lt3r5OTen6Qvk17V6PAs/KErPVpoGH36It40FABJ/EuTBbvtQT16XvndI4ZdpGbzWBarc+lDslC+dS6tZq1cTyJatLvCicMjSRoq/VgEaKTjDtZebYNTQM3HJrw7rt4HcAQunSvfvD2E7bjbr3LhguYAaHKcttLBZTjF5EKc8d+z0HD9Zpc/He8Igzz+ZfnLeNfd9/iH9y173ccf3t2GnF6PseRb3/e7jJJNouRiFlYbCTabB0rGsGu09DtMYeOIDeLaEMwdpQmmQtRR3XpwTfWFAqCChVtHk2BsohfjjCmwHehMtLW47QVEhdIdUklCvVdSeeThfG5I2ZyiHan1Ri+VIsbVIaJBgxSGxQl0Tsm8F6MeH4+ZlkPJTwCFaZcK6KCqWKsaGjoytrbM1UvMJ6TW0LJk3BpNFUjeB9EDprBaOBY7G0LBQ1pQ4lOApP4w2N1zTOUFnDxBqqJpYuuWhAElxPUbHs12jP0FhGpmaxGHOaup8d4/0Mlu5FLx1EJmNQCtVM2a5KFkwQyJ6+c4FyOOB7t9/B4u7T8M5z+y37KcpHUhQDdj360Wx77JPYdcFt+MaiooGCWtTU99wXSpe0DmWFTYMbL2OXlnGTSSxd3I5yd2JC3zpcLJlmMESdtpPCe8SE8sggqI6iaqXx5RA7CKXUTblIXSzS6BLxDu0ajJ2g6wm6HqOqSYgPLpUuxf1ZTfDGBrtmpdsSpmT7npp1eqVD6Ii/t8K2pWqbO042fo9wrPCYxzyGz372s+tOt5q7ktaaK6+8kiuvvPIYj2pj2FIPEBkZ62Gj2omH26ItIyPj+CB3os7IyEjI8WDj2DIPEKmhW/t+A+yD82qFCBpobVuhq4hL80JgH9K8HQshLXuRlpHmV0R7U69m2IeUkTe2YwhQhBF5Syk1O4dj7q+2cWhcsP+A4otfuJ1qUnHuBY/C2iHDJwal/T8/7R7KxzgWD36bO/Y8lj3+LrSt8EpjB4tts5VGDxjUXYMYqwoKO50RHLXCMu/ifLoTL6/ydN42c+nvfxVYAoVt95+iYyE6m9cwv0QWpNuBPUvcKLDu27I9MHcUacWsR5sGHn6LtowHA8GZQWfz12ce5piuxD40Zkilh1QypPEhLNbxrxGLkYZCagpfdQ2idBlF14ZadcxF4w3W6dYSWkUWE2AgU0o/obQTxDsWjtyNWToYBnPPXfiqQsoSd+d3gvh5OkEXJYNixOk77uGxZwz59r0LHDpcc8d3wny3XP81Rju28f/94AV884ydnHnOP+P0p9yKGZbBWrEYoLdvA+cwowFmFBhIGZQoaxns2c3k7nsY7z/AwvediW/q0GRqZ9xXZcwaNh197uoGV3fN88KOjvFPGXxR4orhDCsgTYVqpqhpGVgIlQSUNjASTR2Yhdjcqv2tktBaR8vW1G0LENe3hqbNTm4c68WEfDOxJSCBbW/F03PMA9DeE0A4h6euZLkpGdeGSa06+1btGRSehcIyNA2F6q5xlStovAqN4hrDpNZMG6FuBBtF0yIercJyIknHMAqntxVjTvP3sf3IfgaH9qPGR2C8FM4N51D3fY/RP1lguPNsAPbuWeYHLn4cX/4fjgN3fQ+lNd55bv0HzWmnPYoDZyywf8fjecy+J8PyERiFBnQsH2awsAiL22A6DRaqVQVa4+ua6X33451nMK0odlv0QphPtseYWg6RRY9yDiOCG48DKykK71xXIRDPf6cLajNgqhdwKEQ8hZ1SFFPKZpmiWEJPl1DT2JQz2suKrfG2iexDYJa9MkHI3WMeIBCT3oX1OtEoB6jNOqlt/B4hYws9QGRkbAQbDSYPt0VbRkbG8UG2as3IyEjI8WDj2DIPEKmp21Gn6dU5rmbBCh370DIQ0mXe28YyUfNgfaeDEPH0K/yVD03pCmlQEvQTWixaGrRr2oYnYdrOfkx5ixaFcRXb1CGs1kwYYLTn+uvvZfnwMs98znk8co9w1s4pe4aHAKiq7fhdYXyLahlvhelgB4PJQarBDhpdol1Y97RYpLDhCX9YH2G5PI2F6v42mxp0DR6nNDhmxtqxMfSsWiUqKLrfwHtQYnHodn6PRNvMOXvXOR3EPOPQrvtBshDHu77xwVi0ZTw4eFN29a+pbhZmtDNeJDB0UftQqWHb8AlCHbSIbxs4Gmq0C1l3qwoaVdCokpqSypdULtq/Oo2NMUFLbB7pNaWqUWLRtsY0E0wzRY+PwP+fvT+Ptu2s67zRz9PNOddauzl9ctISDEgIvERRkBKE3AEGpSpq2aC+8Cp1lVAwquy9wxKQwovKCFKMskEsL6CG8qWipQVFjVilwH1fCSpdeSWJlLQh5CQ5J6fZe6+1ZvM094/nmXOttc/O2XunO03md4x99tlrzTW7NZ/ffObv+/t+f6eiHibUNaFpImvgHME5hDaIuiQ/cS/7vaXZm8P+g4ynQ+7+Qhw3h666lKc841Iuv6zg0HLUZ8iLDrOsVMzuK4U8eBFyeQVx9AFkFpkSpCRUNcE5stUlxvceY/1LX2PlyZfhmwYxGSOGo9hQTkhkyu6F4GEynZ1s7wnOEWxsEiVcAyEniGTznLKQQqguIylJ2ggf2YfO2lVIkHVsMNeyF0pHFqKFVJ317uzLjE3ohJSLr293ndBrIJ4ICAiszHDo7v7dYr7CwKUq+tobptYwbTSTRlE1AusEUkQNRK5jI0cl47299nEqZb2ksppxrZnWkrIWVDW4dIvTCowWGA1KBrSMb2TKMtAVI7HBsDxJNn4QWY5jJj4xcP74MeTyCk5lDOUYgFGxQfj6SxgUT+ULX7yUB752kiNf/Bq2sVS1xzpBFXJOXH4dw8kxXNIwDB/4IuW+y/DKkG8cjc3dbI188AHc9EgcfzjqtQ1UkaOqqNcSeUHIBwSdEaRCAjLFVF/X0Y/WOahKRDVB5gMApBlEu2oVG3SGEDUp89UOreWzcM3M1rXxCMq4P9pENlkZgtaEZJstpIAgY2lw6/ac5hTSR5Z559fJ46+BOJ/R20/0eALh3LVo69Gjx9lAb+Pao0ePFo/vHOF8x4XDQDCXvT7DM2LHQgSx8KQ5r2HYsqnMnNtSCAK3uXlcTMl3n/WtxkLM9kcS3QdaF4LYhC3pKtrsu5AMmnWkdwRRUWUDhAhoOeR7XrrCcz/w/2I4fhKfueYnODYecvEgZvcn+R5ylWGlYbk5TqlHFGGdOl9hXOyL2RWhUSGyEC3jkTcb7D/1JTZGF+ETOxDELDOABOFDPKIQf8dzJACJZMZOBBkbQs1YiHjsoWMWAmKezQiz8x3aZlLQOSx0yz1szcPpeDzpyd1YtPV4FJEy321jtxbSOwh+xmSlemgnTXROwmCD7pjGgIhNJNuf4KKLC7HhYiNymmCoQkaTGkVBzELG3Qhk0hKEQEmHDTFzntsJ0lt0uRazjCm7F1INstCGANH9KC9gvAFSYGzDQV1gliqyKy7muv89Opw88/jHaQZ3c/fSMyhdHvVWK/uRJk+6AondcwhZl+jBqGvWhFLIvWvYe+7GVjXDi/dz4nN3M7n3AUZXXhprmSG6KynVZfVU8OADwU8JzuEbC2WFkDI2kxIC2WoRMhaY2cj6pBrmeVYheELrypRqnYVJGcaWNWrX2WYUOx2VJODhYTaA6ksWnggQWAwO1VUMzOsTIVYWtI0jG6+ShkFSJ/YhBJAqdMyBlPFz1ktcGvPTRjOuFeNSMp5CWQWsjcspCca0FQuJiVDxGh7qmqGcMmzWyKoUF7yLY1Wq6MDU1DSXP5UmGzFoNuLnpsdhGcxVF3HpwSFfvX/E/zqwxNJKzmUXa6SsMaKhNEu4Jc2gjhULk0NP5r7Bk/FIloeHGNankN4ysg3Zof3oyXTOoW2u8aNtCIMlvMkRweMB6SwyMabB1fgyVjdIIVDp3m+ETG51iqAFNsRGe16ozi2pEy/7WVPJqP0IqallHRlZ4/AhsqhByKiFCB4RBB39KOQZZoFnRh8Pdo4L5gGiR4+doJ0cPl7YqUVbjx49zg4e75jQo0ePcxd9PNg5+jPV4wmDtr7xzD89evR4omD7mHBu4F3vehdPe9rTyPOcpz71qbzzne/c0efe+973IoQ47ee66657bHe4R4/zEP0cYXe4QBiI0wVR8f8z8nxeYD2rZZs1nZOEBQF1K55ul2nfmRdOt7+7XQgz0bUkgPDYoDCiQWEX6NJWKOxTuVBbUhQQVHoYLc5cyXJznL2+5sDgCPkfv5OPv+X/5oW/cZCn2b/jzuE3MHFRpLSXo9SqYCqX8Eoy8mscKZ5MIWJ5hMIShES5+Lu1jq31kFoPUb6hNst4odC+jpRiOmYvVLJgdV05gQqxNEMIhZBpWPm2sZzvrNq2G21dk7gkgGq/l/kmc/Ni6kcmpBY7WL6nLy8IbBLgS+8Q3nbXcJAqCiaFwAvZWTPD/Bj2aOGi+QGx9DAgcKl8qQ4Zpc+pnKHxisYly8JUuidlQAmFErMmUx6J8A5TriHrEpoqiqahEwoLo6N4eTgiZDnBFMjxKZiOKe77PBfLL3GxEEz+5uMAHP3yfRz4pqfz1Is/S33FNTiVIZqSYDLCaAVbLFHnK2wU+1kqH0TbWGKgq3WUVKjVtWTfaBkd3kexfw/BpaZTqYkcScQIILIMmWeEpsE5h69qfNPgqxrVNMi6QlqLcg5RNPgsCjeDVBBC/B68m9m++kBIQmx823QydKGjLYtCCggqxgUfG1YF5sqYkpCaXYgmt48JZz8e/M7v/A6vfe1r+YVf+AVe/OIX85d/+Ze87nWvw3vP6173uh2t49Zbb+Wyyy7r/h6NRo/V7p7zECIkE9fZPTmW785sXV1QsTQpzJq+CTkTUGsVDRICAu8FpY1TqXGtWJ9IxtPAZBqoG4938Uo2RiKkQPt46c+LqHNVM/AbZM0Y2VTRYCCJhgkeu3IQVg5QDfZyvLiEfVXsO+SlYtCsc6Wesm//Xg4vL3PpoRUK49k3WGfZTBj5NfJmEo89NWp7cHQFRyb7ODHJODBa5WBxkkzUZPvXMM6hNtYQxx9EKIVeniu3dbM5QJCx3JJiCOUUYQyhrvGtGURjkU2cZ+imQroG6RpMXlGZIU7oaBqTTGW6mNCO47S9zuZZm87CWQgRzRRkNGJYEFIT536inUvsxlWhnyPsChfIA0SPHjtD2FUw6dGjx4WOczkmNE3DG97wBl75ylfylre8BYDrr7+ee++9lze+8Y38+I//OFnrqnUGXHfddVx99dWP9e726HHe41yOB+caLpAHiGjI2rIMAr/AIMRFYleRzU+X8w3ftmIf5rfQsg4+yC0vsjAnxJbCx6x9yjrmoelEmC3boH2DF4raDDA+ZgVLOaIJBqML9lenWHrwH6Pws64IT34S/+RN/w/Cs1/A8B8/xTP+8f+k/K7/J0BnKamwuJDzd2tPwTrB1fuOIfEsUablMoyrsKmRXJvRl64icyWVHqKCnR1TsnQV3kdGZ84GUyTGpbWhFcJ3xyaE6tiHzc3jFs7ZFk2ftrRwnWMbtnp/p/B99uAJAeEtcu56k75BuJT5bi1dkwiyY7REQOGQKasdmQeHoUb7urvuQmIsmqAj85DYB+vnr60k7U1jRAmHkQ0qNVZU5TgKJUOYiYmliELiYghLK/hihC2WcLpAFyPMvV+k+cfP0Zxaw5U1kwei/Wt5akrz4EnGX7qHtVtv4/IbXwTLewjFALzHmiFfyb6ek9Mhlw6H7GmOApALgaymyAOH0EbjTp5i6euupLr/KErK2NQub6LIOy/mDk12bEmwDjstI3sgJbos0cMBqq5RTYUcLXdWjsFEa9fWrhFnY3axW60kpAzpfDOqKJAMM4vIduyHkDKRgSBTU7ldsQ8R53JM+PjHP86xY8d4xStesfD6K1/5St7znvfwsY99jOuvv/4s7d35hdbwI7ZGtWhfdxbjVmZYsWi60NowZxogICXk2lNoR6YdWnhcELigaFy8Jqsm2rZWSTxtm0BI12nXWy1ZwRoVOhG1wmFchWpKZDWZ7UTw+MEyTTbiyPBqBmLC1Bd8QX49APtGp1hujrOycYSRepCLgSevLHUxrViPMUIET5Cz6Z5DMW00d98nmOwZkB9qyFXG8tJFjAA9eBCtDTI7jsjyjhmkrhB1iUyN3ZAyMhEmi+YHPnSMpJhMUdNo96zLEllOKfaM0aM9ZMUKVufRCtZbVFMiXBJrb54ntH87G+OOcwgdCIlVDj5WSIS5qoVothDwUi9Yd+8E53I8ONfQayB6PGEQiAKpM/309Y09ejxxsF1MONvxoG1E+YxnPGPh9WuvvRaITSl3guc///kopbj44ou56aabOH78+KO7oz16XADo5wi7wwXCQCQmIcyYhy57JbZ+muwaxc393txEDqK12/w2RAgPWXu/qL9IWgERM5pBSAiuy3h4obAyMg6FH+NE/CqkcOTCoVPDKr72FQDs1c9Am4zsSV+PXH8QtGZ871H2HYk3kPsv/2YEAR0aNsISy3lDCPBgucLlwyM0IYt1n8HSqLxriKWSraVTGVkzRruaWhcdW9KyBl6odOxx/7vmcHMaBi9Vd26kcPFMnoEpCELsKDsg5rMK3Ye3eG37NfX1jU8EhIBMGp/2b+Ed0jWx6ZlSC5lqGSLTAHVk40S8tpWPWcr5xo9WZfF6FJHPbFnGmK2c2yQiNZGL7EMuawx1tHB1Tar39bNaX2Ktv1hehSJl7KWiyaMuSXiHMRnju4+wfu9xVi7bTz2Ox6gyzdpXjpAtD5memLD+93ex9LSnIA4cQliLXGpYVhuowjF2Qw7amBUMQuKzAmErxGgZ5QNuY538kotpHjiKPX4COZkih4No5axntwuhFEKryJo4RzOpCD5gJxV6WmGmFXoyRa1OkcNYby/yAqF1HLPBg7Xd8Qspo3Xr7GR0TNHm75b23AkJUiY9RPxed6d/gO1jQnzvrrvu4tnPfvaO1/rqV7/6Uen1cuJEzCDv3bt34fV9+/YBbPsgcPjwYd74xjfy3Oc+l8FgwMc+9jHe+ta3cvvtt/OJT3yCoijO+PkLB/HeCLESoLUzl951Dc3a+z/ECgKjPMEIcg1SRrYgVw4tLVrE67ZlIFvIdNlKlRpJKpGciQVai8g8GCgyT2EcmYxsvxEN0jtk0gcFpaIVaVbgdYw5uSj5h1NXxOXVLG6shqPo8Umycoz9x38gHw6Qe/fj911EUCo2qzx+FHv5UwgqjuGhX+fw0pDm8Conxyra0gpPqUdk+RJBCLTOkFlGWDs5O43WwnSMLCcwGBFMHl9XCpHWHVnJimAdYiOyKXpjjFnfQG2so/fsQy+t4AZLeJ1HTUOKz5EhnjGctOfW+9hQcs7qVYTISErRxOaW3qHS+I9MpwK9W1aynyPsBo+YgXjpS1+KEILXv/71C69Pp1N+5md+hsOHDzMYDPiWb/kWPvrRjz7SzfXo8fARkiD+DD99euGRoY8HPc4rbBMT2ngwnU759Kc/veOfI0eObLm52267bUtXpM0/L3rRi+LutaLQh0iEbYcbbriBf/tv/y3f+Z3fyfXXX8/rX/96brnlFj772c9yyy23PKx17gZ9POhxXqGfI+wKj4iB+KM/+iP+7u/+bsv3XvWqV3Hbbbdx88038+QnP5nf+q3f4qUvfSm333473/iN3/hINrslWmagq7s/g0OPICw0fdvKpKv9rMQnh4bQaRxCcnGYX65jMMQioyHx0YUlzPap3c5YrbLaHKNWRde4LQSBwjEVIwozZLiyGjNuwJEn/RNyO2H1wc9THXgS2U3fzAPZKgClGJJRsVw+CAXowqGFpQmGzJUdw9Huc6dVIGBshZcqureE0NWOh7lzGGu/BZvlIYLYHC6EqJGIzlIqZjeTfmIrdN+NOP21eZelhXM8XxspTtez7AR9k5jHDudSPJC2njUaS5kq4V3MRgm5UEcvvcNQooXsXEEAlKtRro4N6ACvYj1t0AKnNU4ojIqRQApwcq5JZQAtPUo6tIg6isyX5M0GypZx36oyuRvNheE8j43j8hyhM3Q9wSuDMwWhGKAHMeNXnlhn9YoDcXs+UK9PWLriMKvPjLXRYjCAcgLTKYVtuKQeE6SiHO6nWH8gLmPbxm0S8gFogwwed+IE5tBB7ImTsTlUclWRg+HiSVYKqWOTq+ADwTlsY/GNxU4qzLTElBV6OTIecjiIzfGybHb+Zcw2irQ+fJhjF9K4V6neOvjYKKqVTbSTahmbywkykG7X9/edxITBYMA111yz43UePnx4y9df8IIXcNddd237+eEwnut5pmF+nS3z0L6/G9x4442MRiM+8YlP8GM/9mO7/vxOcS7FA0EgcyUixIaQretPvNfopPWbaRiNdKAhVy6yETJqmDLRoBJD6YKiFHnUQOh4PWdGUORxoimFpG5C2xuRzAjyTFBkgcIEBsYy0FGbaEKF8jPWNKjYQC4IgXAW3UxZLR/gyauG+6b7KW2cLxSqxkwnyHu/xH3/42PU44rB3hF7r/06dF7gVvbhhiuo8Tp6fBI3iI5Ke09+CbNccWhvxn2rl7BXnyDzJSIEnMqQyuIGy0DMMocTD8b9cg7qKsYC2bonRosqoeaaQ3qPLWuCizG4Xptg1idkGxPMeILas4paWkElFqN1m5qxDy2zoaP2YW47qBhz4g4FhG0Q0sVqk7mGvEHp1Lxud9Pcfo6wczzsB4iTJ0/yUz/1U/y7f/fv+OEf/uGF9z7zmc/w/ve/n3e/+9286lWvAuCFL3wh1157Lb/0S7/EBz/4wUe21z16PAwEtndY6JMLDw99POhxPmK7mNDGg2uuuYZPfepTj3h7o9GIpz3taTtevtU63HHHHQsPEK324elPf/rD3peHy2rsBH086HE+op8j7A4P+wHi53/+57n22mv5oR/6odMCxAc/+EGMMbz85S+fbUhrfvAHf5Bf+7Vfo6oq8jx/+Hv9EJjXIMT6+1mfhrDJgWkz69DWPYsQFj7nUbNlEhuhgsen4DvvHb+5xUj0amnX67vtAlRywL7qCJUeUskhCtutpw7x3JzILmJy7Q0EBIUdc7Q5yJIeI/Z5pmaZ++uDXOm+DIA1sTW89JaLP3sbkyd/Q6ypdBUbS4fJ3YRJtpK0DL5jPKzMECqQNxt4qaOTk28WGIrunApJSJ/z6ZgiAxF9C4IPkFgY39YibmIx5n/H9+e+v4dwV9p8XtseGu2+7Aaut2h7THBOxYMQEM0mBqKFUnhl8FLjU82u8rEeWgSHtmVkCIgshnBRKxSkxpscsui97l3VXeNCBZx0uFSva1NMkMKTSYsWFoUjtxNMPUaXGzH77x00NSxHFhHbEE6dQBRDyAqkrTHTUzhTRIcTUzB62tWYlSXKo8cZXnlp3I4xNCdOoQ8egMNXEO7+QlyfyXBHH2Byxz8wvPwSBDAyGrlvf3y/KuHAxfH4tAFtEPsPoZyjvv8oenkJUeT48QShFCGbOSbNZxz1IMfXFjut8LahmViErPGJjfBNPIemaQjDyGSILIu+7qnWG21ijJzThCygzTj6ALhNbisi3sm82/qz2+BcjgnPe97zOHDgAO973/t48Ytf3L1+yy23sG/fPr71W7911+v8sz/7M8bjMc997nMfzV1dwDkVDwBCwLgyMo6tfg+Bl5pG5TQiw4XZ/URLm7QODiMaMiqMr9C2RhBwUlOrAUhwSmETA+G9SD0eJMYImkZgXUAI0EpQ5CQGwjHUNbmI7ouZLVFNCfMsacrwi6YC11AAB4JnOTvB0EUGSp+aou74W478fz/JV//2qwA85YZrEpvn8TqPmfiLrkjasDQWT9zPnvUHEc6xsv8ydLVBEJJy6WDM2iuN8BqRFcjBKMYrgMk4nc/EoMJMd6Q1wmhkpjsmwtXxc9567LTCljV5VZPVNbqukcs1YjCCYkBQse9FkAr0XOzeypmpY5B9Uj67Bd5ASBWZYeVOmz9sh3M5HpxreFgPEH/1V3/FH/zBHzwkPXnHHXdw1VVXdTRsi2uvvZa6rvn85z/fZVZ69Hj80AukHgv08aDH+Ytzu5GcMYZf/uVf5rWvfS2XXnopL37xi/nwhz/Mu9/9bn7jN35joQfEm9/8Zt785jfzhS98gSuvvBKAl7zkJVx//fU84xnP6ETUb3vb23jWs5512sT+0UIfD3qcv+jnCLvBrh8gmqbhpptu4md/9mf5+q//+i2XOXHixGmuEbAz54h3vetd/O7v/u6O9mUntaQ9erTo6clHH3086HE+Y6clTGcTr3nNaxBC8Ou//uvcfPPNXHHFFfzmb/4mr33taxeW897jnOuE1xAn5X/4h3/IPffcQ1VVXH755bzmNa/hDW94w2NSBfBYxwPoY0KPxw79HGF32PUDxFvf+lam0ym/+Iu/+JDLtI1Ttnp9Oxw5coRPf/rTu92t0wS3bRlS21wuzD1ZzkqSXGqE5hFz1HkgCoBhJs6ONrEkS1YRpdBBgPCdMFrOibA7S9h2/anUB8BJQ+Yjnbqu9kbhtIglTC5oRu4UG2oP94wPEkK0kHNeIkVASceK1ORuwhXqKyz9t/cCsOcbv4WjlzyLMl9FX/71DD//afzBS6hWDrF86qtMlmOpgvY1lRx0InAvFJUeIoInsxOCKvDt+UvHNTsvorPFFZzuRhBLmaKPnQgCSSwBm7fSnX+6n7eJjX+rM9KNbYnTvBj9sRBM9tg5zs14kCyd59YfpCJojc+GOF3gdBbL+IRA+iYKpm2JqsbIKop+uzIoIQkm68rmtFB4ofCiQohof+iCommtmH1ryewx0sYSCDfFNBNkUyKqCdTlrDmTS40bnYulQvsOEUyGLMeIpkZXE+zyfiZ7LyPPh+Sre8mfYgmp9ElMx2RZhtAGpmMmX7mHfP8e9JVXoVb3oIqjPPA3f4/Ukj1PvRJ799cAyA8dQC+tEEar4C3BREtPcegwxjnsyVPRUEGK+NOaK3iPkBJhDDLPUM5hRo7gffoJeButXQHEnBhay1T6ZHQqPTIzcWRcebJqnWtaGfxMXN2WOXXfrZuVQRlOL3XY0dVy7seEm266aVtb2De96U286U1vWnjtHe94x2O3U1vgsY4H8PBigoDYwDDdO4JUWJnFEmIxoAkGO1fCZEQsPcwpKZqNaH7QlNEwRCicKRBZwGqDkQ25itevM/G4tAzkRlA1ksYmQxbZli95RqZmpCYUPpYEteYK0lZxTLhYyhSEjBbFQiKbkjx48snx2f282ojjUEv2f91eDn/zUzDLS+h9+wmDZJ/sHfVwL9JZpItj0jQ14ui9hHJKdt892JOnMJdeRnZlHuOjykDnCAK+GCHH63Fdaq5s2Kex2H6XWY4cDFF1ja5tV8IIsYTJW0czjmVPQoquBFJogzAZwRT4VlA9/92lmCC87QwxFspTU1xoy88hTk2Et+n13cWE8yEenCvY1QPE3XffzVve8hZ+7/d+j6qqqKqqe6+qKk6ePMny8jL79u3j7rvvPu3zraf1mZwjDh8+vGMXhrvuuotp6nTYo8dO4Pv0waOGPh70uBDQx4RHB49HPIA+JvR4bNHHg51jVw8QX/ziFynLkle84hWnvfe2t72Nt73tbXzmM5/h2muv5U//9E+ZTCYLdY533nknWZZx9dVXP+Q2dpJpafHsZz+7y0ScxjyEyAf4LVpdtOJmiUemrET7lBrt3GbCSxGlOJ3166LqF2QgLTGzbV3YRvekPFu/F4rM15wsLqZgysmwh1zGJ/M95QM0OmcQxuwfFHzh+D5CiG3v9wxq9stj+KCYyiUMNfKl/wcAe7/6PwkITun9HFu5mMGznsbArXPgq5/GLu2lUZGuHssVMmaBvc3kj80qlR6ifY3Yin0QIh3V3HmURNFXYg5aUXVom+1tepAPiE68PVvvJtYhrWP+nD0UehvXs4tzOR4gJKG1VVUKr3O8zmmyEVbPbJO1q1Ehsg96soacbkT7U4hNkwCyLPrzt7EiXesqJOMDGRCYbj+kDDhkJ8A0oSKzU3QzQVZThLVx3cHH7Lmas1g+dCnBZNjBSswSVhN8MUI4i/SW8colZIPIPGSTOOHS66cQK3vwBw5TrlxEvv8w8q5PE4ZLsLSH4XCEWV3Bbow5fueXOkYg278XqgpGEPIhcrKOL0YgJPLSK8mGx/DTCVgbRc+0pzaxs9ogi4LgA8oHtHUEHxBS4uommirA7Ldz0QYyfT9oA1kBasZSLmQY22W9A9tE+9aWfdjcSPIROAr1MeHRweMRD+ARzBGkinflJJyu5JAyFJQ2x3qJECHatxIZiJySUXWSvDwZM/1NtFkNJo4FpQdI4VDCo8TM/jVogZQBZRVCeJQUOC/QqmUfGoamZCAmDOqY2dd1YidDwCuDkAqbLxGkhuDxOsNUGziVsb50MSYxCS4bYS66lIP/5Bu46OJLCcceQCwtwfIe7PJ+ysFeTDONlQbFUndeBtJQHH+A5ugxjvzNXaxecZCV4QC9/wRitAevYjxzKoNiCb3nIABSqWj84Fwcv1LOGjoKiRgMkM6ifYhNZtPYb2MC0DGUoWkIzkVmVym8yfHZAC/NQtWC6NgHF+OgbGYmFMHH5nNzDSkhTdO2MG3ZCfp4sHPs6sxed911fOQjHzntB+AVr3gFH/nIR7j66qu58cYbaZqGW2+9tfustZb3v//9fPu3f/tjUnvZo8d2iJUR4ow/O2TRe9DHgx7nP7aLCX082Dn6eNDjfEc/R9gddsVA7Nmzp+uQuRlXXnll9951113Hy1/+cn7yJ3+Spmm46qqreOc738mXvvQl3ve+9z3Sfd4SWzEPodUpzEGKWVZ7Pps401DM1gcQwpyGYgtxTdQ40LEP7fojA+FPsyZ1QuOFxAmNwtKQkYuaUzZmFQdqA+1qnNCM5ISr9wUmtqBQNReHr+GCplYFX1q7iP/3Gz7Os174LAD+9ffsJyDIKREy1nnuO/JZvCmYLB+O9q0Eap+xHE7QyFmQdlLHBlKp4YoKtrO6a4+9PSeyey0yDbHLzKz5U0gaiIXvZb65y1wDuPlzvvgdLLIfmxG1GA+nibrA9w4LjxrO2XggBMFkXRYt6AxrBtRmRK0KrMwIQiTrVo92IJxF2DpqE1rmwdnOPjR09q/JAlaqLW2hIcYYQUALS0YV7VurjWTfWsXMmXNxvKzsjU2jiLXKbriCT/vbHLiSYv2BzkLR1OOuqZ10Ffr+u2fHu7TCAxc9kw9+7ik8/YqK5zzDIFyDGp8EIdB793Lyri+yft8aB6+5JH5MqVktcTWBpkZoE+0U8yHi4GHk2gmoSkJr4wgIIWPjSKVADmg5xZCygK5qEEoSnEcoOdNAJOvX2DzPgMkIWUFQOp5n7yN7qVxnn5tWnLKJ7nT2oV2Xjo232HVc2C4m9PFgpzhn4wHxntGoAisNtSyoQsG4GTKxGbVT+ABGeYY6sgy5rJHBoV2JaqaIuozXpIz3b68MVmXYpJ1wnV28iHMBkVgIKQgqICXk2jPKLCNTM5RTBs06uklNFl0d2Qed4U2B1QV1toQXCid1nNMMDlGKIUWYdJrJabEH9kNmCuqlvWRAyHLccJVyuI8T+cVkecnK9AFkcBTTyFpmp+7Hr53k6P/8R+pxjbcu6sE2TuKLEbqexHu1VDhdwFIcV8pkyOk6oq5i1l+pmY2riUyEnBuDIv1fZhpX1gQfkDo2oOwaz0lFUAZvcqwZYFWxwEDI4JDeIl2DEnWs+GiZhzYWdHE6McHadPF6d4xCP0fYDR5RJ+oz4T3veQ+/+Iu/yOtf/3pOnjzJs571LG677bbHpMtkjx47xXYOCz0eG/TxoMe5ij4mPP7o40GPcxV9PNg5HpUHiK3cEwaDAW9/+9t5+9vf/mhsYgf70LZ6SwxEkKfpHzoHBmbZgpgxl5CYguiuIvGhbZiW1hm2+FxCm3FUws00EMIlVwDZZdedNFhhEARKOSIP0+juJGCjiQzEWrGPQRjTiIyhW6MQY5YTpVuGESpYjKtQInDN857BN3zDHgDu3hhw1dK9DJp1lt0xismD2OX9rC0dplFFdFlyJYftl6jMqGMYnDQYV9GoHBk8MqSaxE1uSS1891pbs5zYAiG66yAgOxen9nwt/BZz2Zr22knfAZucmTbvQ8s+PBwWIlq0bb9Mj0eGsx8PRMzimQEA1gyi24oeUoccFxQiBIxokMph7HSWvdZm1syszZYPRvhihM2XaLK4Hiuji5Mnxor5WCPxCBHIREXRjMnrdXQ9BtvMrneloBjghqud64jXcZwHIWn0gHG2By8UxfREZP+aimyyhkjNpsLSSjzaxJjkdsJzv26NA+YYE32QpRNfQWysEdZOUX3tXoRSXPqcq8n2xlgji5xQlYij98Z9Go5iTbFrIjMgBGK4FF3Vmk3OKO1vbWKWMbmzCCmRWY2qY30zUqJMcqXKYqMpYQxoDdoQlO6cV0RXz+wWtkGri2hZiHbczzEZmIywhYPLdtguJvTx4JHj7McDQBBjAAVTXzBuBmzUhkmtqa1AikBhQqdlGGiFlwonEyNnsi6rbYsVynyViVph4gdMmoLSxWvceYnzAhcE1s3cl4zwUf+Q1SzpMQO/gbHTeL3Hk4TXGU2xQp0tUZolSjEkILBBY4NChoAPgkxW1Co6pllhkMFhzEm8NIwvezpZuRZXiWTJnuwax5pmgqqjvkusn8SVJUuH95GvDBkc2NONYTXdQHiHNwVOJMe6OU2E1llcpmUJRbzfIxXoDCkVUoro1JbWKTONq2qCjTFBD3KEMdE5LssTY5xjVUGj8wWtpPIWJRpUmi8o6U5jGuP2dadPcabA6zz+loadop8j7A6PGQPRo8e5iF4g1aNHj3n0MaFHjx4t+niwc1wgDxAz9qFlC1omYjNCECk7Lgki4EkuQEJ12on5jGLLZCxk5ENb09tyEQEp4tbb2sQFD3ohcWisMHgUOjQ0wdBgMDRoGlaymBm4Z3yQw0PFkDHrai/DsMGg2UAGh5MaKzOWJw/wraf+nm8o/xy9/5UAHFu6Eh0axmYVZRzTbIVSjrqzY6gQwWPVLMsJcbBYmWFc1WVVW6am/ey8JmH2ufb4Y81nx0Qw0z3M6x26c9GyEC1NKBbP1cKyXS8Ov/jZOfZhV4M9gPPbLN+nF85/iMg6tAxEaZao5IDKFzRB44PsWEMnDVYXaF0hihFSCEQ20wcFnePzAU2xQpWvUOoRtShwqI6V3KzpUcJhRE1uJ+TNBqZaR9p6dp1LRVhexS7vx2ajblvrw0PI4FDedtf3qeIQQHRSUTlZUyE2TsYtZjELiXeIYw+y+uXPE/7+f7Hv+c/BH7oM0ZSQ5Yg8Jzuwj/2XXkJwFtG6PklBqGvwAZHnqSdDclWxDSFl9YVPvRZabUh3ntNYUiq6sxB1FTKv8W22ERA6vWcM0phOBxGkIqTfSEUg+t7LdI7wKZZu5bDUaSn0jH1QmqB2x0BsGxP6eHBBICApGTBxA8ZNzkaVsVEpylriPCgpEMJTu3j91C6jljmVGUXHtZbN1AVltsyGXGXDjtioc6aNprKpD0SYiWxDJObRMsyxD1OGbFA04xn7AASlacyQ8WA/pRwx9QPGTUHjFT5IaqdYyadk0jINQ5RIFQRBkesBXhlUPSYIgTUDdLVBUZ5AT9eoR/vxUqFtOWP3lULv28+SUoTGIocD5NJyfM/bOWZk1i8KwJms00bIpkImFiIIER2jAGSMB0JItI7Zf5lnqLLENzY62mmFLPI4fqUiJF2ZkxonNG6ONWjjqwwOLxUyzS9afcU8++BSLxuvc2w2xMms03bu8ELp5wi7wAXyANGjx/bo6ckePXrMoy9h6tGjR4t+jrA79A8QPZ5Q2N5hoUePHk8k9DGhR48eLfp4sHNcMA8QXTHRprKCh4JHEnvD+bnX5suYZLdcLIk6fX2dfatoi6fcXAO60ImXAJwwsYwp6GghKRw2aCZ+QCY0e8VxAMzQMnUFXkkyUVOJAUJ6rBxhfMXy9GikD48doTy+xoEHvgTAUrFKrQqmrKKFRcqcIky68qPMRru4RuUL4mMVbEcZqmC7Zm+t/axIYuutzqcXEiFEtJYUkiA4zbb2oSBE2LHbwfz6Fv7/cBrJ9emDCx4BgVMZTSs0lBkWs2VZoxcSKw2NGUDwKJ11Il6ShWGTDbsyqDIMqJ3p4gNEEwUpPCaVLyocmSvJmzGmWkfVU3DRmjQKMgvccIVysJcyW+72qZJDPJJGGkZig8xNO0G1CB5tK1w+RA5GUejtUknR+qko8CwrVKax99+PXloBIfGj1ShqzHKoSoTIu1Kk4BxyMIBiGIXIySK1FSKLpo7lASZDOBeXgXh+WgvHEKJKVKpORt7aMwaXlksWi9LoWdlT2tZDlS8ufqFbLCNkEm2argwqqIdj49rHhCcCAtB4Q+UMlY0lR9aJrutwe1m25SuNV0x9gVCBZlDE8hmhqMmZ+AHr5WChDKpOQzEEUKmvmpKQG4/RgWHWsJxNGakNinqM8tEuthUnWzNgXOxjIpaYuAEbTcG4MlRW4oJACrBuyIFhLHUeqNh4VguLFRnOxBihXI3wjmawiinXsIMVpKvwcohTGcIkG+jBCOEcajiKBx8CZEU0TzAZLhvgpZ6ZmsyJml0ye9BCEqyKDTbbuCHSjEpKpJ/NraRSiCxDNk06SSoKqFM5pQh+wTzloUxcWojgZxautCVUKlpCp330UuNSadRu0MeDneOCeYDo0WN7bN3LY/MyPXr0eKJgu5jQx4MePZ446OcIu8EF+wCxVSOy+UZlENkFMWsn1zEY8wyESwxEtw4xxzCIeel2ahyXtjH/NB25CZ22F6hDRiZqBAEfJBUZMgmeV92D7MUjbMzkV3pIJYeYUOGF4tjwCiZ+wH1Pfg5H9v4Ez7n8SLc/hZiSUVOESWwaU693jEAQitLMBJtyjllQ2AXbtJ0gCqQDohU2tVnbOXGzCD4Kpua+C0GAEDMGUXy9/eP+TlmNbfc5gDvdIfa0ZXqc72hF/HNWy3i0sChctEQVHsXMatmpDHJBM3cBeKlpVE6tBlQUlD6ncYbaa3wAKSL7oIVHSdcxECZUZHaKqceoahzZB1sRhMBnOV7nNPkSlRkxlUudYYMgRIYSwSSMWKVkefwAulxDTdcjO5AP8TrrrFYB3P5LaPJljj/rMoQIDI//L2oh0ONTMRWasnV+GrOX7UUutIG8mNmhBo+YjmEwAqm7z83E32kMzllPdtlLbUDViCxLi4rIQLg5y0WZlvUhMTIusiCywXe20P707Xq/2EAOFv+/iaHcygb6obBdTOjjwYUCgZu7rysJmQlolZo/SshUQMn4tw2S2mXJcCEJqJ2mdBkbtWGj0kxKyaSEsgoL11BmwGhBkcfhkSvHULfN4zY6MbNTWczyE40eNlhhYgds1DnjxjCtI0uiZECpuK8eWFJjhi5atWrf0CRjFK8M1gwozRLa1Tw4vBwpHMvlcZzUZHZC02bjlxwaEM7h82HHjvp8QFAGp7JkrRyQbiaqDlJ1c4XYNC81jg3tfTqxEMpAViDdzHghiqdNbELZWj9LEce6d0jXoH2NkxoV7GwbLTsRUtPfMw3KNhYko5zdop8j7A4X7ANEjx5bobdo69Gjxzz6mNCjR48WfTzYOS64B4jWWnUrGqplD1q0egdgwfo1hJitaF/fbNPYom0YFW1cHZutW6FtRLfYaEoQcEGhhCOXddcsBmCiVhj4aNtqZZay+J5G5Hgkp5oVTlYDbrn1GMEHin96CQBPO/QgSjgyKoyrMK6MLeBdg1eGOmUpnIyNZxas0QAxd4xtBq/7PXfc80xF23BOMGuYt3nwiRA6nYkkbis2jZtbJm1z/vf89h8K83azO0GArub1TMv0uDDQsmJa1EjhOvvfmM2au+6Cj/aBUncaIIjaiYaMJhgqn9F4Re00zqexLcDIgBegiY3pAIyr0K5CNdPY5K21Qhws47IB1gwps5VOo9FewwqHEQ1KWJS3yOAR3qImpxCTjVmhttRRRzGItovjpYs4ri/i//r8JVx5qCHsFeyZ3oe0NWq6AVVJmIyjZSt0zZ0669Z8EFOwZRVfL6edroF5O8dky4pziSUIs30SAvxcZtG31sszdLaLtkHUFWiNlLH1piSxB94irI1NqmxqVOXT9vxc3bNPbIZzCNvEmOLErjUQ28WEPh5cOGibvWZaIGVg4Fs79vi+En7u/4HGK2yIrIX10Up1UiumtWRaCSZloKqhrn2XlY4JeUlyLkbLQK4tA1VShAnGlZHxlIpaDyh1rAqY+iETO2BiM0qrE/MAWnoGmWMpaxiZKStqjZXyGHl5Km7P1jTFSrr3Kio9xAnNmt7LWj1ixYzJzLA7fm3L2Y5KDc4RdLRADVLhzIAgo05TeIf0cQyKTcwsgEx2r+0PcyxB/FCKIRBjgjEgZdRTta9BHMNNjdJTtDIEJI2eVYvI4GMzOd9EjYdrELZJ2os5z1zvuuZ2UhqkaKI2Iuw8JvRzhN3hkdeF9OhxHiGEM/+cbRw5coR/82/+Dc95znPYu3cv+/fv5wUveAEf+tCHzvau9ehxQeJcjgc9evR4fHGuzxHOJVxQDESrZEh/bIkFdf8m16aZBmJTFr3NiIvZ+lVqRLWwzU3rj4xGVEfIlIW36EX9hIivG2J20KEwrkrahIZaDVA4GhQ2aFbNGlNneMELL+Fbn3wfStwLwCCMIURGoc0eCO9izaLUWJV17APMGJJGGrSv0b7uGr9tbh43r0Foswvtenb6vbS/I/sRuizvPMtxJvYhOkGkeu70++HoIs71APCpT32K//gf/yM/+qM/yvOe9zxCCPzBH/wB//Sf/lP+w3/4D/zYj/3Y2d7F8wAB5ZsutTh/rbaMWFsf2zY99EIlR6YMK5IzCiY2fPSx+VxIbihBtjEgoKRDiYCRFk3KfnmHsnVssiQEIPHFCJePaLIRtR4ShEj1vqprPql9rAE2tsI0Y7Lxg6jpBuH+r+HrGpkXMYufF/gsx+nIYBg7RRnHNZdN+Iby/0bftxHZAGcRdQneEeqaUEeNQtcoL8sj+wAx2y+SfcxkHF9TKr6uZ02dgMhAOBuXFTI2g6qq5MjUsiQyZgfn03lSELyPn29qRJUymUBIsUq0WUTbQFPP9q1pkvtTmGkpWoaCuXAvZecitVOc6zGhx6MDIyxeSbScu+fMVSXMVxu4IDrmofGKqlGUVlHWgqoR1M3sulFqTmslogZCa8h0bCBXKIsRDVkzJSAJUmBVxkStMHaRHShdRuUM1kuECOTaozr2omHZbLC3eYDRiXsxJx+ActJuHLWyH5cP8crgpKEWBaXLGemSgZhQ1BtIb6n1cBYLk0ZMNDWymtKsHOj0YEGIrkGctDXS1rOT6D1KSrwykS10LrIO3oEQCGG7uNu+Fv+Ym1NtbgzpHaIukVKhW92FbxvURcZYeou2JbIpY1POVpfROj0JC1Yg58d+mk/sdp7Qx4Od44J6gOjR40wIO+gyebaDx/Of/3z+8R//EWNmk7aXvvSl3HPPPfzqr/5q/wDRo8ejiO1iwtmOBz169Hj8cD7MEc4lXDAPEC0TMJ853wpthmHz7249IiADXXeIzboJmdY9r3+AmNmc11TArK9Exz4E3bm/tPsp0nq0i0/5GlCuxqo8ujQhUTgcikzUKCxXFPdy1VUNp37ytax83SEARq/6l0wG+3BSI72jNiOMnWLn+j4o3xCE7H7H/Z7TOYTIvQQhF5iKeF7T8e+CeZitP/nAp+OevTJbZje6BzazEbvAuT749+zZs+Xr3/RN38Tf/M3fPL47c55CEDNnnXNIymKJEGLWLMWJkDzCvdTRdURlC+tpx2jLEkrlCXP6IQAt4/oyUXfOIdrXCG/jGNMmMhwmx5rorR71DY5aDyjcGO1nmXRjp6imRNdj1NpxOPEgzQNHAVCjBjVaiuuUusvSyarikPsih+2dnPr//C7TE2Mu/87nI/YfStqBkDzXFUJKhElhXwioy8gwlNPZa86CtdFFCRADkptSOu6WCVAKFJEpaPUJWxUQy003ZOdmeowQGQmR5dHRJYRu+x3DYBvwgdDGKi9B+qiDcA4Sextjl4CsZyB6LEIkjZKQs2qCmXOi7yoFXEj6p6CpvSEEQzO/HtE6OIHWgsyktc9dQ3kGRgeKLFBoi5YWQ2T4rcrwrbuiz2l8TBQ5r2IcUZYiDc9MWoxqKGTFqn2Q0foRzH1fxt57T7ruQQ4G8V66HGgGqzQiw6EYyBIpPMvVg+TTE5FJKGb3/db5CNsgThxDFSNcNkA10wXtk6xLhK2jzgg63ZNIrm3deXEOkdi/1r1JuGZxcAkJIsSbf8scJEc2mioeR/CI3MZ+PNA56QlnkbZC1lVcb6vDSusVSQPRspZy3gVT7m6a28eDnaPXQPR4QsGHM/+ciwgh8NGPfpRrrrnmbO9Kjx4XHM63eNCjR4/HDufLHOFd73oXT3va08jznKc+9am8853v3NHn3vve90ZL3U0/11133a734YJhIHr02Al22v36rrvu4tnPfvaO1/vqV7+am2666eHu1hnx7//9v+czn/kM73//+x+T9ffo8UTGTmNCjx49LnycD/Hgd37nd3jta1/LL/zCL/DiF7+Yv/zLv+R1r3sd3nte97rX7Wgdt956K5dddln392g0OsPSW+MCeYCYWYW2X/3m0qNuyTBrMBIboYTOl6srgRKLLUjmbVxnpUfzPz7ZhS02L5kvdXBE21aFTX/rJK4G7atu2cyVBKFwUtOoAo/qGtS128nslH333cmh//2lVPfcEzfgLet6LyN3Ci9j6ZRVOVZlaFd31q2BgAy+K9EKQnVHIUNcv0jLtsuJEEBsX17UHfemZk4zW9i5kqggti6j2uK8b8Z8GdNuEgKB7enJ9u3pdMqnP/3pHa/7yJEjW75+22238R3f8R3bfv6FL3whH/3oR097/UMf+hA/+7M/y6tf/Wp+4Ad+YMf784RGCChXE1qbxtSErLMbbBeTqmuaNN9kMqh2DNdIoVEilfLMLdM2pGqFmIZoRABRPCgIcf1CE5TB6iI2qwOkb3AqI28mZPUGTi+WTilXo9cehPE6bm0NN56il4YIY2bWqXNCxCAUuh5jTj7Awev/CZPP/S9QijBcRoxPxbEiBdKY2OSpjFaOsi1nyAvCeB1RDDsrxhA8wVmE0oTJODaAss3Cfp42OtsyIyGBdJ43ly/5QGjFj84RmgaZ5VCVs0Z1zsVtuS3KJdW8SDKVO7WxRspoHHH6px4S28WEcyjh2OMRIY1R0XRmHjI4lE8Ny0S0b25kNBhoRIYQYXaH99FcRSAwevGalmLmcOxDbPymZWCQOTLlMKnM0cpkziAzKl/QBN3FlEzZrlyynbsYEV8bhg2Gk2Po9QfxR++nPna8s2LWPiDXTiFGqzR6EC1QvelKpTfyfQjvMGKMsmVne6rqaWwaOR0TnEPdfzfi4KWIpp414JQK0ZRRKD1vaKANYq5BXNdM0gvE/IzSz80XlKZrBumYjfXgwfq4XmuRTYWsS0Jr3NDGqGTvjG0WSqdQehaIgu9sXAmpmFxInJ/b122wmznC2ULTNLzhDW/gla98JW95y1sAuP7667n33nt54xvfyI//+I+TZdk2a4HrrruOq6+++hHtywXyANGjxw4Qtu8y2UaHwWCwq5Khw4cPb/n6C17wAu66665tPz8cDk977cMf/jDf933fx4033shv//Zv73hfevTosUNsFxPO9myhR48ejx92MUc4W/j4xz/OsWPHeMUrXrHw+itf+Ure85738LGPfYzrr7/+cdmXC+YBYp5xiBnHh1qQ9AQbrVU9Mr02E03OZ8KFCF22scVmATXwkOxDu0wr2JpJt2RqMbf4dNyoHK9V15TNoTDU5JQ4FC5oSjXi/3foBj4zWeWEjKmP71m9jw07ItMV2td4oTrbVid1bErVZu6ZNYQTBJS3nVVrtHKbsRGz3w4v1BlZiK3s0jazCiK4GfvQMR6bmIfNNm8Pse64vp2xIt16djj4r7nmGj71qU/tat1bYTQa8bSnPW3Xn/vYxz7GjTfeyIte9CL+6I/+CKV2Jwx9okPYesZGtoLBzcI7IQh6ztZw05i1MpsJqFPGUhBwIjWdC3MN4FyJsVW3bECA0nhpZsLCxEy0LEhWreF00W3XS0NWbyDrmUWjMBqzfw9CSESWRbYgXQs+ZTS90thsyLF9T+Vr1WHkMzzXTv+GICS5t4imRihF0G0WMDEpVRkzfHUd2YY8ZgJDYwkpwxhsg9AGX1czRkCpuA6lEPN0vxQIFAEXt8ciSxGsiwyFD2B9PMtCRntZpWZZSZ9YkJTBFDI1pxMiLZcaxnWibj+zlt1lPIBeNPlEgCCQuWgUIEK0eZbBLRgteKmRKomHpYsX71zYlTKQJXZSitA1ngsBKhcX7GJCsmDNVZPu+4JG5YQgaMiwiX3IZDJCEL6bV7RNZm3QaGExtkL6Jhm1gMoz7DiZHgwHoDWuGLGe7WPDj3A+VhU0UjMOQ8bFEvv1feT1OqZci+egmsB0jDt5qjNVkCceiOwCgFQEkyGamrZJGxB/W+JY9TPmj/SZhXG5sIyKxgfJQjeO17ZBZGIuqzKN73FkW2HGQLRxox3fyRTiNHRGC4C1CNUssM47wbkeD+644w4AnvGMZyy8fu211wJw55137ugB4vnPfz5Hjx7l4MGDfNd3fRe/+qu/yr59+3a1LxfMA0SPHtshcH50mfzkJz/Jd37nd/JN3/RN/Of//J93REf26NFj99guJpwL8aBHjx6PD3YzRzhbOskTJ04AsHfv3oXX28n/8ePHz/j5w4cP88Y3vpHnPve5DAYDPvaxj/HWt76V22+/nU984hMURbHjfblgHiDms9gPZeMaEF09f9d6fiaAgDBjMubrnefXJ8Wc5egcW9GyD/M2rvPWsq2Va2sV12Yc2gx8ywi0v60wOBQai3ElXiiCjCyHxbBRF/zD59ZZWo6TyzuOHebJe08wDUOWqbsaTuUFEoeTJjbXStuYt011yVpy87lcaF8vFp/2FxiB4LtU41bfw2lN4YDQ6kk2fVVbMQ1nagRzoTWJ+dznPscNN9zAaDTi9a9/PX/3d3+38P63fMu3nKU9O58QYiOkzirQdTqIzvpXhNRwUSJcgxQClZrKyXStS+FiE6PgkOl3QCBk+n/S+qhg0a5GzWkgIDIEXpnORlAGh7Q1Xhny8hRBKpzKsKkhnPQu2srqHCUljFaQgGyaWOs7HBHyQazzV2ZBO+GlZhJGHBsXjDLLkdWncWjyZfxgGTXZiOvvFk6DQArwAV+VyNFSPC8mR/gQNQhtJjH4aKu6VTOozRlHQCRtUgqpHXMRkmVrsI7gHCHth5CiYyDEvGaiHdtGI1oLWiFTNnOOrZjDZjZzJzjXY0KPRwEBtKujvWjLJno3a5KarmHdLS7wKjaX1FKlxnKgZbz/a+nRSa/QeIVM9rAtA6Glp1A1uapRIjZ3dUFjg8ahkm7KdQynwsX7NLGm3wZN4zVSxvuzzUbI0R70RYfJ8gKTGEKZ5fiLr6AZrHLS7uFEOWRPMcUFgfBxnmGDojRLaFdh5hutuTgO5fISYjiK56AdTyaL40+bqH+YH/shzNgDIaMuQapZw0khZ/rEdnNhrj1vEwDXaZ2Cc11cQIoZ4wgxLrRxQIo4/rVO29YgRGRWW6vWLRjIx6pK4WzpJEM7P9uiUmMnuOGGG7jhhhu6v6+//nqe+cxn8t3f/d3ccsstu+o1dcE8QPTosS3CafONLZc5m/j4xz/eZRBe8pKXnPZ+6Gc7PXo8etguJpwDw+33f//3+cAHPsAnP/lJ7r77bn7kR36E9773vTv+/Gc/+1l++qd/mttvv508z7nxxht529vexv79+x+7ne7R43zELuYIZ0snOc80zK+znTfstgwJ4MYbb2Q0GvGJT3ziifsAcaYGcqcv6wnp8TggFqy7WtYAFi29Wt3D/M88PPIhmYv2fTvnvGDRyCBP00E4dNd0zoQqtZeXqGBRWLSveVpxkmu+I3BKxpvA18b7GakJTTA4oaO6wuuujrIQU7xSXUZ1poEQaN/gkzvSfAYvCDHThaSn+Dbjv+CQ1GYcExOxwEJsZh+692ZN67pzLWS3zfltdfuzqUZ9twhsHxzO9nzhR3/0R/nRH/3Rs7wX5zlCiA2S2mutZR62Qqq37yAEXs7FBSEJSTsUmL0nCEjfoHwcj8rVyJQVFK2zS2pSF6RCetu9L33M3tVZdE5xKXsmpMaqLI7R1DQp7LsY4R0+y7vj8ULg9Ixm1vUE1Uy5NJ9wuPgCqilZdxdjpqfiAiaLGcRiSMgHs0OdjqGcIvMC8ug+w8YaIfiZ65IQUYsgxIxhkDJpSFLmVunUVC6lG20Ts2PCErzvtAz4gG9szDQGj09MRGQVBFKrjomQRncOTkIphDaxVluquD05x4BA0kjILfVTZ8J2MeFsxwOAW265haNHj/KSl7yEW2+9dVef/drXvsaLXvQirrnmGv74j/+YkydP8nM/93O87GUv4/bbb0fK3TG45yvieI0NHEVyGuvuTUKcdq85zREwiG6eMK+3dK3moX1NBJRw5KohlzVa2IXqA48kBBFdkoTr3lPCdgyFR7LRDDq3N6OXELnHSYPJl1AX1108q3XBZHgAJzW11WldjkHSXmhhGfgNXNBoW86OJx8i8gJ90UWE/Rfjsjw2g7M1QZmY1RcSWXrEPGuRYmvLMsRjToyBjDqroKI+IbrQJc2Ii58RwYONTEdILmy+rmfMZJtdbxkIo6N7XIoBZAqMiTHN5LPttfs4H/OV6uZOO8Vu5ghnSyfZah3uuOOOhQeIO++8E4CnP/3pD3tfdstqXFAPED16bIdzqRFMjx49zj7O9Zjw53/+591E/7bbbtvVZ2+++WastXzwgx/sutxfcsklvPCFL+RP//RP+d7v/d5He3d79Divca7Hg+c973kcOHCA973vfbz4xS/uXr/lllvYt28f3/qt37rrdf7Zn/0Z4/GY5z73ubv63AXzAHEm3cPC33P9GjoeIcyy3q0b05m2M9//YR6t28L8/nQOK0n7ED8lIUQ9hUdSi4KB35h9ToAVGolnKkYYUXPw1BdYW76ERuasTO9DeIeuNti/Hp+Ah1f9k+jwlJyUBCG6MqlYl92QoUWD2uTCpFonpHZ/kyajayE/z8ZsZgvmjlW09ZDBn/ZdbK5LFngIi9nCefZhft1bYSfLPMQHty8BOseDR4+HibYuVyw6+ISUKWv1ClZmWBm1Ba1vuwh6QQMk0jUug0e7Cm1LpGsQwS1srx2H+Dbr6XGmwNRjqsFeajOiVgVWxO1Ikp7CjBDDQBYexOsMrzOafDnplaKz2uDUEexgJW4rePSpYyh9EtHU+K/dzf6rnhpZE5132oZmzyGCzhA2xgSVFUizTjA5oi6hqSAvEG1GcN7rfZPjiWgZB6Uhy5IrSrqdaAMi9nUQrX6CpIFoM4/JkSlYR8B17IZSCmk0Isui6xSxzpss67KcbM6a+5htjNvdZUZ9u5hwDsSDR8ISfOADH+BlL3tZ9/AA8G3f9m1cccUVfOADH3jiPkAIER3SEDFTjux6QQDRaQ2NC5HJr72mtvH+LYXEeU8jZ1rIlhDT0lKomkJWaJqOYWivo1mfKd/NIgCakNEEQ+M1pcuYNFlM9muJlgO8ktRqQBgcxAbDxEcm0XqNlpbKGQpVYwrHUE0xoiYEgQ4NxlVkYRq1WUmfZYsl9J4DuNEepsMDcd9diWrKLmOvbInQUTcp2j4Q805KrRsbdCxk0Dk+Kwg6i+xry0D4BiWn0Q2y7SsRfKd/aJnJkPRSLQMhiTFa5gUiz2EwhKwgmGyBKdncU4rg0/vZon5jO5wHcwRjDL/8y7/Ma1/7Wi699FJe/OIX8+EPf5h3v/vd/MZv/MaC6cqb3/xm3vzmN/OFL3yBK6+8Eoil0ddffz3PeMYzOhH12972Np71rGfxwz/8w7valwvmAaJHj+0Q2F4gdQ7MF3r06PE4YbuYcD7Hg8lkwpe//GV+/Md//LT3rr322q7koUePHhHnyxzhNa95DUIIfv3Xf52bb76ZK664gt/8zd/kta997cJy3nuccwsPRddeey1/+Id/yD333ENVVVx++eW85jWv4Q1veAN5W8q6Q/QPED2eUNhWINWjR48nFHYSE86WZeMjwcmTJwkhnGb3CFFo+bnPfe4s7FWPHuc2zpc5wk033bRtjHnTm97Em970poXX3vGOdzxq+3DBPEBsVc6yZUOyzeVLm362EkcLwoKAWpJoNjGzbhN4PGqhrKcrVwJ8SA3kgozyYZGoz0Rl1iqKIof1WmwmJyUBSelzjtZ7CKuS1eooLtNU+QrGTllfupiD408CMGjWCUJijcG4ilFznLrIcEGx4o9TqlFsGEfASdNRfV6orkHWVudUEBaE01v93xOtYmVwSVAdTrNnXVzvYsO9IGLpVVuWtFmo/VD7tlsLV8K532Wyx6MEIZn5H8QmZKET2s5df8k21esMq3IaldOISAG7JGiMJQom/XadcFq7KJ5WtozlSi7S/UHISJ0Hn2wiI9XvTIFVOb7QTM0yTpquqRSQBJfJylVp6uFeTBmbzTV6gJWGqVrGoTgUPPn6A3F7yhCyIpZIrexHPvgAYrw2s1W0DdQl4cBlNNmILJUxOFPglw2yqcBkCNtAMUyN5RxC6SikhihgbOs0fIjlC1kWxYzadCUF7bmXSkM1RXhPaJr0NUSRtHAuZvpSsXHwIVWYSYQxyKJADkeQJ6F4nifh9LyYc24ghzATcMrFUqttsV1MSPHgbFk2PhKcye7xCenmJgRexLEWkHGcCdXNEwKzEqZG5TTeUPmMyhkqq6msxHmBFLGpnCSgVUBJT54a0BnpyGVNRoUKtjMscUIv2Lq3ZcxVSOWSXtN4Re010yaWS0kZkDLE94THovFestaMWK/i58a1QonAKHfsH2ywrDcowqQzUtlgQDCSpeo4zhToKpZK18O9WDNkbXgRE5aSrWzNwG2gvI2mEMERtEG4OQtnmaxdvYtjsu2kpzReZwST4U2O0wVOZd14FN6hpcEAyrtotKBrhKxnt9wwM1wQczausiiizexoCV+M8PmQoLNZOeo85uOCkFhdnGZBf0b0c4Rd4YJ5gOjRYzucL/Rkjx49Hh/stITpbFk2PhLs3bsXIcSWjaVOnDjxsOwee/S4kNHPEXaHC+oBYjPjMG/B2r22mX2YF1ATmYKWbYDF7Pc8OyE2pdjn2Ye4HdGtr804tBZwqs1EpL/b/wNYlZG5EicNDshFTaMMX964mKVsL/vFSYQOaFuyLvawvO+ybpulHpGFEhkceXmKr7vnQzT7L2Ft9fK4v0kg7lBkYS5bKiQiuAXx9Obj2CxcnmcJPLJjVFq7y5AE1TFDkLIKm0Zmu20vZMoEpd+nCdEfGrsVUodz3WKhxyNH21yovUaTaDrIRatPEQJeapzOY0M3laVxF8OiCyqOW2IjSCUchNnYF3ikTw2p0g9ASi522bcgJF5qrC4o9QiAUgw7hq9tJgVEq2bfxHUJSZAqZgO9I6gcTYNDcXR4JctZFFGPxg9EFkII1pcvYf/agxACfrCErKZxHE6nZJ/7NNmBi2j2XgxAU6xQrD8AUuKLEWq81tkfdgLHNsMYPKK1jm2XSZaqnaDRxKxokJqgdddDSrbnJQS8j1bREqCOkUHgkUoh8wxZ5JF9WF6BZDnrs2LGpni/2Biw+84lQT2829lOYsLZsmx8JBgOhzzpSU/ijjvuOO29O++8kxe+8IWPy36cCwgIrMw6sw4vVHevmWckffp/EzLqYKidpnKK2kkaJ3HJ9VkIgZJggifXQGIg2qoCFSJLKUIAGUXZ8/eqJmicV0xsHDO10zROYr3AOoEQoEkN66TtKhWECPgws4+VgrgfMjalmxdlT33BqWrE3uxoZEG0IRftPCPHZhljlpm4OM6MzEDBMKx3zTSDVJFZbe/drbFCO09I47Id/7FxpukaZLYW1RAba8aFPaodx86leoQS7z3CB4QU0cYZkHmGKAawtIJb3ktTrGDNIArghYhVDyHE3yzaxnuhZtvczbXSzxF2jCeGCXSPHgk+nPmnR48eTyxcyPHgxhtv5EMf+hCnTp3qXvurv/orvvKVr3DjjTeexT3r0ePcRD9H2DkuGAaiq2MMmzPo2z8jtXWJ85ali+s4vSkccFrGfsHydFO2ISDQqXFMm3GMaohYV+1Dqr2UOU5ojCsJakAuS7yWGNVgffy6KjHgq/J/4+RaznQpZgWX1QaCQO4nUVNRrCD2XoRLWc8QBE5qZPDkfjrL8odFdqA9pvb3mXQGC8wNEiEUM74hPZ12LARz78w+326jZR/aDNDmhj2b2YuHhbA9PdnzkxcCBF7nM6vWlnnYQjcTZLJxnWO+usZPQiKD71gIH2TM8rUMRmoIFzP0cxnxILv/t+yHVQWNypmKEZXPIIARFiMaDMlW1TcU9TqmmaJsuTD+smoNERxBKDKd44Wa6ZiUoS5WOJpdxoYdkV+6wWD9/rgv01jzzGAAVQnedfuvbIUtlshO3p8y++lYnIu1yMlSEaVSw7c03tWcXar3KVakcZt0EN4UiKxGpvUBSB/iNmQ0wJYQm0oB0hhkliGLAoYjGIxwg6VuXfO11MJZhLeLTS9T06rNjSu3xXYx4RyIB3feeWfnmDSdTvnKV77CH//xHwNRK3Hw4EFga8vGn/u5n+OWW27hxhtv5Bd+4Rc4deoUP//zP89znvMcvud7vufsHNDZgIi6hpZ5iGP6dCtwH+J1bIPubNeBuLQI+G6eESeTm+cbbUWBTIz+rAHrrNqhSbawlTOslZGBKJuorwDIdGCUWQrdsGRKluQGEt/pKRuju8Z1jVdkypKrJlnHWoKQ1D7jZDliKatwQpOFKXZOC6BcTaPybl7jgmAgXLR9tdPIetbTdFI8lJO5k+SSDiLFQqkJShPkok4pIHBiNsUMOmpFZUjMQ0hnVwpk0jMI1cRGksmKVAwGMFrGj1aoh3sp81VqPejW2zK2rb5z4btM+pZdzR36OcKusCsG4k/+5E/4gR/4Aa666ioGgwFPecpT+Imf+AkefPDBheWm0yk/8zM/w+HDhxkMBnzLt3zLIxaE9ejxSBEA58IZf/rYsHP08aDH+Y7tYsK5EA/+03/6T3z/938/3//938/x48f56Ec/2v09X560lWXjpZdeykc+8hGyLON7v/d7ec1rXsP111/Pf/tv/+0x6ULdx4Qe5zP6OcLusCsG4uabb+aSSy7hzW9+M1dccQV33XUXb3rTm7jtttv4zGc+0wm/XvWqV3Hbbbdx88038+QnP5nf+q3f4qUvfSm333473/iN3/iYHEibCdiOcZhv3tI2bZu/IubrCFvM+zTBnPvSJvbBz2U0um2IgMbF7GViH7o6SRHrCWXwtJv0QWKFwSqDEAEXNEo4AoKBLnEoGm8oreYjf11x4wsjA5HLmkzETGatBzipWS8OUIkBKliECF0GJCBQIW7bC4Xys4ZRMWOy9TkU82xC+v9m3UdAdE5McajNsrGbHRM616XTNClz25id4EcFT0TzkccK53Q8UDq6H5Fq8ud0D90yLftFzFLJ4GPdcssQSocnZitbN6a2gZxMzeTEpjr8+HvmDuKljs3pVEYjY8bPJbbRCEsWSjJXApA1Y/LJcaStEE0dtQVSx1phKciqdYLUaDuN2ogmfs7rjEYV1MHwwGTEZaMRuc6QTRmzh85BVsBoBbu8L7qqALrZiNuRCjFejw3fmio2eqtjLAnOIaxDGN01oWqbRnXN5WyDkMnpSurZ8WtDcA2idVOyTZd5xCem06SYmjQQIstA69RAL3qSO13gE7MhXYOUDcLrxcHcxuJ5LcpOr5VzPCZsZcW4m+We+cxn8j/+x/949HdsC5yrMaHVQDh0d5/eqrKgZSDm5whaeoIWSBnwXmB91EKI5MYkCFEfBSgWG6l297gQfxqvsV5T2oxpoymbuL1pJfEBchMYZpaVfMpIl6xwkmF5sotlXiqUcQyTa2NAoLHkfoK2DUGIWMWQ7qGFqiCA9BYdZun14fGvEvZfyT7VkJk9SDzDZo1iegLpG4SzyGoS9Q/ewXQcD6hlGHyI7mgk9k+bxEJEtrdlYVptQqtxdNJgzQBRNIlJdFH3IGSMJy42lRRJWyGKIeRFdLDTBbUeUIkBNuioJxUOrTRK2oVYPK/XlOHCigfnEnb1APHBD36wo0sh0qdPecpTePGLX8yf/Mmf8MpXvpLPfOYzvP/97+fd7343r3rVq7rlrr32Wn7pl36JD37wg4/uEfTosUOEEPDbRIcnpL3hw0QfD3qc79guJvTxYHfoY0KP8xn9HGF32NUDxHxgaPHN3/zNANxzzz1ADCDGGF7+8pfPNqI1P/iDP8iv/dqvUVXVrrvd7RQ70TvAolahZSE6x59NrkxbaR8WtrlFXwmYuS91bINcdGnQNCnrufh07JJHk8V0rkkACofCYdEM5JQDA8GP31BxaPJlAJpmwNQsx3UIjVOaDb+MwqFlrBFUwZ7miax89KpeOObgYz1x4hDO5HTU9sjY2vEq9bsIc3/vAu33KfBbrh9Od8Padp3nSZOY8wHnbDwQEISK2XA4nX3oGLFUVx8VDtH9KMyYQe+jLic6M6lY3xza+ubZhRSZOTFz/EiaCq9Mxz7UqqAOOSEIClkhhadgSt5MyJuoU8jXH0BNN6JWAcBk0fcckDrut2hiXXKQqsu0N1Jh7JQ9+QkuKb7C8r2fm2mPvIvMQgiE4TKyqWa1zdMx1HW0cvEBqjKyD7YhNDNWMoQGpIiuTIAwzDL+7TmwTez/AHiTLw60NmupDcI0BKfjclIgIGYfpYA556z5+nHR9tPoXLQUyE0atI4ZjT5zu0EfEx49nLMxATomcXPPp3Y+sFXlgZYesGjhcSHqoBoncYlRUDJglO80CbHCYKaharPuHoUNkX2ovaa0akH3IGUgU7A6sOwppqyaDVbccZY27kfVk66vjNMF2pYMVdQIyODQSTPlVZ76x1yMCIGBqSlE2VUYmGaKrGNskceOsHziAcLyKiumiGzA+BRhMEqOZiYu6yzYphv7rZ5JeBf7ujhH0K3WK2X9g0d4hxQW1cZYObtPe6EIyuCzHOUayKIjpEzuby17CUCWekkI0cWB9p7fOmY6dKxQmPv6Ws2JEAGxS+VzHw92jkdcBPmRj3wEoPPIvuOOO7jqqqtO87G+9tprqeuaz3/+8490kz16PGyEEM740+ORoY8HPc439PHgsUUfE3qcT+jnCDvHI3JhOnHiBD/1Uz/FM5/5TP7ZP/tn3Wt79+49bdm2ac1WTW3m8a53vYvf/d3f3dH2d9KQp0ePFtEQZjtG6XHamQsQfTzocb5hu5jQx4NHhj4m9Dif0M8RdoeH/QBRliX//J//c06cOMF//a//FZUEdSGEmd3fHHb65HbkyBE+/elPP6x9EpyZe9pc4tRSl22TlvTiaTZdC3aim8pptmpMF18XC9aPMlFvbflSKzDqyqkS1Rft2kInym5fa/dBY1FYDoT7qRl0QsrKLCGDw6UyimirGqh8RhM0q/IUxlZ4oaKdXWrzpILt7C1FEoY+VOv3eQvMrmmckLE0RLQlBbEpXaSIFz/XlkbN1jcrI+sEqnjCQ5REPRrofZwfG5xT8SCksd2VwNBd2/OCfu8hqPnSl9CZCwBdwykZHFKaLi6047YtIWqtWueF016Z1MhIxTKmYLBBE4JAC0smKjI7JW82KE7cG9c7WYt2iU0DeRFLAbRBKIWobVx/8AhrU7O8mbBYCcmoPomThqBMFCc21azUqCoR41NRlGhjyQDTCaGcRuEyxJIEKQhViTCaUNcE6xBanW6CLmPJAkql/Qrg435J18Rz35Y9tNtL513I2MxLGtMqUeNbbSM4axF1iZyzhGwtbGGu3FS0hg1z5ZdbXGvboY8Jjw3OqZhAvI/LufoUKWalbiGIroHkwme6MqZ433dBIIXC+WjCLtP7880gId7/vTS0jVtt0DRBY4OkcorGSRo3OwdFFhhljj3FlBU9Zk9zlKWN+zCnHojlOK0tdfIj0KmUUfoGaWukrXHGEvKlzgq9vdNWaoiRFcaPkVWyY3WW6gufx9cWvbIULZSXlxDOxdiTpzEtFbgSoWZjMdQ1gVS2uIUpBcSYlE46AD5EEbX0SVjdmrBIFQ0Y2vVLMYsrEEuZgkfaGt1MKaRBmIBURWd9L8WsBLubf6US8s3l2TtBHw92jof1ANE0Dd/3fd/H3/7t3/Lf//t/5+lPf3r33r59+7j77rtP+8yJEye698+Ew4cP79iF4a677mI6ne5iz3s80dF3mXz00ceDHucz+pjw6KOPCT3OV/TxYOfY9QOEc44f+qEf4i/+4i/44Ac/yLd+67cuvH/ttdfyp3/6p0wmk4UaxzvvvJMsy7j66qvPuP6bbrqJm266aUf78uxnP7vLRGwnpm2fTDc3e9uyQdxDrCt+Vm7LdMxvZ35dCtexDypE27HW3qxrCiU1hMggtI3mTKhQwVLJ2HK+JucEe/nAx5a55OKvA+C5Vx1lRa51nwtIKpex0RTkqmEpU5R6ROZKrDTodAhSOLzQcX+FQvooEPVykYUI4vSmOxCzsVaauUZ0vns92lxusrrc4jwRfJct6XiIzZavWzQI3Mn3sOlDfZOYRxnnbDywNWreZtm72ZcvRMx8qSjM80TL162aDs2sW2fZyk7M117XUnXZcKCzMg1C4YReMFNAEBkIV1LU6xRr9yOn63E9aydj1r61PYVOOOyVQbpogypshQgB11odEnAqYz3fzxfHl3HZpQc5fOofMBvHo9e/tVEMqQ2+GCGaaNEq8jKyhnWN2LM3ZvvWTiKHI4Jt8EDwVTpGsclWWcQsYSt27M5NIHgfNY3eLWYTSzdjJTYPxPa7cg7quE2ZGB5hK6Qpoji7zXK257w9Tw+niRxsHxP6eLBrnKsxwbjIwM8avc2aPTqh4+/EzLsgOyOUFkIECAIlAkGGyGymxnHtfX7Gjs0ao7qQrGOTCNt3wunYoA5gaBzLec2ymbDij7O0cR967SiM1xGDEUF5gs7wKsPrrMv0e2/QaXtIRZWvdEYwNkgsOtqvSI01A9RoBQB14lgcmzLNi4ocsbInNofLisi+Lq0irI3j0CSWcrweP+dcaj45x+Ik4wiYxUjZWsTL2EZWhJnNsmgtlzeP280GDc4hqykmeKRv0K4k04OuMWB7rueF8LtlHWYH0c8RdoNdiai99/zIj/wI/+W//Bfe//7385KXvOS0ZW688UaapuHWW2/tXrPW8v73v59v//Zvf8wcmHr02A4B8D6c8aePDTtHHw96nO/YLib08WB36GNCj/MZ/Rxhd9gVA/Gv/tW/4n3vex8/+ZM/yUUXXcRf//Vfd+9ddtllXHbZZVx33XW8/OUv5yd/8idpmoarrrqKd77znXzpS1/ife9736N+AC3mM4ddFmD+KVTEJ8vNdqvzy7RNZOZtSbsMA22GYa5ZCVtn5VvItKwUPtqwCosIszrrkGzeWg1C3AfVZUEEAU2DChYnNDo0WGG6fbnmas03XfQlABwa7WtKOUIR6/4KVbHRFLigopVssEz0Miq4TudgZcwsKB9rFp3UC3Wi3X6252sTM+A5PWsbmNWOb2Z4FrOErU1rbDrXMTIP+f3trFngQyIE/DYCqV4htXOcu/EgxGZs7Xfp5rJcKSPudYZQUbMTZNQqbNb+BCG6sTnflEgGf1pDurhVsfB3izZ+ZKJGCkfmSgbVKfKNY4hq0jVpCraJtcZKQZYTspyQFbhskKxLVdy2lXhtZg3TQrSgzdyUK0b3c9m9fxP1EcHjswEyr6NFqlS4bAD5CACzcTLqHg4cIhSjqJlIWUgxHSOVQkiJbxpEq3noDio1ilNmwSY3CLEwhoR3MxtXpQjBE3z6ca6zcBVSRgtZKaEWiKZGJDtbkReIvELkg7g9k8XIqvRC7NzOcntLbBcT+niwK5yrMUEQMK6K7IN3iJZRFCLqBhVYYbox7BMDYYPs7EBbDYQPcp7MjNoKMbvXA11G3Ae1aY4Rf2sZEMYnfQUMTcOKGbPEGsPyBGqyhkhxwWcFIStoBnsoi1VqVXSxSgZHlpVoW+JURqPyeK/Hs2LGjPxat5xVBX7lcNzeRTX5cBRZhCzH7jmEmJxChIDPBzSDPQSp0M0UV4xQZdwXSdIqNVXSPbVxNY5DLyOTs1XztoVqhDaWeN8qlyNL6gDpZu/bBqRC1CWqMshqisrH6HyEyUZYVWBVhpWmm8s8IvRzhF1hVzOxD33oQwC84x3v4HnPe97Cz+/93u91y73nPe/hVa96Fa9//et52ctexle/+lVuu+22x6zrbI8eO0EAfGoU81A/fWjYOfp40ON8x3YxoY8Hu0MfE3qcz+jnCLvDrhiIL3/5yztabjAY8Pa3v523v/3tD2efHhY6hmChTndrhmCzY1L7Wvf/sLU24qG2u7kpXVoh0DaWCUjcQuO4eQZkvvayfV1jEczqrJ3UaN8gRMCEmsvcA+y96ATh3/5rAA7/xL9mMjpEJYfp8w1Dv8ZSsYaTmmG9hggeZzRO6i6D6kS8BJyKDEZ0f1o8ru68zDsobXFeN7eSJ7hUV754vmYL+RlbFETXvM5vOhfzmeGHzT60n++zB48azul40NQLtbY4F7NkShHIQaXrTsZGcVaa2PBJqJkeaRMj0TqnxfrpWL87fz1vZuekj3onHxRaxCZ12tXkdkJWrSGbKuoRmsj+CaXA5DAYEUyGG67gzABnitmxKENQlqBnY1jaGuMd+04eYU9WsHHbh1i57pmwZz92eR8MlpDVFOoSs3ZsljUcr8eGcXsPEJSOeov2/BUDxGQDYTJEOSV439VLt2xOaHUI6XNByrju5LIk0jKi3Z7WCJOBc/GsOYf3tvuMkHMxRano0gSIukbYJq6nGCS3KLUQoR+W/qH93vqY8KjhnI0JIaBdhfIN0lmEtx37iA7YOfdCABcUtdc0TmJ90jYhOgZBCpAi3dcXKhQ2MZMtU0FkKZRIrk0y1i8YFa/bkZkylGOKZoypxzP90KDADVew2YjJYB9jtUoTTLefSji0GZHpEu1rvFBoX1PIkuXmePz/+BjVYC+NHrCRR/vc8aX7yO0kNs/0Lm3TIqsp9Wg/02Jv1DHkKyjfYEzUX+qsQI9PRi2EtTEWzN/3E5MbwulOji1T6ZNLnNdZdJmrSwie0NQzjdRmCIkwGmFyVDFAjGrEwCLyOMdwbdPQuflBq03ZXCGxHfp4sHM8oj4QPXqcb/C9w0KPHj3m0MeEHj16tOjjwc5xQT1AtFmozgGpbYvOYsYf6JwKtlPrz2cXtsKZnJza1yW+c1Rq6/zbz7aag1YvIURAYVHedo4RVmZo3+CF6l5vVM6aX2HyC/8nALn6Co0qyP2EWhaMmlMsrX2t6xPh8hFVsYrUDofusgEyeBwqesRIiQ4NCttlFaJ/vug82LeCR6JwHbPRsixeqNhnYq4PRLfOtl6aWe10qiKNzMs223xY6B0WnhgIAeGa2C8BolNIm+UGQsr6tVodJzWNKqJbydzYaJeBOIaNiO5FrVOZ2JR967LgPrkCiUDejKNveWIQtK8x1QayqeJ+2QayOdFoXuDzQXRCUYYg9cythKRH0joyLOliVk2Nz3KErXGjvQy+5wfh/i/jswLZVASTwXQDf+wB/HiCXd+Ix5Fn6OUlZAh4bbp+FpGJWEIOllHrJxAq9qcQ83XLaZ9Ccl1pNRfB5ASpUNUkbhdmsUQbyAuEtQhZx2NpSnxjI8MBXZG40AqZx8/LpkERGRphsqifEFGT0f7enAnd+bXSuzA9ESCIOj/VlNEZKM0NHNnMjQmJSzrIxitKq6ltZCBcurTa+71WgVzPGAWdekp0PZtCqvmPHZkIQmCkJWiBkoqQ3JyMiuzjSE7I/RRtS/COYDLCaAW0oSlWmOarTNUSVcixQXV6TSXi7ELJGOsKO8bYKW5gyJsNKrOEVxnK1VhddHOSDVaYmhEZFcvlMfIH78FnsfeMUxmlHqGCpREZEk+hojNcZgZkJsdIhZhE97jW4S72dwjRwVG0TlQzRkB2faPmnBrzBmWb1Pulxjclvp4xEcEHQvq/NBo5GCBHo8gzSIXXMXZ6oaLT1TYOm9uinyPsChfUA0SPHmdCIODcmScZfYVjjx5PHGwXE/p40KPHEwf9HGF36B8gejyh0DeJ6dGjxzz6mNCjR48WfTzYOS6IBwjBYvlS+/uhSpTmrVy3FAPPPWE+lIVrC4nr/hf/Pb2lvcIShEB61zU9EYnO29wgrS0Bam1QY9lSg042q15InDSM1SonJkscGESbNoehomAplAzcBtpVSNcgTx6FrKAZrHa2scpbrIilBxaDwKcyJB/LkHxAz4m9u3OQ9rk7NjETj9tgunPR7ntom/bMnSMRXEftikDkC+eE1h4Q4nT6MZacPTIBdTyE7SzaHtkmepwbECHMSlp8W94iY/emrlQnNpDzIlonWwwuqE6gKAj4IKMRQrpAlbeI4JDpd7utMHfNSlejbIlXGUFqtC0Xyvh0EiwK72IjtrYZm1SxFEibTqAsvO2aTQlbI22FrKto/9py7VIhSYLl4NDrDwIQTIaabsQyqbWTNEcfZO2L92DLGEtWnnQxajCApo7nRyqCMjgdG0kZ7/CjlWjdaJtFgaP3saxJtfsaG1m1+9SM9iJdjXAWmadmYVLHaGttFEVbFwXX3uOmFd45gk3nVCv0IJYnGCEIRYNIYzcoRVAap7JZSUQyYCBZZO8Y28WEPh5cIAhRPB1cLL8LnlQF1N0XPbIrDbJe0jhJ7SSNE1jX2rqDkqBVQIqAlhYjG7SI111r1d6iLUmWwaGEI1M1Xs3u++3n8jCNBg3eEnSGk4owSLFJZTQyx6NSKeXMrEULSxEmSOcommT7KhS5nSBtTc4GXhl0tYHVBcNwCoBROIl2JabawHzlLuqvfpXsiithaQVTj2EAjcjQoWGDFbxOpeBteecKmOARdYWwDdI1BKtQpsGqHC9VKtGOsc2lZrUiRDv51uY2IzWKczY2kJSS0FjcJHYP902Dr+M5kplGNxYNyGIIIdpwtyYYNpgFK36Yn5/t+DLp5wi7wAXxANGjx04QLdq2X6ZHjx5PDGwXE/p40KPHEwf9HGF3uKAeIE7LWs9ny8OZBdObWYe2IcwCAzHXYC6+5zubsJDea59824y5plncp3aNXXbedywARAbDSR23I8D4Cu3qyCgER62HBCFZ8id57sm/Rn7xfgCmT3om9dKTcNJEezZXY/Mlwv5LugxhbYY4oTG+6oTOlRzSkKFoRZ5Nlx2QyWa1bfLmpJlZOAo1Ez8H1e2/J4pHPWrBkhXoGujNfSkxEzSX8RXi9OEZhCCERUvehyWQ4vyjJ2+//Xae//znE0KgaRq0vqCG7GODtsFRmwnsmhdFMWMrFJ5vAPdQ7JYUHi0smiaNxQrlaqSL9ofz6+kauyWBsUqM42xlKr7nmpm5g8k6IbIIATdYiqvQWcyqJ8YO71DVBFlPoZxAOZ3ZsQ6GUdRdlegvfS42ohstz0Tk4w38xjq+qhFSYoYxs++qGmE0lBOU0vh8SDAOLzVe50hbI8txFG0vrcD6ybjPVQVNjSiGCFNCViBdg9cZ3uRYM0TZqmMzlI1GDjIxJSIEhLOIpkGU6TvwHjup8NYhpEBqhVTJbMK1InhB0AZvCpwuOgZCBhcZGOcR4symGFteLudZTOjxMBCIrN+8QjbZuLYs5DwD0TaL2yyolSJgVLRfzZQlk5ZMNN19XnaCbJEszMPM+jnds+ZNVFpzBZnGeZAKmyxTncqo0v2+tTjPRI2m6e7fg2od04xjg1pbxvuxNGhbohIT6nQxs2ptBcyujs3hvnAn47u/hsozqi9+kewbv4ns5BH26Jy14UVkrmRZBSbEuDQAvDR4aXDDVXQ4CU2NnKzDEJwZoFVNLQfdPAJio9tAnNNI4bAyi2JrSIYXqXHkJLEoydrajqe4xEAolyGN6UTVCIHXsXleHXIab/Bpe4oYt7eb9215qfTxYMfoZyM9njAIYQcCqXPIA7ppGm666SYuuugi7rvvvrO9Oz16XHDYLiacS/GgR48ejy3OtznC2cYF+wCxE3vWrf5us+ByjhHYSvsQtxGzFDJZuM1nz4UIyGDnLGVDZ9kKs0z9zE5WpdcVhFhL2Vq2WpUxmB6P2YRRxiRbYaU8Bt5xxzU/3G2zrDIO5Q+iZY3VA7zUOJMydUhqNUAFi3HVLAsiSqQ0+KC6Y1aJhTjtHM3Z4nYak7T/AnAhXk4yuPiaWGzu11q6CeE7zcPm5luzcyu69zZb7s6a3EnELmscz6fBf/PNNxNC4F/8i3/Br/zKr5zt3Tm/sCnT2P0WSQfRLtbaGQuHDxIl3MxSmZCMXRuMK8lsiWmmUZfQahiEnDEZbUYNOhZChKbLegYhEM7FGn4h8fkAYW1ndxrSOpwuOmtSmexJO/bBJavE9TVCytIpgKyAqkQORzRXPR3ZlDSDPWSTE8iNNQgBNRowOnxg8TQ5B9MpYWMDORzB8iqyHOOGKzHrX5XxOL2HYpiObxI/5yzUZZf1D6bAS4N0cb+abLQQh9vzI4OP2gjv8HWNKKvTvj4h55kbGVkVbQg6w6sMmxiIaKUbLbuD32W9c7tf51FM6PHw0N3L5psgpp+2Xn+hukAEpAwoCRB/t/athXYMTUOhawaqJBNVp1GEyDBE1jxm3EUIqBCv94VGc/NjI8URlzLz7XuVHlKHPGofqJHBYXzFoDwJgKnWo4WqrSJbmPRGdrAS7WB1FpnBMED6Bq8i+yirDeSRrxCUYnDFpfjxGDeZ4r/wOdTlT2Jw7Mvo1QnWDBl6hxrGuKFdTVbFprTCW7zOkC3baxtUM+2aczY6pxHJZjVZrPogceQoXKerkMEhnEXXJbIo8OM5y+j571AIhBQxNigV2U5VUIuCymc03sx9Bw4hA0oo2FQFsh36eLBzPEJVao8e5xGSQOpMP+dKgeMXvvAF3vKWt/Dbv/3bGGO2/0CPHj12j21iwrkSD3r06PE44DyaI5wLuGAZiBada0CbgNjETGzWOLQN31r1/gKrEMJpn+9eT/WO8+vdvL0QRNQbCAthlrGfX35BV4GgFgUZJc4U1PkKpRnhg2Kc7eEfD70M09ZCqpKj9RIH8ujytF7smzWaCjZpDQS5ndA12SOyDQBOhNly6enfo7pay3knpvj3rNFbQODQHTPQ6h8IHi8kQqhuHYGQ3KcCQrTdeaIT0+OB86W+8V/+y3/J933f9/Ft3/ZtfPjDHz7bu3N+Q0bXpQXtQ9uEjKR5Ch4tmgUdkwy+Yx60K2MTKlulrPem60jMaXSk6pgD4WJ2Lbo0tYtGdsGbglAs6ooAvDIgBNLGZnHS1jGbKASYLDoiAXKQ3I3ygpAViJU9rF/2DEYn7wHb0KyO0NUG0mTIiy8hO2BhMsaeOhm311hCY6nuuQdhDGo0QdkGkWVo76LWQqUY5dLf7eeqklDXyNCyjAGZD3BmgNdRm2BTtrM9z8rVHRukvAPnUHVNqOrOfSk2lQtILZFZ3HbMPKbvUEqC1PG7bLVkyY2Fh2Azt8P5EhN6PDIIQrpGfGQekvahbSi5uV5eiUCmHd4LhACjPEY5hol5yEVFFkq0mzV1dLKt9ZdR4RjEgp5SeodM99x59t1LjVUZVdIpti6JPihs0DFjLwqGbDAoT8aGc4BXWWyMNw/vsbrAuIaqWEV4h5cG4S1OR7Yz847mqqcjvEPffzehqpFFwI0nlH/91+QH95Eduohs30G8zliZY1hkUyZ2NcWmxD7I1CA2OlzFZred22PICAiaoGmcQYo4HwlKILKA8C66RtomxoTErobgESo18MwMwhjQOjrGJfao1a64BX2qXKha2A36eLBzXPAPED16tIgOC2cODu27d911F89+9rN3vO5Xv/rV3HTTTQ9/5+Zwyy238MlPfpJ/+Id/eFTW16NHj62xXUzopxI9ejxxsJs5Qo8L7AGi7VnQ1s8vZP+Rpz2NzjMPrSOSxHUMAND9ntXvn+7EtNU6N//thSQEicSlngnb6yqc0MjgqMQAP7iIMgxwxIybEhYjHdfe/98BcMMVqpXnsNocY2qWqUOOCwojGoKMjkqFHSO9w6qsY2a0b1JviLbPhEL7Gu1qaj3o2BWg60vRHlf8Wya3Jdl9B7NjUad9Jq4onZsQWZuOiXgIRD2JW3B0Eonr2BVCwG8jkGozy9PplE9/+tM7XvWRI0e2fP22227jO77jO7b9/Atf+EI++tGPcvz4cX7mZ36GX/mVX+HQoUM73n6PTUiMAzBjC1IPiKBMdBqSurs2lW+QXaY8jgXjKkwzQdsSWU+Rdcy8BSFiPb4QBK9AZwuaHeGbmfMTRCYizP6Pd4RiFN2XgqfJl4E49rzUMVMPoAwIGZ2M9ATVaiAGI+Shw4Rh/JwtRtGHXcV4wefvQC4tUwyW0WsPEobLBJMh6jIqh5LTiWssbjzGjqcEP8E0DaGxqOWlWINcTqLuIS1PckVyG+vpOD1+MkbqxJhUU5Qp8DqLGUXpKM0SmZ0ufjXeIQqHdMmtysV+EDLT0XWlsZF1aDO0rR7CuVhnbUt8YkaiVst3jOqusV1M6OuhLxh4oWJPl/ZelbLYTmocGhdUl8UWBLT0cYKkQMnoujRUFUM5pnBjMlvO2IRW/xQyghKd69Dp8wEfa/6TXme+P4wXispEVrEOOWM3xHrJSJdsuBEDXdKIjPuGX0cmom5opXoQbadoqRDWYoslmnyZbHKCZrCKlRlSxP4SElA2xpbp6mEABqfifcuurdGsTzDLQ/RowKn/9RVGGxPycorcdwDTjgNvCfkw9qGRafpYl3FsNrGngwKMMuSqIJhWHyYpQ4HzisYrIH4XSJDaI/PIQBgX40I7MRXGRG1GYiSEUog09qVr0LYkMxWNbBmbFMPlTG+yK8fGXcwRelxgDxA9emwHv0N6cjAYcM011+x4vYcPH97y9Re84AXcdddd235+OIw3jte//vVcdNFF/MAP/AAnf3M8LAAAKxdJREFUT54EoCwjXX3q1CmKomA0Gu14v3r06HFm7DQm9OjR48JHHw92jv4BoscTBmEHXSbb5MI111zDpz71qUe8zdFoxNOe9rQdL3/nnXfy93//9+zfv/+09w4cOMB3fdd38Wd/9mePeL969OixfUzok409ejxxsJs5Qo8L6AEiCNkJhWevzazZugZuc3Ztnc1oKl9q29BL7zrxcFsKJTaXP4mw6BTZWjUyK/dZWB6xIJB2nG6TOv/5xhtyWZL5kiAkx/xBaqfJlGWvOoFHMlITZBnLCx48/AwudV9B25KJvrg7JkPNqDrZnR8vFcaV3SiozRDlbfeeIOCExmuVBNWzZjdt45d4vNHSVeLxpMZzcyVFs3IySZhrrteWjCDpBFennauQROzt6qTpbGE3W+3tFue6Rds73vGOjnlo8d73vpff//3f5y/+4i+46KKLzs6OnWcISs1MDdqxLBVB61jCpAxOZViVdddk2/DJ2FgekNUbqHqMKsfI6XqyUPUIk8frSGmEdODdggnAQvlj+/8qNX4zGQSLUAZhCoJUne1pVSzhpCZjFnesiqJH4yqWTn4VVUc2qjl42VzZRIC6xBWj2CxKStizH3P8CFQlfnlv3G8gjNdpjp+I58MHQmpG14xjmZEaDhDa4B88iiiKOM6HI6ir2EAOotViWcaWrUJAVYIUiGqCSpa046WLMHa6YBktRGyU5VQGxiFMiSiGyJUQtzmdILMMV1ZdyQJAaBpCXSOmqVwKYmM9nROkjgL1JE4VD8PK9VyPCb//+7/PBz7wAT75yU9y99138yM/8iO8973v3dFn3/ve9/KqV73qtNef9axn8T//5/98dHf0HEYgGSgED7jYPE4ZrMxoVEETDLU31C5OiZxPFqMyYKQjVw1DNWUYNhhWpzD1BNVMokBZZ9hUeoQKeKmwIZvNJ1KTuGh96pA2NngT3nVNJJ3KogVyiM0nHQrrJet1gRAB5xVltcTnxweorGT/KJYiPX2wgQixoaVbzdDVBrqeYPMlajNi3exjT/VAbLo2F2tE8OhmGhvPHb0fO54iM43MMib3PhCXUYrgPaKpEWvH4/FlOUHnIDXCNXHsSRVjQBsfpUQJQSFEV2YcMokVGisVKkis1/gQi8YbMmpVoLMRchgF4TKLBgx6uI5cX8NPpoSmifvkLKIukdN18mTYoLKGSg1xzIxdWgvuzfOLba+VczwenEu4YB4gevTYHrMJ05mWOZu47rrrTnvtox/9KBB1En0n6h49Hk1sFxPO/mTilltu4ejRo7zkJS/h1ltvfVjruPXWW7nsssu6v/syyB49tsK5P0c4l3BBzEY6feK8LZqQMePdNWibtamfR2vbOp8tUGFmiyaSCHjWiAZaMkLgCURbuPh36MR8rci4FUe1++aCRglLCKYTHktmzIkgshOFmHaZ/6LZ4FIxYT3bh8CTuwkTtcLEDTh5xXUAbMhVMlUxVpeSiRpFbOY2bNZS9sMlq9loQVlmUYBpXMwqOqmR3uGUjhkQERkIQYgirJRFae1tWwlzK0A31Ok8z1iKzSIyLxQqWJzQHaMggyMEuXDeRIhnphNB+TCz2ZsXx+9yHIfADrpM7m6dPc5BCAFS07okCydi8zad4bMhThc0ZkSlhzQqJ4TInrXsg06iX9VMUNN15HgNmhrq1PBsSNc8TSgFLvKTLSPQ2Yn6mHEUdRkzdFVJsA1iOEJkBXiHzZdwSQBoXEmt9tCovGMC21g0HD+AKseIpgbbYOoSP1yZHbJ3uGxEYwaYS6/EjvYgbU1YVTErbxtEU2PX1rrPyDxDCEHdWLLVJQaXHUYUBW5jHVkU8djaYxkMESt70uEp5GQDf/I4fjqNjaxktK4UJkPojOHkGFW+QtaMafQgfi41mIxCdh2tZ72DJYXQGjUYIEclqizxyd4VYkbQlyXBe2RjkeUUOdwgpGxo0JogdYpts2aXO8F2MeFciAd//ud/jkxC8ttuu+1hreO6667j6quvfjR36/yCELGhqpBI10T2QeVUekjJgIkbsNEUlDbNF7zAKE8uLZm0FLKK7EN9irw8hSrXkdU0ZtyL0cJ2tKsXjFwEc0Yk3qKaKWq6HjP4iYFgsIw0A7SvWZP7qFwWrUm9oHbxfjmuDLn2LOWWq5e+GjdnQ1d54VSGMAOCVFT5ChtmDx5JZYY0Oiez0y5G6XqClwYdAnZ9g/zgPvTBQ/j1NfQgpziwh+yig4jhKDKN7ZAyGbIpowW1ySLrMNQIbWCyDtNo9CC9xyT7WACjCgZKxOZueKq56gGPTI3nBsgsWl7LrIjna7CEHC1H44cUP4P3MJ0ifMA0NWq6QTFcocmXsCp+rjWKEbscwP0cYXfoG8n1eEJh2yYx5yDe9KY3EULo2YcePR4DnOvxQMr+Nt2jx+OF83GOcLZwwcxIttI+eFSX5fdh1lhkTg2x2DRurqlci5iFj8Zvs1pp323TPcQzWFt3J4PHSZM0A1ErUIfYyr21nN2MTFSIEMhcSdaM0bbCS8VK8NR6EPUGwjG2OaeKA93xeRSFLMnDNNYApuzlvG2r8paNYj+DZr07hlbb4FNzHRkcOrEn8XzK7klebrKf80FF9iYxJ+25bJvJzVutzmtSXFvvyXzjrrla0TnrSyEiC9I1/EmZnbCLTGPcgR0EgD69cAFAEJTudAnBFASl8NmQJhvRmCGTbJWaHB+iDbERdWS+fINKGghp65ghT03PksIushFCIqRENCKyAlIRks2pNzELFpRCNGXaJYGfTghlhRotz9iKEPByFoaNj5oB6S3GV3Hf7BQ9PhWtE6cxE4fJkS6NxcEIX4yo8mWmZpl8z8Xd+JC2QlQThLUwHaP37kVmUacQGgtSMFgaIQ8cinqJ6QQ5GiFMBsaAbaJuQ4i4bYC6htFSV6fs1tbBe6SQiGKArKbIaorwDmsG5FWMNT7ZZpIaTnllQGcI0cDSCsJaxMgh6gppLTTxe/DTKb4s8WVFqGtIDInMC8RgEPcvi99xUIaQspc7wnYx4QKJB89//vM5evQoBw8e5Lu+67v41V/9Vfbt23e2d+txQwC8NLHBoR7Epm16yDQM2WhGrDc548pQu8QUiKh/kCJagmYiWpsrVyObEllXcdwLgbAW2TY7kwZDbJoYpMLKqLOKDeTszG5YKsR0A6HS/TIfzjVwlWSyofYalfbBesFqUWGDZMmULFVJk5CuT20rghBYMyAISa0K1twKmWyYyiUKP8bKDJPu307n6GaCqEvCt30n+gt/Fy2ZV1YZ/W/7YXVvjHl1CVnRWTh7U8QYqBReZ0jqmQYs6Z/C+hqCWKihhzFm5G1M1BItG4xssEF3FSAQ44PVg2gJnZpQimyIHK4gV9I5ryaIcgrlhDAZQzlBmpPIvMCkOAjg8iEusTFWP4rxYO6c97iAHiB69NgJ/MP1i+/Ro8cFiZ3EhLPZWPKR4PDhw7zxjW/kuc99LoPBgI997GO89a1v5fbbb+cTn/gERbGLyVWPHk8A9HOEneOCeYBoM+whCEJiG+Z1D/Ntzbdq8NKtZxMj0DmIBI+au7C8iPXBIj1Bb/6clVnMsEvRZc4BtGiwwVCHjEzUHUOyuelJm6nIy1PotaNMDzyJSbaKcSXHxEXgoHGKyscndSk8WShRvkF5Gx0XOrZgtm+VHnaZfyDWgKdGclZmsSlcq/kQKjbTshMaVaB8s3A+hIgsR5s5aXUX3TlCLTglyaQHadmZuJ2Z9iM6OTlEcn6anQsHgcS8+KhvEbJzf9opAjuwaNvx2nqcsxCCoA1BxLHhTY5XOVbnVNkSU7VEHfIuJigRmS/lbXRi8kkDFTxBqugyMpc5pGliXfB4PY7ewRAGowUNhAghZu+FxA9XEPkQqRSUU1haiZnL4DH1uPtcmS1jbEWj8+iUBl3W0g2WkOvH8ccfxK6tk11+OX41Wf06x3j1MsbZHsowYDkboesJqkoubU0df2zcbzlIjjEDoiYjaRsA5Oqe5BQVwHvCyt54SOU0NpUjZhjHn72LwaUX48Zj5HCAXVvHGIPYWINiBEJiTj0AKwe6jJ0SgiZfRrkaYWuEt1GvkH58biLjkw86rQeA1AahFG48jizEZIpb30BmWWQihgNEMUAMhoh8gNsFA7FdTGjfOVuNJR8pbrjhBm644Ybu7+uvv55nPvOZfPd3fze33HILP/ZjP/aIt3FeQAgaHeNBpYbU5JQ+Z2IL1qqcSa2preiSy7kJKBFQwmGERWGRPjokxR8RNUJJ5ySTO1pWRf2UzwfYfBmh471OpZjilaEe7kUMVjH5EJnYTltEPZOThr3+KBtqD5XMyHVk91eyCbXX7NHrHC33cF9xJQBXPfi3QKwIcGaAzaNz2oZYhQAbdsAeY8lc2TkvAVgzQDYVPh+QrR3FX/KkqNVaP4m96Ip4PCHg9l4UtVQtO5INOl2D9A2EgD55lHDieIwlSTflT55AaoOabgCgzSA17pRIaRj4je57MIndaZvWusQURWSIUCCyEaqokfUUla3HhnLra/jpBLe2hhASkWfIYWQg5GgJPVyOjMRw744vk/NljvBInNkAPvvZz/LTP/3T3H777eR5zo033sjb3va2Le3jz4QL5gGiR49t0XeZ7NGjxzx22In6bDWWfCxw4403MhqN+MQnPvHEeYDo0WMnOE/mCI/Eme1rX/saL3rRi7jmmmv44z/+Y06ePMnP/dzP8bKXvYzbb799V5qrC+YBIoSoZmizih6ZXpuxDjDTOcSW9mEuyx0616GdQAUbNRZSQpgxB41oGYHoXNSoPGbekZ3bUkBQiCkO3WXtZwyEx4eYuZ/oZYa6QA6WWR8e4qTfw0hNyELDhh0xqTVuEL/sTNRI78gTW9DCSd0dWxAS7ZNbkpx531cq79736dyt+2X2iuORLQgB48pOtxDXa2JWRYL2NVZmKN/EdQiVjlUm1mHGArU+14v6Cp/OwdYQqWZ6fr89sbdGaPtK7BB+W4u2Huc9BHid4VLtqzMFjR5Qq4JKDmmC6cahEQ2GmsxN0T5pHlq2QciZBgKgGMT/txmqLI+1v87BxhpiuBQ/ZhuES/qj0R6cGWDKtchWDKP7WVCq84E3SSOgmpI6X6Go1zu3NDnX38DvOYg4dQLVWMLeA0xX4yRV15OYuUNT+jiWpYvZOiYbMw2DUpBl+FMn434WBSIv4v5nWez3oA2hGCHqMmbvkqvR2lVPxzSTeNh7DqHuuZfJV++lGZesfP2TEELgxmOUUsgTD+D3HiJIhbn3i/i9h7qvxqsMNVkjmCyOaaUIgGxKhPdRRyIkQWuEnesFkcZtsA47rXBVDd6jBgXZ6jJqNanRdqN/aPdpBzHhbDWWfCwhxM7Z2/MdAYmVGbUoqELO1BVMbMa4MkwahU3ah8LEa2GQOQbGUugaIxpUsIvVAdqwcNW0MSL1KZHlGOMa/NLBjn1o9KCrBjC2wi1lHdspgseq6JS0YfYy9OtI7ZFiGecVQzUlkxpB4PLhkW6d45VLGK7fB0n/UKsi3tNDlhh9cCE6KmpXoWxkSrzOEN7is2HUR33+DtzXX4fMCrzOqEb7Yz+JbIiyNU0WH2itzDB2itUFXigKfQrZVIhTJ6jvP4oqctSeVXzTICdjRBEd2HS1gbQVhRBMR4cIQpDZKZNslayZdu6L8xrI+MWlHlJC4qVBqGbBZS04h59McdMKpEAP4/bU6gpyT40UEpkv7epaOR/mCI/Eme3mm2/GWssHP/hB/v/t3XuMXWXd6PHv86zLvs/MnnZa2lJotfQoU8DgGyzh1VKjhhw905dLxIiYkBzES0xU4n+SYPVPjCZKAImcEPQPsEYdTSSatJhA5JxoPeDbgb60nSn0tIVe5rpv6/acP56198z0NjOluzN7+vskhM7aa++19u2313P7/Xp6egBYu3Yt27Zt47e//S133333vB9L0juIK0azyuQF/1v8zgUhxGUyZ0xYhvHgd7/7HZVKhY997GOLfSpCLCmdco3wfjKzDQ4O8tnPfrbVeAD4xCc+wTXXXMPg4OCCHmvZjEAIMTeTViK98D5CiCvFXDFh8ePB0NAQQ0NDgF2LcfjwYXbt2gXYtRJ9fX0A7Ny5k507d3Lw4EGuvdbOkf/0pz/N9u3b2bJlS2sR9WOPPcZNN93EF7/4xcV5QkIsWcv7GqFarTIyMsKDDz541m39/f2tODNfy6QBMT1N6VzTl+we09OVtErQMwYglTLTU2TSAmrnSxHanObUfGwniWwRNpMQ4s+aAqVMgjGKCM8uwjIxAVky1NOUpzOKpzX/rQyJsc+hbnIcLW6mUfAZqxXIuiE5v46jYnJunYlaFyu6T9j7JYZMWLVTLhw71Bi5HtokZCI79cCN08JM6UIlsCledXP6ktIkxiHCpUeP0VV5Fx2HVAp96CTGi2oE3uwKpk5iF5g5SWSnKpkYNMTKxTONs17HmUX57LBlfMHX+1KTPM7Ln0ERu1niNHVg6OaouwVClSFB24X9BrK6hjGKbFQhG9gCazqenn6kwsCmOSx0oZI0fWuxq7XAGLCLorWC3PT3QsURJBFxoYcoU8SrT5B4WXS9QlTosTEkiVFRSJIpthZSekFtemqfdlvTDWLHJ8r1oOMQZ9ONGNdnrHhVKwblTWLTvpoGhhJ+ddQunp6asAuRXddOt/J8W1Culi70rFRwiqW08F4OtAbHtYu6PZ8kkyP2clTzKym/9mcmXrc/LpMnxlj9H/+dyt//TnFlGdMIiOsNXM/DBAHx2DgcP4bb3QPdZfRJu6A4WbGazOhREtdvLVDXjZotqKUdVJLYxdpgz6U5hamZQjdNW6sdhzCI0K62C9Nn9sZdRAaVpR4TXnjhBb7//e+3/n7ppZdaC6z37NnD7bffDtipF3EcY2Z0kfb39/Pcc89x5MgRGo0G69ev56tf/SqPPPIImUzmcj6NRWWAQGWpmyy1KEsl9KlHLkGcTgF2DTkvxnPs5yfvBRTdGr4OcFWIE4c2sUcSp6lMDUrbVKaJ49uUxNBK84rro4M6fm2MuOi3FhA3k4jU/BL5xliroGvDyZONKhhlf/sj7VOuHcXJraKRTkkuMkGkPNwk5LSxi121G+Pmy0xlVxBp+3sfqgwqNoSJg6sSPGWTn3iNyda0TjeskbgZm0I634VX6ka99TqNG/4dlUSM51aTcyfJNsapZ7sJ0nNwk5DJXB9+XKM0dRz/xNs2znSXySQ2zXVSr6O9tEBe+h12Th3D8XxQGnfyFLWVG9BJTClqEDs+oZtDoXBNYK8PWulp67O+0zoKUHFoEzy0EltokjiGmFmffZROU0bHC/uszDMedGJmtrGxMYwxlMtnLyzv7e1l//79C3q8ZdKAEGJu9hrkwsFkKQxPCiEuj7liwlKIB48++iiPPvroRe33k5/8pC3nJMRytJBrhE7MzNZsYJ1r/ZO5iGC3bBoQMxdQN80aDVDTvd7aFk8HsKMAMxutaeG35mJhNbP1O6Mlm42qJMqh7tkFOhEeLuGsdLIAnglsz0ASEymPfDxhi6FpO+Zg0DhExOlbYUvTxRg0vgqYiEqcqNpjlPw6ngoIjY+nQtb0NOg99RYAY70fwA+mUEnE0cwHSYyi24wT4aGdDF5si9E5SQhGz1rY7CShTZ2WnrOvGqgkYayw1r5eJsYloOFPL0ZyZhbFAdwktoVsHD9N8Wpf1BhnuvBeWlpendFLOHP0waS9Bol2WqNCKi021yyOZS568d98KkkugSsG8T4pjHYIXLvwr+HmibXbSnbgEpE1FeLEJRNV8aMqblCxvWO1iVavmTImLRDnQanHLqoeO2EX6no+5t2jNm1hLkfwxj501vboOpuvx2Ty6KCO9mwvfnOxpNOoEmfyOI0pjOPij79rRw3BLjpOYttDn/6t4giHNO1iHFIrrmYss4oYh+7oFAA6HTHJhZN0+x7u+Enba5emkY1WrrOpmusV8LLoku3l1yYhnppE+b7tMdQOFHw7IuD6BLkedBLTs/dPmKuuJv8/7OLfYqNKAuni5a7W4kkThsTjIcp1UMrDRCHmvWPoNE2sTlM6mlyx9fyMUnbkIS3KRbp4nDBojTgAKMdB53L2PXAdsq6D9lx0PofOZlG+b0dZFvwjOFdMkHiwPChC41GL7OLpMHEwBlzHkPVi8p79znvafua6vAo5ZZMTZKIqmahqRxeS2Bak8xVGuzbBgYlxG3YU0amnxRaVQlcnUHGEm+2ikemyv8HK4bS7mpIZYyq7gmxovxOFeAwnLVSXU2PpaEdEUY+STYveuUlAJqlS80o0ItvDH3seU9kVVCgRxB55XSMxGlfFeDomMZpcMmUTumRKresjP5gizHXbVK0qi1coogD/H7vRGzZRdjwyE+/R6LIJEJqzGCb9XnLxFKXJo6gkpr76g2T1CGHPKjw/izl+BKeryy4mz2TBSS8xHRfjpcXhTr9H1vGIcyUc7RAW8nbkRbm4cVrEM42JzSQWrVHbNF0ujoNyPfvd9zy079sYUbAjwSpfgGyOJJObteh6bvO/RujEzGzlchmlFKdPnz7rttHR0QUXl1w2DQgh5mSms7lcaB8hxBVirpgg8UCIK8cCrhE6MTNbPp9nw4YN7Nu376zbhoaG2LZt24Ieb1k1IJprE5ppWs+8DcBR0fQ2Y6bTh6X3baZnbQqdjC0yZSJM+hgGRaR93CSwqUvTAmfKJPjpvOWK202Y9vz7cR1tYjwaxMolUQ5uErRSmhoUSqdrMNJ0r5CgTUzJVTjFGIeEvK7YYlfK3rY5O0Fd9bXONdEOU4XVHK30sCo/yZQp4amQQGXBsSMosXaJlTsjHatLNSmiMETGtXPCdZ0qBXJUMWhcBaG2vQfNNLDTr9/062zS1y1My9CbtJBcq5ifsYX3EmXnoTdHJlojEunoAzNGIaaPNZ32FexaikQtrJAcLP35zuLSaaY6BNvbXgjHgem0wLF26RodQYUBUaHbjj4kCTpKP+NxDI6DPv42rFhF4vuE13wYd/IU+tS7KM+FlVdhHA+lDtvRCEDVKhg3g25UydQrJH6WoGsVKlfCPT6CLvUQFXpwapOoE8dselVA9azAxDE6qqSF1XIYx8UohRvW8OoTxF6WrvCUTaGYrttwojpOmOCpKbywSlwq47z7tl3HsOIqJrvXk6uPkbgZm961UZ1+HeIYEwSYqSlULofRDnHervOI3QyxMfDhj3GkdD2b/stm6Aj7rsY7cQTVtxISg3/VKuKJSaIJ25uahHYUwiQGr5jHu+YD9nhRhPF8uxak2AvaIc6VSDK2Z82pjttvcxzb0Qh3+ufJVCugNW65bOc+Jwa0Qilt98sXMIVujOcv+HMiMeHK0Py1MgaybojnxyhlWj31AGV3FLAzB3QS48YBftr7riP7m50oh8TxSByPhlMi05jESUcB43R0DaXRk6N2Dn4S48QBRjlErk+XGUWbmFxjkvGM/f22Kd0jVky9jRM1cBtThNkuu6LT2PTsDTdPokLqJoev7fHywTgnvHVkVY3AeFSSPAVdJaMauE5EkPgETpZC7RSJdgndXOv1SLRHw8uTKIdM6T1UtoA58R71v/8f/J796PXXooorWqMBAIHJ0NBZJnp6URjWjL9J0LuG2M3iuh6q7yqII1t0sl61/wbQDmpqDIKAZHIcVqxGxyGhX0hHdqL0+sQncDK4aXr2RDt2HURaxE9lHQgcdBxDUaPSkRPtuDZmNGdWuC5xvpsw103kLiy183KPBwMDAzz77LOMj4/T3d0NwMsvv8zhw4cZGBhY0GO1beXqO++8wz333EN3dzddXV3ceeedHD58uF2HE2IebIaFC/0nXY7tIzFBLD0XjgkSD9pH4oFYejrjGmFoaIhdu3axa9euWZnZdu3axYkTJ1r77dy5E9d1Z32vvvvd7+I4DgMDA7z44os8//zz3Hfffdxyyy3ceeedCzqPtoxAVCoVtm/fTjab5dlnn0Upxfe+9z22b9/O66+/TrG4sMIeczNoFZOYZgGzdBSC+My9WvP8NQlGpWsmlLY9krgYpW1LWNmXRqdFzkLl23nE2BZ1Q+dtISqCdH9Ngkfopj31hDRMlkBnyFC3hVPiOpOqh9C4eCrC02Fr39aaC1Rrjn8ze1NJT9p1G2nvR4RH3WSpxxkOjNk5eHdVnqG+aiMA1xcOUtN2VCFjbGaXSPutDFMKQ5y21J0kIqfSHpbm+otEkaXS6nloFntrjhhAOsrgTPfy2jmMTmukQqfFYGwxufRxsPukf7SyL80sJkdazE4Tt0aNEuVAer9WYcB05GZBnxIDcSSLqBfD5YwJKonsmoZUgYTQyeLEAV5QIXE8O1rYzLzmZ/GPDxOtXIdKYoJ8FwD+qaM0ymvJ1Cowdop4/WZ0UCPOlahfdzUA+Tf/N6qrh/qnPk9u6j17wPGT6NH3qG24gdzIv9DG4NUnaBRW8N4N/azd+zvcehW8DNUPb2U8fxUA5ckjZMaO2SJrQR13Ki3mhi1MFeeK+PUJPF2ZXfAOMI5H5OWYyK1iKn8dG//z7zjdPeh6hZ7jb9iMSn7O3q85jzhXsD15UWjnLGdzYBJ0owaOQ27iOLXSavzqKGu8Q5i0CJ53bNh+UdZusHOSTx7H7b8Rx8ti3nwN5TgoP4OJI9S110EaI5JcEeN6BPky2VNvE+e7015Du7ZJxTFJrpTOe45QgZ0PTd6FvrXo8ZOY0VOo7rJd76AdO+KgNMZxidORDB1PF6Cby1wxQeJBe1zuawRt7O+ccW1xtQQouraAWWhcik6FlbV3aGCPG2sXP6oRa4/QzdmCsH6MFzXStYYxiZdjKlNmKlOmENjRzVz1FInjYZRm6gO3pGsF47Qga0z51FESP0eiHI53baa3cRyArn/tJrr2Q0z1rKf76H/SKK9jorjGzmCIquRG/x8kMZWVG+kKjpE9fQSAsXU30GVGSXBYlRyj4eZb1z8uIUYrRsMyXe5JnKhBJrBFK+P0OiVwstSSPCu0S1ws4G/4AE5lCgpFou4+Yi+LTsLW+kdXRVSSPHlVYzIqEvoFvMDGI+NnifNdjPZ+kCPR1fT646x/+X8BkFSquKtXQxyj115Dtfdqu4YiY2dq5IIJ3s5sZpU5Zl93Z3okMXJzKGNHcZyoYbNg5btwqxOoKLDH9XOzsmEZ7RA5WRpefkHXCZ1yjfB+MrOtW7eOPXv28J3vfIe7774b3/fZsWMHP/rRjxZcX6ItDYinn36a4eFh9u/fz6ZNmwC48cYbue6663jqqad4+OGH23FYIea03IcnlyqJCWKpkphw+Uk8EEtVJ8SD95OZDeCGG27gL3/5y/s+j7Y0IAYHB9m6dWsrMABs3LiR2267jcHBwbYEB2VMa3Tg/M5YF3FGU9Ihsjnk1Yy5t0yPWMy8f/NYzf3PPL5B4dOYdaxQZ8hRJXeOBnGrZ37Geakzhsqa+7iEFHVIUU+ycs1JAI5y+6x9Pew87li5zTIZaRYjh/OJlTvruc9Hc8RhJmXMrGOd7zFnPuczzyu5wHleNDOPIjFLoXthGbqsMUEpdBTgp2sZfEYvvLtJiHuvamVDcgKbpSgulXEbU8QrbPaMZs+2ihMyU/Z7F1/9QQDyE9Mp+uJSGUpl/Ooo8aqrW9szlVOsrpxq3QcgM3WSVeljATZrCGCys+utxOmoiA7r534SUYDTqNA3dZI+gC3/xpn9aK3n1XvV9MauFed+POzrkp84htEO2cn3WudG37rpnTI5KM3IKb7l3zBMD/Kf69vkV0ftSIOZzoCniImLPbPvkyvNul+8Yg2sOHcmE1jYyEPLXDFB4kFbXP5rhLTeCxV6m7+/M78gCTS82VkGm7WSEuW0RtojxyfKTWeqyaVZlJq/V5XCqllHjZzZa3Ia5eljdEWnW7ef/sgdre2j624CbM0FozQNr0hj1X9r3R66tjZLk5uEgP3sN7MlNWWo0s0pQidL6Jy9FiAXTpFjionyBruheO7vV/OapBiNUWQMEigxSuAVWrWhmufkJBHX6hGIYGzrf5zz8WZyk5DQzbE6OWqf34zzTGas2QjdHMy83DjPuc40cx3cvMg1woK0ZQ3Evn372LJly1nbL6bSnRCXioG5y9Qv9kkuUxITxFI0Z0xY7BNcpiQeiKVIrhEWpi0jEKOjo+etdDc6euHewKeeeoqf//zn8zrOa6+9BsDBgwcZ2LFj4ScqloWDBw8CMDw8fMH9apOH+edf/+ec+4hL72JjwsXEg/0jR/j3B2QKxJVs/4idI/5+Y4LEg/a43NcIbx0a5o67vrDwExXLwluHbByQa4RLq21pXC+20t2xY8cWVN0PoF6vnzOvrbiy1Ovnmd6RSpIGlfH/ukxnI850MTHhYuJBrRHwf/cfWtB9xPIkMWHputzXCP8amrtYl1jeJB5cWm1pQJTL5fNWujtXr8NMa9as4eabb57Xcf75z39ijMFxHG666aaLOldx+bzxxhvUarUFV3Ccy/DwMPV6nVWrVp3z9osp0nK5CrtcKS42Jkg8WL7aFQ/g0scEiQeXllwjiDN1Ujy42PssN8rMp8m/QJ/85CcJgoCXX3551vbbb78dYwx//etfL8lxPvrRj7J3715uvvnmS1IRULSXvF9XrssRE+Tz1Vnk/bpyyTWCOJO8V52nLYuoBwYGePXVVzl0aHoawcjICK+88sqCK90JITqfxAQhRJPEAyE6X1saEA8++CAbNmxgx44d/P73v2dwcJAdO3awfv16HnrooXYcUgixhElMEEI0STwQovO1pQFRKBTYvXs3mzdv5v777+e+++5j48aN7N69uw1VqIUQS53EBCFEk8QDITpf27IwXXPNNfzmN79p18MLITqMxAQhRJPEAyE6W1tGIIQQQgghhBDLkzQghBBCCCGEEPMmDQghhBBCCCHEvEkDQgghhBBCCDFv0oAQQgghhBBCzJs0IIQQQgghhBDz1rY0rpfDV77yFY4dO8aaNWsW+1TEPMj7JdpJPl+dRd4v0W7yGesc8l51HmWMMYt9EkIIIYQQQojOIFOYhBBCCCGEEPMmDQghhBBCCCHEvHVkA+Kdd97hnnvuobu7m66uLu68804OHz682Kd1RTly5Ajf/OY3ufXWW8nn8yilGBkZOWu/Wq3Gww8/zJo1a8jlcmzdupWXXnrpnI/51FNP8aEPfYhMJsPmzZt54okn2vskxLIg8WDxSTwQS4XEg6VBYsLy13ENiEqlwvbt23nzzTd59tlnee655zhw4ADbt29nampqsU/vinHgwAFeeOEFyuUyH//4x8+73wMPPMAvfvELdu7cyR//+EfWrl3LHXfcwd69e2ft9+STT/K1r32Nu+++mxdffJHPf/7zfOMb3+Dxxx9v91MRHUziwdIg8UAsBRIPlg6JCVcA02F+/OMfG621eeutt1rbDh06ZBzHMY899tgintmVJY7j1r+ffvppA5jh4eFZ++zdu9cA5plnnmltC8PQbN682Xzuc59rbQuCwKxcudJ8+ctfnnX/Bx54wPT29ppGo9GeJyE6nsSDpUHigVgKJB4sHRITlr+OG4EYHBxk69atbNq0qbVt48aN3HbbbQwODi7imV1ZtJ77o/OHP/wBz/O49957W9tc1+ULX/gCf/7zn2k0GgD87W9/4+TJk3zpS1+adf/777+f06dP88orr1zakxfLhsSDpUHigVgKJB4sHRITlr+Oa0Ds27ePLVu2nLW9v7+foaGhRTgjcT779u1j48aN5PP5Wdv7+/sJgoADBw609gPOel/7+/sB5H0V5yXxoHNIPBDtJvGgs0hM6Gwd14AYHR2lXC6ftb23t5fR0dFFOCNxPhd6rwBOnz7d2g84a98z9xPiTBIPOofEA9FuEg86i8SEztZxDQgApdRZ24zUw1tyjDHzeq+af59rXyHmIvGgM0g8EJeDxIPOITGhs3VcA6JcLp+ztXm+lqxYPL29ved9r5q3z/z/mfs2/27eLsSZJB50DokHot0kHnQWiQmdreMaEP39/a35cDMNDQ1x/fXXL8IZifPp7+9neHiYarU6a/vQ0BC+77cWujXnMZ75vjbnNcr7Ks5H4kHnkHgg2k3iQWeRmNDZOq4BMTAwwKuvvsqhQ4da20ZGRnjllVcYGBhYxDMTZxoYGCAMQ37961+3tkVRxPPPP89nPvMZMpkMALfeeisrV67kV7/61az7//KXv6S3t5fbbrvtsp636BwSDzqHxAPRbhIPOovEhM7mLvYJLNSDDz7Iz372M3bs2MEPf/hDlFI88sgjrF+/noceemixT++KsmvXLgD+8Y9/APCnP/2Jvr4++vr62LZtGx/5yEe49957+da3vkUYhmzcuJEnnniC4eHhWYHA8zx+8IMf8PWvf51169bxqU99it27d/PMM8/w05/+FN/3F+X5iaVP4sHSIfFALDaJB0uLxIRlbnHKT7w/hw8fNnfddZcplUqmWCyaHTt2nFWgRLQfcM7/tm3b1tqnWq2ab3/722b16tUmk8mYW265xezZs+ecj/fkk0+a6667zvi+bzZt2mQef/zxy/NEREeTeLA0SDwQS4HEg6VDYsLypoyR9ARCCCGEEEKI+em4NRBCCCGEEEKIxSMNCCGEEEIIIcS8SQNCCCGEEEIIMW/SgBBCCCGEEELMmzQghBBCCCGEEPMmDQghhBBCCCHEvEkDQgghhBBCCDFv0oAQQgghhBBCzJs0IIQQQgghhBDzJg0IIYQQQgghxLxJA0IIIYQQQggxb9KAEEIIIYQQQszb/wdkxWRKMx6+CQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(out_state[0])\n", + "plot_field(out_state[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "e0eee8e7-1131-42c6-bdb4-5f0d70e77d21", + "metadata": {}, + "outputs": [], + "source": [ + "pde_args = QGARGS(\n", + " params=params,\n", + " domain=domain,\n", + " layer_domain=layer_domain,\n", + " wind_forcing=wind_forcing,\n", + " helmoltz_dst_mat=helmoltz_dst_mat,\n", + " alpha_matrix=alpha_matrix,\n", + " homogeneous_sol=homogeneous_sol,\n", + " bc_fn=bc_fn,\n", + ")\n", + "\n", + "pde_time_step_fn = ft.partial(F_qgml.pde_time_step, params=params, args=pde_args)\n", + "\n", + "rhs_time_step_jitted = jax.jit(pde_time_step_fn)\n", + "\n", + "\n", + "# vector field\n", + "def vector_field(t, state, args):\n", + " p, q = state\n", + " p, q = rhs_time_step_jitted(p, q)\n", + "\n", + " return (p, q)\n", + "\n", + "\n", + "if domain.Nx[0] == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "d36f0d83-644d-46a6-a194-20ec3e74d505", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-12 18:57:12.848\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdp: (3, 97, 121) | -5.185125e-06 | 2.919435e-08 | 2.919435e-08 | 5.175048e-06\u001b[0m\n", + "\u001b[32m2023-07-12 18:57:12.848\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m22\u001b[0m - \u001b[34m\u001b[1mdq_f0: (3, 97, 121) | -1.502200e-06 | -8.966964e-12 | -8.966964e-12 | 1.339382e-06\u001b[0m\n" + ] + } + ], + "source": [ + "dp, dq = vector_field(0, (p, q), None)\n", + "print_debug_quantity(dp, \"dp\")\n", + "print_debug_quantity(dq, \"dq_f0\")" + ] + }, + { + "cell_type": "markdown", + "id": "dc9508f4-3ddd-4a46-b3fd-6110267f9ff2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Time Stepping\n", + "\n", + "We're going to use the Heun method.\n", + "I'll also be using `diffrax` to handle the time stepping :)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "988e4234-c444-49a0-a17b-15dad9e8bfae", + "metadata": {}, + "outputs": [], + "source": [ + "dt = 1_200 # LR #600 # HR #\n", + "n_years = 2\n", + "n_days = 365\n", + "tmin = 0\n", + "tmax = pd.to_timedelta(n_years * n_days, unit=\"day\").total_seconds()\n", + "ts = jnp.arange(tmin, tmax, dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "70d59ba6-3cb1-4557-a7ce-379269c31548", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "52560" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ts)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "25a0510c-a635-4b48-bc80-ea59da75e70c", + "metadata": {}, + "outputs": [], + "source": [ + "if domain.Nx[0] == 97:\n", + " p = np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True).astype(np.float64)\n", + "else:\n", + " p = jnp.zeros_like(domain.grid[..., 0])\n", + " p = einops.repeat(p, \"i j -> 3 i j\")\n", + "\n", + "\n", + "bc_fn = ft.partial(F_qgml.custom_boundaries, constant=params.zfbc)\n", + "q = F_qgml.pressure_to_vorticity(jnp.asarray(p), bc_fn, layer_domain.A, params, domain)\n", + "\n", + "state = (p, q)\n", + "\n", + "\n", + "solver = dfx.Heun()\n", + "solver_state = solver.init(\n", + " terms=dfx.ODETerm(vector_field),\n", + " t0=tmax,\n", + " t1=tmin + dt,\n", + " y0=state,\n", + " args=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "ba30e79b-1ec6-4d91-add1-382910d41ce4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2000" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_check = 2_000\n", + "freq_log = 1_000 # LR #50 # HR #\n", + "n_check" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "5355e16e-6862-4bd1-af6f-593293208943", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02be4df57ec44719ae279f9dc0826dc7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/52560 [00:00 21\u001b[0m \u001b[39mif\u001b[39;00m t \u001b[39m%\u001b[39;49m (freq_log \u001b[39m*\u001b[39;49m dt) \u001b[39m==\u001b[39;49m \u001b[39m0\u001b[39;49m:\n\u001b[1;32m 22\u001b[0m saved_states[\u001b[39m\"\u001b[39m\u001b[39mq\u001b[39m\u001b[39m\"\u001b[39m]\u001b[39m.\u001b[39mappend(state[\u001b[39m1\u001b[39m])\n\u001b[1;32m 23\u001b[0m saved_states[\u001b[39m\"\u001b[39m\u001b[39mp\u001b[39m\u001b[39m\"\u001b[39m]\u001b[39m.\u001b[39mappend(state[\u001b[39m0\u001b[39m])\n", + "File \u001b[0;32m~/miniconda3/envs/jaxsw/lib/python3.11/site-packages/jax/_src/numpy/array_methods.py:258\u001b[0m, in \u001b[0;36m_defer_to_unrecognized_arg..deferring_binary_op\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 256\u001b[0m args \u001b[39m=\u001b[39m (other, \u001b[39mself\u001b[39m) \u001b[39mif\u001b[39;00m swap \u001b[39melse\u001b[39;00m (\u001b[39mself\u001b[39m, other)\n\u001b[1;32m 257\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, _accepted_binop_types):\n\u001b[0;32m--> 258\u001b[0m \u001b[39mreturn\u001b[39;00m binary_op(\u001b[39m*\u001b[39;49margs)\n\u001b[1;32m 259\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(other, _rejected_binop_types):\n\u001b[1;32m 260\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39munsupported operand type(s) for \u001b[39m\u001b[39m{\u001b[39;00mopchar\u001b[39m}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 261\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mtype\u001b[39m(args[\u001b[39m0\u001b[39m])\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m!r}\u001b[39;00m\u001b[39m and \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mtype\u001b[39m(args[\u001b[39m1\u001b[39m])\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m!r}\u001b[39;00m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "saved_states = dict(q=list(), p=list(), t=list())\n", + "\n", + "solver_step = jax.jit(solver.step, static_argnames=(\"made_jump\", \"terms\"))\n", + "\n", + "with tqdm(ts) as pbar:\n", + " for t in pbar:\n", + " state, _, _, solver_state, _ = solver_step(\n", + " terms=dfx.ODETerm(vector_field),\n", + " t0=t,\n", + " t1=t + dt,\n", + " y0=state,\n", + " args=None,\n", + " solver_state=solver_state,\n", + " made_jump=False,\n", + " )\n", + "\n", + " msg1 = f\"PRESSURE: {jnp.min(state[0]):.4e} | {jnp.max(state[0]):.4e}\"\n", + " msg2 = f\"VORTICITY: {jnp.min(state[1]):.4e} | {jnp.max(state[1]):.4e}\"\n", + " pbar.set_description(msg1 + \" - \" + msg2)\n", + "\n", + " if t % (freq_log * dt) == 0:\n", + " saved_states[\"q\"].append(state[1])\n", + " saved_states[\"p\"].append(state[0])\n", + " saved_states[\"t\"].append(t)" + ] + }, + { + "cell_type": "markdown", + "id": "98fb638c-5efa-4404-9e30-4c2947a28849", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "546e67c6-5101-4e3d-8e3f-5a3eb0880666", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (time: 53, layer: 3, x: 97, y: 121)\n",
+       "Coordinates:\n",
+       "  * time     (time) float64 0.0 1.2e+06 2.4e+06 ... 6e+07 6.12e+07 6.24e+07\n",
+       "  * layer    (layer) int64 0 1 2\n",
+       "  * x        (x) float64 0.0 4e+04 8e+04 1.2e+05 ... 3.76e+06 3.8e+06 3.84e+06\n",
+       "  * y        (y) float64 0.0 4e+04 8e+04 1.2e+05 ... 4.72e+06 4.76e+06 4.8e+06\n",
+       "Data variables:\n",
+       "    q        (time, layer, x, y) float64 -0.4522 -0.4529 ... 0.4412 0.449\n",
+       "    p        (time, layer, x, y) float64 0.009725 0.02492 ... 0.007248 0.003341
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 53, layer: 3, x: 97, y: 121)\n", + "Coordinates:\n", + " * time (time) float64 0.0 1.2e+06 2.4e+06 ... 6e+07 6.12e+07 6.24e+07\n", + " * layer (layer) int64 0 1 2\n", + " * x (x) float64 0.0 4e+04 8e+04 1.2e+05 ... 3.76e+06 3.8e+06 3.84e+06\n", + " * y (y) float64 0.0 4e+04 8e+04 1.2e+05 ... 4.72e+06 4.76e+06 4.8e+06\n", + "Data variables:\n", + " q (time, layer, x, y) float64 -0.4522 -0.4529 ... 0.4412 0.449\n", + " p (time, layer, x, y) float64 0.009725 0.02492 ... 0.007248 0.003341" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xarray as xr\n", + "\n", + "\n", + "ds_results = xr.Dataset(\n", + " data_vars={\n", + " \"q\": ((\"time\", \"layer\", \"x\", \"y\"), np.stack(saved_states[\"q\"], axis=0)),\n", + " \"p\": ((\"time\", \"layer\", \"x\", \"y\"), np.stack(saved_states[\"p\"], axis=0)),\n", + " },\n", + " coords={\n", + " \"time\": ((\"time\"), np.stack(saved_states[\"t\"], axis=0)),\n", + " \"layer\": ((\"layer\"), np.arange(3)),\n", + " \"x\": ((\"x\"), np.arange(0, domain.Lx[0] + 1, domain.dx[0])),\n", + " \"y\": ((\"y\"), np.arange(0, domain.Lx[1] + 1, domain.dx[1])),\n", + " },\n", + ")\n", + "ds_results" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "f85d69ec-2ce4-4639-acd3-7f6aec53dff5", + "metadata": {}, + "outputs": [], + "source": [ + "from xmovie import Movie\n", + "from pathlib import Path\n", + "from matplotlib import ticker\n", + "\n", + "\n", + "def custom_plot_p_layers(ds, fig, tt, *args, **kwargs):\n", + " sub = ds.isel(time=tt)\n", + "\n", + " xlim = kwargs.pop(\"xlim\", None)\n", + " ylim = kwargs.pop(\"ylim\", None)\n", + " vmin = kwargs.pop(\"vmin\", sub.p.min())\n", + " vmax = kwargs.pop(\"vmax\", sub.p.max())\n", + " cmap = kwargs.pop(\"cmap\", \"viridis\")\n", + "\n", + " fig.set_size_inches(15, 10)\n", + "\n", + " ax = fig.subplots(ncols=3, nrows=2)\n", + "\n", + " for i in range(3):\n", + " # NATL60\n", + " pts = sub.p.isel(layer=i).plot.pcolormesh(\n", + " ax=ax[0, i],\n", + " cmap=\"viridis\",\n", + " add_colorbar=True,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " # **kwargs\n", + " )\n", + "\n", + " loc = ticker.MaxNLocator(6)\n", + " levels = loc.tick_values(vmin, vmax)\n", + " sub.p.isel(layer=i).plot.contour(\n", + " ax=ax[0, i],\n", + " levels=levels,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " alpha=0.5,\n", + " linewidths=1,\n", + " cmap=\"black\",\n", + " linestyles=np.where(levels >= 0, \"-\", \"--\"),\n", + " )\n", + "\n", + " # ax.set_aspect('equal')\n", + " pts = ax[0, i].set(xlabel=\"x [m]\", ylabel=\"y [m]\", title=f\"Layer {i}\")\n", + "\n", + " xlim = kwargs.pop(\"xlim\", None)\n", + " ylim = kwargs.pop(\"ylim\", None)\n", + " vmin = kwargs.pop(\"vmin\", sub.q.min())\n", + " vmax = kwargs.pop(\"vmax\", sub.q.max())\n", + " cmap = kwargs.pop(\"cmap\", \"viridis\")\n", + "\n", + " for i in range(3):\n", + " # NATL60\n", + " pts = sub.q.isel(layer=i).plot.pcolormesh(\n", + " ax=ax[1, i],\n", + " cmap=\"RdBu_r\",\n", + " add_colorbar=True,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " # **kwargs\n", + " )\n", + "\n", + " loc = ticker.MaxNLocator(6)\n", + " levels = loc.tick_values(vmin, vmax)\n", + " sub.q.isel(layer=i).plot.contour(\n", + " ax=ax[1, i],\n", + " levels=levels,\n", + " vmin=vmin,\n", + " vmax=vmax,\n", + " alpha=0.5,\n", + " linewidths=1,\n", + " cmap=\"black\",\n", + " linestyles=np.where(levels >= 0, \"-\", \"--\"),\n", + " )\n", + "\n", + " # ax.set_aspect('equal')\n", + " pts = ax[0, i].set(xlabel=\"x [m]\", ylabel=\"y [m]\", title=f\"Layer {i}\")\n", + " plt.tight_layout()\n", + " return None, None\n", + "\n", + "\n", + "from pathlib import Path\n", + "\n", + "\n", + "def create_movie(\n", + " var,\n", + " name,\n", + " plotfunc=custom_plot_p_layers,\n", + " framedim: str = \"steps\",\n", + " file_path=None,\n", + " **kwargs,\n", + "):\n", + " if file_path is not None:\n", + " file_name = Path(file_path).joinpath(f\"movie_{name}.gif\")\n", + " else:\n", + " file_name = Path(f\"./movie_{name}.gif\")\n", + "\n", + " mov = Movie(\n", + " var, plotfunc=plotfunc, framedim=framedim, **kwargs, dpi=200, input_check=False\n", + " )\n", + " mov.save(\n", + " file_name,\n", + " remove_movie=False,\n", + " progress=True,\n", + " framerate=3,\n", + " gif_framerate=3,\n", + " overwrite_existing=True,\n", + " gif_resolution_factor=0.5,\n", + " parallel=False,\n", + " )\n", + "\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a5a1d23-1cc6-4a3d-9e51-b4cf45bd4558", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "06b4c4c0-3b49-44b0-b11a-d11431fc67a9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "mov = Movie(\n", + " ds_results.transpose(\"time\", \"layer\", \"y\", \"x\"),\n", + " plotfunc=custom_plot_p_layers,\n", + " framedim=\"time\",\n", + " input_check=False,\n", + ")\n", + "mov.preview(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "5b6f4726-ca13-40a7-a7e1-8c54b66b2a0d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + "/var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/ipykernel_71303/2500604652.py:78: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7d68bcec017244b0ae325e54d9b2d5b3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/53 [00:00 0:\n", + " self.p_prime.unsqueeze_(0)\n", + " else:\n", + " self.p_prime = None\n", + " self.arr_kwargs = {\"dtype\": torch.float64, \"device\": self.device}\n", + "\n", + " # grid\n", + " self.x, self.y = torch.meshgrid(\n", + " torch.linspace(0, self.Lx, self.nx, **self.arr_kwargs),\n", + " torch.linspace(0, self.Ly, self.ny, **self.arr_kwargs),\n", + " indexing=\"ij\",\n", + " )\n", + " self.y0 = 0.5 * self.Ly\n", + " self.dx = self.Lx / (self.nx - 1)\n", + " self.dy = self.Ly / (self.ny - 1)\n", + "\n", + " assert self.dx == self.dy, f\"dx {self.dx} != dy {self.dy}, must be equal\"\n", + " self.diff_coef = self.a_2 / self.f0**2 / self.dx**4\n", + " self.hyperdiff_coef = (self.a_4 / self.f0**2) / self.dx**6\n", + " self.jac_coef = 1.0 / (self.f0 * self.dx * self.dy)\n", + " self.bottom_friction_coef = self.delta_ek / (\n", + " 2 * np.abs(self.f0) * self.dx**2 * (-self.heights[-1])\n", + " )\n", + "\n", + " tau = torch.zeros((self.nx, self.ny, 2), **self.arr_kwargs)\n", + " tau[:, :, 0] = -param[\"tau0\"] * torch.cos(\n", + " 2 * torch.pi * (torch.arange(self.ny, **self.arr_kwargs) + 0.5) / self.ny\n", + " ).reshape((1, self.ny))\n", + " self.wind_forcing = (\n", + " curl_wind(tau, self.dx, self.dy) / (self.f0 * self.heights[0])\n", + " ).unsqueeze(0)\n", + " if self.n_ens > 0:\n", + " self.wind_forcing.unsqueeze_(0)\n", + "\n", + " # init matrices\n", + " self.compute_A_matrix()\n", + " self.compute_layer_to_mode_matrices()\n", + " self.compute_helmoltz_matrices()\n", + " self.compute_alpha_matrix()\n", + " self.helmoltz_dst = self.helmoltz_dst.type(torch.float32)\n", + "\n", + " # precomputations\n", + " self.beta_y_y0_over_f0 = (self.beta / self.f0) * (self.y - self.y0)\n", + "\n", + " # initialize pressure p and potential voritcity q\n", + " self.p_shape = (\n", + " (self.nl, self.nx, self.ny)\n", + " if self.n_ens == 0\n", + " else (self.n_ens, self.nl, self.nx, self.ny)\n", + " )\n", + " self.p_shape_flat = self.p_shape[:-2] + (self.nx * self.ny,)\n", + " self.p = torch.zeros(self.p_shape, **self.arr_kwargs)\n", + " self.p_modes = torch.zeros_like(self.p)\n", + " self.compute_q_over_f0_from_p()\n", + "\n", + " # # precompile torch functions\n", + " # self.zfbc = torch.tensor(self.zfbc, **self.arr_kwargs) # convert to Tensor for tracing\n", + " # self.grad_perp = torch.jit.trace(grad_perp, (self.p,))\n", + " # self.inverse_elliptic_dst = torch.jit.trace(inverse_elliptic_dst, (self.q_over_f0[...,1:-1,1:-1], self.helmoltz_dst))\n", + " # self.jacobi_h = torch.jit.trace(jacobi_h, (self.q_over_f0, self.p))\n", + " # self.laplacian_h = torch.jit.trace(laplacian_h, (self.p, self.zfbc))\n", + " # self.laplacian_h_boundaries = torch.jit.trace(laplacian_h_boundaries, (self.p, self.zfbc))\n", + " # self.laplacian_h_nobc = torch.jit.trace(laplacian_h_nobc, (self.p,))\n", + " # self.matmul = torch.jit.trace(matmul, (self.Cl2m, self.q_over_f0, ))\n", + "\n", + " # precompile torch functions\n", + " self.zfbc = torch.tensor(\n", + " self.zfbc, **self.arr_kwargs\n", + " ) # convert to Tensor for tracing\n", + " self.grad_perp = grad_perp\n", + " self.inverse_elliptic_dst = inverse_elliptic_dst\n", + " self.jacobi_h = jacobi_h\n", + " self.laplacian_h = laplacian_h\n", + " self.laplacian_h_boundaries = laplacian_h_boundaries\n", + " self.laplacian_h_nobc = laplacian_h_nobc\n", + " self.matmul = matmul\n", + "\n", + " def compute_A_matrix(self):\n", + " A = torch.zeros((self.nl, self.nl), **self.arr_kwargs)\n", + " A[0, 0] = 1.0 / (self.heights[0] * self.reduced_gravities[0])\n", + " A[0, 1] = -1.0 / (self.heights[0] * self.reduced_gravities[0])\n", + " for i in range(1, self.nl - 1):\n", + " A[i, i - 1] = -1.0 / (self.heights[i] * self.reduced_gravities[i - 1])\n", + " A[i, i] = (\n", + " 1.0\n", + " / self.heights[i]\n", + " * (1 / self.reduced_gravities[i] + 1 / self.reduced_gravities[i - 1])\n", + " )\n", + " A[i, i + 1] = -1.0 / (self.heights[i] * self.reduced_gravities[i])\n", + " A[-1, -1] = 1.0 / (\n", + " self.heights[self.nl - 1] * self.reduced_gravities[self.nl - 2]\n", + " )\n", + " A[-1, -2] = -1.0 / (\n", + " self.heights[self.nl - 1] * self.reduced_gravities[self.nl - 2]\n", + " )\n", + " self.A = A.unsqueeze(0) if self.n_ens > 0 else A\n", + " logger.debug(f\"A Matrix Created\")\n", + "\n", + " def compute_layer_to_mode_matrices(self):\n", + " \"\"\"Matrices to change from layers to modes.\"\"\"\n", + " A = self.A[0] if self.n_ens > 0 else self.A\n", + " lambd_r, R = torch.linalg.eig(A)\n", + " lambd_l, L = torch.linalg.eig(A.T)\n", + " self.lambd = lambd_r.real\n", + " R, L = R.real, L.real\n", + " self.Cl2m = torch.diag(1.0 / torch.diag(L.T @ R)) @ L.T\n", + " self.Cm2l = R\n", + " if self.n_ens > 0:\n", + " self.Cl2m.unsqueeze_(0), self.Cm2l.unsqueeze_(0)\n", + " logger.debug(f\"Layer Mode Matrices\")\n", + " logger.debug(\n", + " f\"Cm2l: {self.Cm2l.min()} | {self.Cm2l.mean()} | {self.Cm2l.median()} | {self.Cm2l.max()}\"\n", + " )\n", + " logger.debug(\n", + " f\"Cl2m: {self.Cl2m.min()} | {self.Cl2m.mean()} | {self.Cl2m.median()} | {self.Cl2m.max()}\"\n", + " )\n", + " logger.debug(\n", + " f\"lambd: {self.lambd.min()} | {self.lambd.mean()} | {self.lambd.median()} | {self.lambd.max()}\"\n", + " )\n", + "\n", + " def compute_helmoltz_matrices(self):\n", + " self.helmoltz_dst = compute_laplace_dst(\n", + " self.nx, self.ny, self.dx, self.dy, self.arr_kwargs\n", + " ).reshape((1, self.nx - 2, self.ny - 2)) / self.f0**2 - self.lambd.reshape(\n", + " (self.nl, 1, 1)\n", + " )\n", + " constant_field = torch.ones((self.nl, self.nx, self.ny), **self.arr_kwargs) / (\n", + " self.nx * self.ny\n", + " )\n", + " s_solutions = torch.zeros_like(constant_field)\n", + " s_solutions[:, 1:-1, 1:-1] = inverse_elliptic_dst(\n", + " constant_field[:, 1:-1, 1:-1], self.helmoltz_dst\n", + " )\n", + " self.homogeneous_sol = (\n", + " constant_field + s_solutions * self.lambd.reshape((self.nl, 1, 1))\n", + " )[\n", + " :-1\n", + " ] # ignore last solution correponding to lambd = 0, i.e. Laplace equation\n", + " if self.n_ens > 0:\n", + " self.helmoltz_dst.unsqueeze_(0), self.homogeneous_sol.unsqueeze_(0)\n", + "\n", + " def compute_alpha_matrix(self):\n", + " (Cm2l, Cl2m, hom_sol) = (\n", + " (self.Cm2l[0], self.Cl2m[0], self.homogeneous_sol[0])\n", + " if self.n_ens > 0\n", + " else (self.Cm2l, self.Cl2m, self.homogeneous_sol)\n", + " )\n", + " M = (Cm2l[1:] - Cm2l[:-1])[: self.nl - 1, : self.nl - 1] * hom_sol.mean(\n", + " (1, 2)\n", + " ).reshape((1, self.nl - 1))\n", + " M_inv = torch.linalg.inv(M)\n", + " alpha_matrix = -M_inv @ (Cm2l[1:, :-1] - Cm2l[:-1, :-1])\n", + " self.alpha_matrix = (\n", + " alpha_matrix.unsqueeze(0) if self.n_ens > 0 else alpha_matrix\n", + " )\n", + "\n", + " # def compute_q_over_f0_from_p(self):\n", + " # logger.debug(f\"Pressure --> Vorticity\")\n", + "\n", + " # Ap = (self.A @ self.p.reshape(self.p.shape[:len(self.p.shape)-2]+(-1,))).reshape(self.p.shape)\n", + " # logger.debug(f\"Ap, {Ap.shape}\")\n", + " # print_debug_quantity(Ap)\n", + " # beta_term = (self.beta / self.f0) * (self.y - self.y0)\n", + " # logger.debug(f\"Beta, {beta_term.shape}\")\n", + " # print_debug_quantity(beta_term)\n", + " # lap_term = laplacian_h(self.p, self.zfbc) / (self.f0*self.dx)**2\n", + " # logger.debug(f\"Lap, {lap_term.shape}\")\n", + " # print_debug_quantity(lap_term)\n", + " # self.q_over_f0 = lap_term - Ap + beta_term\n", + " def compute_q_over_f0_from_p(self):\n", + " Ap = (\n", + " self.A @ self.p.reshape(self.p.shape[: len(self.p.shape) - 2] + (-1,))\n", + " ).reshape(self.p.shape)\n", + "\n", + " beta_term = (self.beta / self.f0) * (self.y - self.y0)\n", + "\n", + " lap_term = laplacian_h(self.p, self.zfbc) / (self.f0 * self.dx) ** 2\n", + "\n", + " self.q_over_f0 = lap_term - Ap + beta_term\n", + "\n", + " def compute_u(self):\n", + " \"\"\"Compute velocity on staggered grid.\"\"\"\n", + " return self.grad_perp(self.p / (self.f0 * self.dx))\n", + "\n", + " def advection_rhs(self):\n", + " \"\"\"Advection diffusion RHS for vorticity, only inside domain\"\"\"\n", + " rhs = self.jac_coef * self.jacobi_h(self.q_over_f0, self.p)\n", + "\n", + " p_diff = self.p if self.p_prime is None else self.p - self.p_prime\n", + " delta2_p = self.laplacian_h(p_diff, self.zfbc)\n", + " if self.a_2 != 0.0:\n", + " rhs += self.diff_coef * self.laplacian_h_nobc(delta2_p)\n", + " if self.a_4 != 0.0:\n", + " rhs -= self.hyperdiff_coef * self.laplacian_h_nobc(\n", + " self.laplacian_h(delta2_p, self.zfbc)\n", + " )\n", + "\n", + " rhs[..., 0:1, :, :] += self.wind_forcing\n", + " rhs[..., -1:, :, :] += self.bottom_friction_coef * self.laplacian_h_nobc(\n", + " self.p[..., -1:, :, :]\n", + " )\n", + " return rhs\n", + "\n", + " def compute_time_derivatives(self):\n", + " # advect vorticity inside of the domain\n", + " self.dq_over_f0 = F.pad(self.advection_rhs(), (1, 1, 1, 1))\n", + "\n", + " # Solve helmoltz eq for pressure\n", + " rhs_helmoltz = self.matmul(self.Cl2m, self.dq_over_f0)\n", + " dp_modes = F.pad(\n", + " self.inverse_elliptic_dst(rhs_helmoltz[..., 1:-1, 1:-1], self.helmoltz_dst),\n", + " (1, 1, 1, 1),\n", + " )\n", + "\n", + " # Ensure mass conservation\n", + " dalpha = (\n", + " self.alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1)).unsqueeze(-1)\n", + " ).unsqueeze(-1)\n", + " dp_modes[..., :-1, :, :] += dalpha * self.homogeneous_sol\n", + " self.dp = self.matmul(self.Cm2l, dp_modes)\n", + "\n", + " # update voriticity on the boundaries\n", + " dp_bound = torch.cat(\n", + " [\n", + " self.dp[..., 0, 1:-1],\n", + " self.dp[..., -1, 1:-1],\n", + " self.dp[..., :, 0],\n", + " self.dp[..., :, -1],\n", + " ],\n", + " dim=-1,\n", + " )\n", + " delta_p_bound = self.laplacian_h_boundaries(\n", + " self.dp / (self.f0 * self.dx) ** 2, self.zfbc\n", + " )\n", + " dq_over_f0_bound = delta_p_bound - self.A @ dp_bound\n", + " self.dq_over_f0[..., 0, 1:-1] = dq_over_f0_bound[..., : self.ny - 2]\n", + " self.dq_over_f0[..., -1, 1:-1] = dq_over_f0_bound[\n", + " ..., self.ny - 2 : 2 * self.ny - 4\n", + " ]\n", + " self.dq_over_f0[..., 0] = dq_over_f0_bound[\n", + " ..., 2 * self.ny - 4 : self.nx + 2 * self.ny - 4\n", + " ]\n", + " self.dq_over_f0[..., -1] = dq_over_f0_bound[\n", + " ..., self.nx + 2 * self.ny - 4 : 2 * self.nx + 2 * self.ny - 4\n", + " ]\n", + "\n", + " def step(self):\n", + " \"\"\"Time itegration with Heun (RK2) scheme.\"\"\"\n", + " logger.debug(\"Starting Time Step...\")\n", + " logger.debug(f\"q_f0\")\n", + " print_debug_quantity(self.q_over_f0)\n", + " logger.debug(f\"p\")\n", + " print_debug_quantity(self.p)\n", + " logger.debug(\"Computing RHS...\")\n", + " self.compute_time_derivatives()\n", + " logger.debug(f\"dq_f0\")\n", + " print_debug_quantity(self.dq_over_f0)\n", + " logger.debug(f\"dp\")\n", + " print_debug_quantity(self.dp)\n", + " # plot_field(self.dp)\n", + " # plot_field(self.dq_over_f0)\n", + " logger.debug(\"Euler Step...\")\n", + " dq_over_f0_0, dp_0 = torch.clone(self.dq_over_f0), self.dp\n", + " self.q_over_f0 += self.dt * dq_over_f0_0\n", + " self.p += self.dt * dp_0\n", + " # plot_field(self.p)\n", + " # plot_field(self.q_over_f0)\n", + " logger.debug(f\"q_f0\")\n", + " print_debug_quantity(self.q_over_f0)\n", + " logger.debug(f\"p\")\n", + " print_debug_quantity(self.p)\n", + "\n", + " logger.debug(\"Computing RHS...\")\n", + " self.compute_time_derivatives()\n", + " logger.debug(f\"dq_f0\")\n", + " print_debug_quantity(self.dq_over_f0)\n", + " logger.debug(f\"dp\")\n", + " print_debug_quantity(self.dp)\n", + " logger.debug(\"RK2 Step...\")\n", + " self.q_over_f0 += self.dt * 0.5 * (self.dq_over_f0 - dq_over_f0_0)\n", + " self.p += self.dt * 0.5 * (self.dp - dp_0)\n", + " logger.debug(f\"q_f0\")\n", + " print_debug_quantity(self.q_over_f0)\n", + " logger.debug(f\"p\")\n", + " print_debug_quantity(self.p)\n", + " # plot_field(self.p)\n", + " # plot_field(self.q_over_f0)\n", + "\n", + " # def step(self):\n", + " # \"\"\" Time itegration with Heun (RK2) scheme.\"\"\"\n", + "\n", + " # self.compute_time_derivatives()\n", + "\n", + " # dq_over_f0_0, dp_0 = torch.clone(self.dq_over_f0), self.dp\n", + " # self.q_over_f0 += self.dt * dq_over_f0_0\n", + " # self.p += self.dt * dp_0\n", + " # # plot_field(self.p)\n", + " # # plot_field(self.q_over_f0)\n", + "\n", + " # self.compute_time_derivatives()\n", + "\n", + " # self.q_over_f0 += self.dt * 0.5 * (self.dq_over_f0 - dq_over_f0_0)\n", + " # self.p += self.dt * 0.5 * (self.dp - dp_0)\n", + " # # plot_field(self.p)\n", + " # # plot_field(self.q_over_f0)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 11:31:24.774\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m2\u001b[0m - \u001b[34m\u001b[1mPressure --> Vorticity\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.775\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m3\u001b[0m - \u001b[34m\u001b[1mtensor([[ 0.1143, -0.1143, 0.0000],\n", + " [-0.0533, 0.1600, -0.1067],\n", + " [ 0.0000, -0.0276, 0.0276]], dtype=torch.float64)\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.780\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m4\u001b[0m - \u001b[34m\u001b[1mtorch.Size([3, 3]) | torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.785\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m7\u001b[0m - \u001b[34m\u001b[1mAp, torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.792\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.339362 | 0.000000 | -0.000046 | 0.313386\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.804\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m10\u001b[0m - \u001b[34m\u001b[1mBeta, torch.Size([97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.806\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.449024 | 0.000000 | 0.000000 | 0.449024\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.813\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m13\u001b[0m - \u001b[34m\u001b[1mLap, torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:31:24.815\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.202842 | -0.000007 | 0.000050 | 0.272714\u001b[0m\n" + ] + } + ], + "source": [ + "def compute_q_over_f0_from_p(model):\n", + " logger.debug(f\"Pressure --> Vorticity\")\n", + " logger.debug(model.A)\n", + " logger.debug(f\"{model.A.shape} | {model.p.shape}\")\n", + "\n", + " Ap = (\n", + " model.A @ model.p.reshape(model.p.shape[: len(model.p.shape) - 2] + (-1,))\n", + " ).reshape(model.p.shape)\n", + " logger.debug(f\"Ap, {Ap.shape}\")\n", + " print_debug_quantity(Ap)\n", + " beta_term = (model.beta / model.f0) * (model.y - model.y0)\n", + " logger.debug(f\"Beta, {beta_term.shape}\")\n", + " print_debug_quantity(beta_term)\n", + " lap_term = laplacian_h(model.p, model.zfbc) / (model.f0 * model.dx) ** 2\n", + " logger.debug(f\"Lap, {lap_term.shape}\")\n", + " print_debug_quantity(lap_term)\n", + " model.q_over_f0 = lap_term - Ap + beta_term\n", + " return model\n", + "\n", + "\n", + "qg_multilayer.p = torch.from_numpy(\n", + " np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True)\n", + ").to(param[\"device\"])\n", + "qg_multilayer = compute_q_over_f0_from_p(qg_multilayer)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 11:22:28.963\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_A_matrix\u001b[0m:\u001b[36m201\u001b[0m - \u001b[34m\u001b[1mA Matrix Created\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.964\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m216\u001b[0m - \u001b[34m\u001b[1mLayer Mode Matrices\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.965\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m217\u001b[0m - \u001b[34m\u001b[1mCm2l: -0.7026014573788518 | 0.32076057894566734 | 0.5773502691896256 | 0.9239601865397017\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.966\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m218\u001b[0m - \u001b[34m\u001b[1mCl2m: -1.1589202915082626 | 0.1924500897298752 | 0.43193137742638776 | 1.255736835487436\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.967\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m219\u001b[0m - \u001b[34m\u001b[1mlambd: -3.532991270468018e-18 | 0.100623973727422 | 0.07368821446433749 | 0.22818370671792854\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.984\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m2\u001b[0m - \u001b[34m\u001b[1mPressure --> Vorticity\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.984\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m5\u001b[0m - \u001b[34m\u001b[1mAp, torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.985\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.339362 | 0.000000 | -0.000046 | 0.313386\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.985\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m8\u001b[0m - \u001b[34m\u001b[1mBeta, torch.Size([97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.986\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.449024 | 0.000000 | 0.000000 | 0.449024\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.987\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m11\u001b[0m - \u001b[34m\u001b[1mLap, torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:22:28.987\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.202842 | -0.000007 | 0.000050 | 0.272714\u001b[0m\n" + ] + } + ], + "source": [ + "param = {\n", + " # 'nx': 769, # HR\n", + " # 'ny': 961, # HR\n", + " \"nx\": 97, # LR\n", + " \"ny\": 121, # LR\n", + " \"Lx\": 3840.0e3, # Length in the x direction (m)\n", + " \"Ly\": 4800.0e3, # Length in the y direction (m)\n", + " \"nl\": 3, # number of layers\n", + " \"heights\": [350.0, 750.0, 2900.0], # heights between layers (m)\n", + " \"reduced_gravities\": [0.025, 0.0125], # reduced gravity numbers (m/s^2)\n", + " \"f0\": 9.375e-5, # coriolis (s^-1)\n", + " \"a_2\": 0.0, # laplacian diffusion coef (m^2/s)\n", + " # 'a_4': 2.0e9, # HR\n", + " \"a_4\": 5.0e11, # LR\n", + " \"beta\": 1.754e-11, # coriolis gradient (m^-1 s^-1)\n", + " \"delta_ek\": 2.0, # eckman height (m)\n", + " # 'dt': 600., # HR\n", + " \"dt\": 1200.0, # LR\n", + " \"bcco\": 0.2, # boundary condition coef. (non-dim.)\n", + " \"tau0\": 2.0e-5, # wind stress magnitude m/s^2\n", + " \"n_ens\": 0, # 0 for no ensemble,\n", + " \"device\": \"cpu\", # torch only, 'cuda' or 'cpu'\n", + " \"p_prime\": \"\",\n", + "}\n", + "\n", + "import time\n", + "\n", + "qg_multilayer = QGM(param)\n", + "\n", + "logger.add(\n", + " sys.stderr, format=\"{time} {level} {message}\", filter=\"my_module\", level=\"INFO\"\n", + ")\n", + "\n", + "# if param['nx'] == 97:\n", + "# qg_multilayer.p = torch.from_numpy(np.load('./p_380yrs_HRDS.npy', allow_pickle=True)).to(param['device'])\n", + "qg_multilayer.p = torch.from_numpy(\n", + " np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True)\n", + ").to(param[\"device\"])\n", + "qg_multilayer = compute_q_over_f0_from_p(qg_multilayer)\n", + "\n", + "# qg_multilayer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 11:34:07.148\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_A_matrix\u001b[0m:\u001b[36m201\u001b[0m - \u001b[34m\u001b[1mA Matrix Created\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.162\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m216\u001b[0m - \u001b[34m\u001b[1mLayer Mode Matrices\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.165\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m217\u001b[0m - \u001b[34m\u001b[1mCm2l: -0.7026014573788518 | 0.32076057894566734 | 0.5773502691896256 | 0.9239601865397017\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.168\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m218\u001b[0m - \u001b[34m\u001b[1mCl2m: -1.1589202915082626 | 0.1924500897298752 | 0.43193137742638776 | 1.255736835487436\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.176\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_layer_to_mode_matrices\u001b[0m:\u001b[36m219\u001b[0m - \u001b[34m\u001b[1mlambd: -3.532991270468018e-18 | 0.100623973727422 | 0.07368821446433749 | 0.22818370671792854\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.210\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m2\u001b[0m - \u001b[34m\u001b[1mPressure --> Vorticity\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.210\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m3\u001b[0m - \u001b[34m\u001b[1mtensor([[ 0.1143, -0.1143, 0.0000],\n", + " [-0.0533, 0.1600, -0.1067],\n", + " [ 0.0000, -0.0276, 0.0276]], dtype=torch.float64)\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.214\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m4\u001b[0m - \u001b[34m\u001b[1mtorch.Size([3, 3]) | torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.216\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m7\u001b[0m - \u001b[34m\u001b[1mAp, torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.221\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.339362 | 0.000000 | -0.000046 | 0.313386\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.222\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m10\u001b[0m - \u001b[34m\u001b[1mBeta, torch.Size([97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.223\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.449024 | 0.000000 | 0.000000 | 0.449024\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.228\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mcompute_q_over_f0_from_p\u001b[0m:\u001b[36m13\u001b[0m - \u001b[34m\u001b[1mLap, torch.Size([3, 97, 121])\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.230\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.202842 | -0.000007 | 0.000050 | 0.272714\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.237\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.239\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.242\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465720 | -0.000007 | -0.002770 | 0.496363\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.243\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.246\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.332182 | 0.033356 | 0.030413 | 3.561408\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.247\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.257\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.259\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000002 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.260\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.263\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.264\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.267\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.268\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465696 | -0.000007 | -0.002770 | 0.496099\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.269\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.271\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.331482 | 0.033391 | 0.030441 | 3.560798\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.271\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.275\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.276\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.277\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.278\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.278\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.279\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.280\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465696 | -0.000007 | -0.002770 | 0.496099\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.281\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.283\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.331483 | 0.033391 | 0.030441 | 3.560799\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.285\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 1200.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.308\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465696 | -0.000007 | -0.002770 | 0.496099\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.328\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.331483 | 0.033391 | 0.030441 | 3.560799\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.330\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.332\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.354\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465696 | -0.000007 | -0.002770 | 0.496099\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.357\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.361\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.331483 | 0.033391 | 0.030441 | 3.560799\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.362\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.391\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.398\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.401\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.407\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.408\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.411\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.413\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465672 | -0.000007 | -0.002747 | 0.495836\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.420\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.424\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330784 | 0.033427 | 0.030535 | 3.560191\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.425\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.479\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.481\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.482\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.491\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.493\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.495\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.499\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465672 | -0.000007 | -0.002747 | 0.495836\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.499\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.501\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330784 | 0.033426 | 0.030535 | 3.560192\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.501\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 2400.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.502\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465672 | -0.000007 | -0.002747 | 0.495836\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.503\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330784 | 0.033426 | 0.030535 | 3.560192\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.504\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.505\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.506\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465672 | -0.000007 | -0.002747 | 0.495836\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.507\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.508\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330784 | 0.033426 | 0.030535 | 3.560192\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.508\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.513\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.514\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.515\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.516\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.517\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.518\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.519\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465648 | -0.000007 | -0.002729 | 0.495574\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.519\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.520\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330087 | 0.033462 | 0.030630 | 3.559586\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.520\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.525\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.527\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.527\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.529\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.529\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.531\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.532\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465648 | -0.000007 | -0.002729 | 0.495574\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.533\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.534\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330087 | 0.033462 | 0.030630 | 3.559587\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.534\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 3600.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.535\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465648 | -0.000007 | -0.002729 | 0.495574\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.536\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330087 | 0.033462 | 0.030630 | 3.559587\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.536\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.536\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.537\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465648 | -0.000007 | -0.002729 | 0.495574\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.537\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.541\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.330087 | 0.033462 | 0.030630 | 3.559587\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.541\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.546\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.547\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.547\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.548\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.548\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.549\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.550\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465624 | -0.000007 | -0.002719 | 0.495313\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.550\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.551\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.329391 | 0.033497 | 0.030687 | 3.558983\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.551\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.556\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.557\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.557\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.559\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.560\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.561\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.562\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465625 | -0.000007 | -0.002719 | 0.495313\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.562\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.563\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.329392 | 0.033497 | 0.030687 | 3.558984\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.564\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 4800.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.565\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465625 | -0.000007 | -0.002719 | 0.495313\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.565\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.329392 | 0.033497 | 0.030687 | 3.558984\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.566\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.566\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.567\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465625 | -0.000007 | -0.002719 | 0.495313\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.567\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.568\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.329392 | 0.033497 | 0.030687 | 3.558984\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.568\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.572\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.573\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.574\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.575\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.575\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.576\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.577\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465601 | -0.000007 | -0.002727 | 0.495052\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.577\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.579\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328696 | 0.033532 | 0.030687 | 3.558381\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.579\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.583\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.584\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.584\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.586\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.587\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.589\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.590\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465601 | -0.000007 | -0.002727 | 0.495052\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.590\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.592\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328697 | 0.033532 | 0.030687 | 3.558382\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.592\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 6000.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.593\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465601 | -0.000007 | -0.002727 | 0.495052\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.594\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328697 | 0.033532 | 0.030687 | 3.558382\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.594\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.595\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.596\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465601 | -0.000007 | -0.002727 | 0.495052\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.597\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.599\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328697 | 0.033532 | 0.030687 | 3.558382\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.600\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.612\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.616\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.617\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.618\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.619\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.622\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.627\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465577 | -0.000007 | -0.002730 | 0.494792\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.628\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.629\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328003 | 0.033567 | 0.030632 | 3.557782\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.633\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.645\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.648\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.649\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.650\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.651\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.654\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.656\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465577 | -0.000007 | -0.002730 | 0.494792\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.657\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.658\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328003 | 0.033566 | 0.030632 | 3.557782\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.659\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 7200.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.660\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465577 | -0.000007 | -0.002730 | 0.494792\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.661\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328003 | 0.033566 | 0.030632 | 3.557782\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.662\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.662\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.663\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465577 | -0.000007 | -0.002730 | 0.494792\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.664\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.671\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.328003 | 0.033566 | 0.030632 | 3.557782\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.674\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.714\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.715\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.717\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.718\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.719\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.720\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.721\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465554 | -0.000007 | -0.002736 | 0.494532\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.722\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.723\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.327310 | 0.033601 | 0.030675 | 3.557183\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.724\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.729\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.730\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.731\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.732\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.732\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.733\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.734\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465554 | -0.000007 | -0.002736 | 0.494532\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.735\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.736\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.327311 | 0.033601 | 0.030675 | 3.557184\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.736\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 8400.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.738\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465554 | -0.000007 | -0.002736 | 0.494532\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.739\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.327311 | 0.033601 | 0.030675 | 3.557184\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.740\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.740\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.741\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465554 | -0.000007 | -0.002736 | 0.494532\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.742\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.743\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.327311 | 0.033601 | 0.030675 | 3.557184\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.744\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.749\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.750\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.750\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.752\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.752\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.754\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.754\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465531 | -0.000007 | -0.002738 | 0.494273\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.755\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.756\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.326619 | 0.033636 | 0.030790 | 3.556587\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.758\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.765\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.767\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.768\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.769\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.770\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.772\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.773\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465531 | -0.000007 | -0.002738 | 0.494274\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.773\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.775\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.326620 | 0.033636 | 0.030790 | 3.556588\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.775\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 9600.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.776\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465531 | -0.000007 | -0.002738 | 0.494274\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.777\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.326620 | 0.033636 | 0.030790 | 3.556588\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.778\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.778\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.780\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465531 | -0.000007 | -0.002738 | 0.494274\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.781\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.783\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.326620 | 0.033636 | 0.030790 | 3.556588\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.784\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.792\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.793\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.794\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.795\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.795\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.796\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.797\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465507 | -0.000007 | -0.002744 | 0.494015\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.797\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.798\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325929 | 0.033671 | 0.030743 | 3.555992\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.799\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.805\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.815\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.822\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.865\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.865\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.866\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.867\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465507 | -0.000007 | -0.002744 | 0.494015\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.867\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.868\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325930 | 0.033671 | 0.030743 | 3.555993\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.872\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 10800.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.875\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465507 | -0.000007 | -0.002744 | 0.494015\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.878\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325930 | 0.033671 | 0.030743 | 3.555993\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.878\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m311\u001b[0m - \u001b[34m\u001b[1mStarting Time Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.879\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m312\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.880\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465507 | -0.000007 | -0.002744 | 0.494015\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.880\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m314\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.882\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325930 | 0.033671 | 0.030743 | 3.555993\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.882\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m316\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.901\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m318\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.903\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.903\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m320\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.905\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.905\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m324\u001b[0m - \u001b[34m\u001b[1mEuler Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.906\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m330\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.907\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465484 | -0.000007 | -0.002748 | 0.493757\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.907\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m332\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.908\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325241 | 0.033705 | 0.030814 | 3.555399\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.909\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m335\u001b[0m - \u001b[34m\u001b[1mComputing RHS...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.913\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m337\u001b[0m - \u001b[34m\u001b[1mdq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.914\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000001 | -0.000000 | -0.000000 | 0.000001\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.915\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m339\u001b[0m - \u001b[34m\u001b[1mdp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.916\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.000005 | 0.000000 | 0.000000 | 0.000005\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.917\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m341\u001b[0m - \u001b[34m\u001b[1mRK2 Step...\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.919\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m344\u001b[0m - \u001b[34m\u001b[1mq_f0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.920\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465484 | -0.000007 | -0.002748 | 0.493758\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.920\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mstep\u001b[0m:\u001b[36m346\u001b[0m - \u001b[34m\u001b[1mp\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.922\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325241 | 0.033705 | 0.030814 | 3.555399\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.922\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36m\u001b[0m:\u001b[36m46\u001b[0m - \u001b[34m\u001b[1mTime Step: 12000.0\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.923\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-0.465484 | -0.000007 | -0.002748 | 0.493758\u001b[0m\n", + "\u001b[32m2023-07-11 11:34:07.925\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m-4.325241 | 0.033705 | 0.030814 | 3.555399\u001b[0m\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "qg_multilayer = QGM(param)\n", + "\n", + "logger.add(\n", + " sys.stderr, format=\"{time} {level} {message}\", filter=\"my_module\", level=\"INFO\"\n", + ")\n", + "\n", + "# if param['nx'] == 97:\n", + "# qg_multilayer.p = torch.from_numpy(np.load('./p_380yrs_HRDS.npy', allow_pickle=True)).to(param['device'])\n", + "qg_multilayer.p = torch.from_numpy(\n", + " np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True)\n", + ").to(param[\"device\"])\n", + "qg_multilayer = compute_q_over_f0_from_p(qg_multilayer)\n", + "\n", + "# time params\n", + "dt = param[\"dt\"]\n", + "t = 0\n", + "\n", + "freq_plot = 50_000 # LR\n", + "# freq_plot = 50 # HR\n", + "freq_checknan = 100\n", + "freq_log = 1000\n", + "n_years = 2\n", + "n_steps = int(n_years * 365 * 24 * 3600 / dt)\n", + "\n", + "# if freq_plot > 0:\n", + "# import matplotlib.pyplot as plt\n", + "# plt.ion()\n", + "# plt.figure()\n", + "# f,a = plt.subplots(1,2)\n", + "# u = (qg_multilayer.compute_u()[0]).cpu().numpy()\n", + "# um, uM = -1.1*np.abs(u).max(), 1.1*np.abs(u).max()\n", + "# im = a[0].imshow(u[0].T, cmap='bwr', origin='lower', vmin=um, vmax=uM, animated=True)\n", + "# a[0].set_title('zonal velocity')\n", + "# f.colorbar(im, ax=a[0])\n", + "# q = (qg_multilayer.q_over_f0*qg_multilayer.f0).cpu().numpy()\n", + "# qm, qM = -1.1*np.abs(q).max(), 1.1*np.abs(q).max()\n", + "# im = a[1].imshow(q[0].T, cmap='bwr', origin='lower', vmin=qm, vmax=qM, animated=True)\n", + "# a[1].set_title('potential vorticity')\n", + "# f.colorbar(im, ax=a[1])\n", + "# plt.pause(5)\n", + "\n", + "# times, outputs = [], []\n", + "\n", + "\n", + "t0 = time.time()\n", + "for n in range(1, n_steps + 1):\n", + " qg_multilayer.step()\n", + " t += dt\n", + " logger.debug(f\"Time Step: {t}\")\n", + " print_debug_quantity(qg_multilayer.q_over_f0)\n", + " print_debug_quantity(qg_multilayer.p)\n", + "\n", + " if n % freq_checknan == 0 and torch.isnan(qg_multilayer.p).any():\n", + " raise ValueError(\"Stopping, NAN number in p at iteration {n}.\")\n", + "\n", + " if n == 10:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# time params\n", + "dt = param[\"dt\"]\n", + "t = 0\n", + "\n", + "freq_plot = 50_000 # LR\n", + "# freq_plot = 50 # HR\n", + "freq_checknan = 10000\n", + "freq_log = 1000\n", + "n_years = 2\n", + "n_steps = int(n_years * 365 * 24 * 3600 / dt)\n", + "\n", + "if freq_plot > 0:\n", + " import matplotlib.pyplot as plt\n", + "\n", + " plt.ion()\n", + " plt.figure()\n", + " f, a = plt.subplots(1, 2)\n", + " u = (qg_multilayer.compute_u()[0]).cpu().numpy()\n", + " um, uM = -1.1 * np.abs(u).max(), 1.1 * np.abs(u).max()\n", + " im = a[0].imshow(\n", + " u[0].T, cmap=\"bwr\", origin=\"lower\", vmin=um, vmax=uM, animated=True\n", + " )\n", + " a[0].set_title(\"zonal velocity\")\n", + " f.colorbar(im, ax=a[0])\n", + " q = (qg_multilayer.q_over_f0 * qg_multilayer.f0).cpu().numpy()\n", + " qm, qM = -1.1 * np.abs(q).max(), 1.1 * np.abs(q).max()\n", + " im = a[1].imshow(\n", + " q[0].T, cmap=\"bwr\", origin=\"lower\", vmin=qm, vmax=qM, animated=True\n", + " )\n", + " a[1].set_title(\"potential vorticity\")\n", + " f.colorbar(im, ax=a[1])\n", + " plt.pause(5)\n", + "\n", + "times, outputs = [], []\n", + "\n", + "\n", + "t0 = time.time()\n", + "for n in range(1, n_steps + 1):\n", + " qg_multilayer.step()\n", + " t += dt\n", + "\n", + " if n % freq_checknan == 0 and torch.isnan(qg_multilayer.p).any():\n", + " raise ValueError(\"Stopping, NAN number in p at iteration {n}.\")\n", + "\n", + " if freq_plot > 0 and n % freq_plot == 0:\n", + " u = (qg_multilayer.compute_u()[0]).cpu().numpy()\n", + " a[0].imshow(u[0].T, cmap=\"bwr\", origin=\"lower\", vmin=um, vmax=uM, animated=True)\n", + " q = (qg_multilayer.q_over_f0 * qg_multilayer.f0).cpu().numpy()\n", + " a[1].imshow(q[0].T, cmap=\"bwr\", origin=\"lower\", vmin=qm, vmax=qM, animated=True)\n", + " plt.suptitle(f\"t={t/(365*24*3600):.2f} years.\")\n", + " plt.pause(0.1)\n", + "\n", + " if freq_log > 0 and n % freq_log == 0:\n", + " q, p = (\n", + " qg_multilayer.f0 * qg_multilayer.q_over_f0\n", + " ).cpu().numpy(), qg_multilayer.p.cpu().numpy()\n", + " print(\n", + " f\"{n=:06d}, t={t/(365*24*60**2):.2f} yr, \"\n", + " f\"p: ({p.mean():+.1E}, {np.abs(p).mean():.6E}), \"\n", + " f\"q: ({q.mean():+.1E}, {np.abs(q).mean():.6E}).\"\n", + " )\n", + "print(100 * (time.time() - t0) / (60 * 60))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/dev/eman/QG/qg_louis_refactored.ipynb b/notebooks/dev/eman/QG/qg_louis_refactored.ipynb new file mode 100644 index 0000000..42eaf3b --- /dev/null +++ b/notebooks/dev/eman/QG/qg_louis_refactored.ipynb @@ -0,0 +1,1782 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "# Multi-Layer Quasi-Geostrophic Equations" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "import torch.nn.functional as F\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=0.7)\n", + "from loguru import logger\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_field(field):\n", + " num_axis = len(field)\n", + " fig, ax = plt.subplots(ncols=num_axis, figsize=(8, 3))\n", + "\n", + " for i in range(num_axis):\n", + " pts = ax[i].pcolormesh(field[i].cpu().numpy(), cmap=\"coolwarm\")\n", + " plt.colorbar(pts)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def print_debug_quantity(quantity, name=\"\"):\n", + " logger.debug(\n", + " f\"{name}: {quantity.shape} | {quantity.min():.6e} | {quantity.mean():.6e} | {quantity.median():.6e} | {quantity.max():.6e}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " # 'nx': 769, # HR\n", + " # 'ny': 961, # HR\n", + " \"nx\": 97, # LR\n", + " \"ny\": 121, # LR\n", + " \"Lx\": 3840.0e3, # Length in the x direction (m)\n", + " \"Ly\": 4800.0e3, # Length in the y direction (m)\n", + " \"nl\": 3, # number of layers\n", + " \"heights\": [350.0, 750.0, 2900.0], # heights between layers (m)\n", + " \"reduced_gravities\": [0.025, 0.0125], # reduced gravity numbers (m/s^2)\n", + " \"f0\": 9.375e-5, # coriolis (s^-1)\n", + " \"a_2\": 0.0, # laplacian diffusion coef (m^2/s)\n", + " # 'a_4': 2.0e9, # HR\n", + " \"a_4\": 5.0e11, # LR\n", + " \"beta\": 1.754e-11, # coriolis gradient (m^-1 s^-1)\n", + " \"delta_ek\": 2.0, # eckman height (m)\n", + " # 'dt': 600., # HR\n", + " \"dt\": 1200.0, # LR\n", + " \"bcco\": 0.2, # boundary condition coef. (non-dim.)\n", + " \"tau0\": 2.0e-5, # wind stress magnitude m/s^2\n", + " \"n_ens\": 0, # 0 for no ensemble,\n", + " \"device\": \"cpu\", # torch only, 'cuda' or 'cpu'\n", + " \"p_prime\": \"\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2400000.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "4800.0e3 / 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import typing as tp\n", + "\n", + "\n", + "class PDEParams(tp.NamedTuple):\n", + " f0: float = 9.375e-5 # coriolis (s^-1)\n", + " beta: float = 1.754e-11 # coriolis gradient (m^-1 s^-1)\n", + " tau0: float = 2.0e-5 # wind stress magnitude m/s^2\n", + " y0: float = 2400000.0 # m\n", + " a_2: float = 0.0 # laplacian diffusion coef (m^2/s)\n", + " a_4: float = 5.0e11 # LR # 2.0e9 # HR\n", + " bcco: float = 0.2 # boundary condition coef. (non-dim.)\n", + " delta_ek: float = 2.0 # eckman height (m)\n", + "\n", + " @property\n", + " def zfbc(self):\n", + " return self.bcco / (1.0 + 0.5 * self.bcco)\n", + "\n", + "\n", + "pde_params = PDEParams()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import typing as tp" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import functools as ft\n", + "from dataclasses import dataclass\n", + "\n", + "\n", + "@dataclass\n", + "class Domain:\n", + " nx: int\n", + " ny: int\n", + " Lx: int\n", + " Ly: int\n", + " dx: float\n", + " dy: float\n", + " x: torch.FloatTensor\n", + " y: torch.FloatTensor\n", + "\n", + " def __init__(self, nx, ny, Lx, Ly):\n", + " self.Lx = Lx\n", + " self.Ly = Ly\n", + " self.nx = nx\n", + " self.ny = ny\n", + " self.dx = Lx / (nx - 1)\n", + " self.dy = Ly / (ny - 1)\n", + "\n", + " X = torch.linspace(0, Lx, nx)\n", + " Y = torch.linspace(0, Ly, ny)\n", + " self.x, self.y = torch.meshgrid(X, Y, indexing=\"ij\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "40000.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "domain = Domain(nx=params[\"nx\"], ny=params[\"ny\"], Lx=params[\"Lx\"], Ly=params[\"Ly\"])\n", + "domain.dx" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Compute A Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "class HeightParams(tp.NamedTuple):\n", + " heights: tp.List[float]\n", + " reduced_gravities: tp.List[float]\n", + " num_layers: int" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "height_params = HeightParams(\n", + " heights=params[\"heights\"],\n", + " reduced_gravities=params[\"reduced_gravities\"],\n", + " num_layers=params[\"nl\"],\n", + ")\n", + "\n", + "# num_layers = params[\"nl\"]\n", + "# reduced_gravities = params[\"reduced_gravities\"]\n", + "# heights = params[\"heights\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_A_matrix(params: HeightParams):\n", + " assert len(params.heights) - 1 == len(params.reduced_gravities)\n", + " A = torch.zeros((params.num_layers, params.num_layers))\n", + " A[0, 0] = 1.0 / (params.heights[0] * params.reduced_gravities[0])\n", + " A[0, 1] = -1.0 / (params.heights[0] * params.reduced_gravities[0])\n", + " for i in range(1, params.num_layers - 1):\n", + " A[i, i - 1] = -1.0 / (params.heights[i] * params.reduced_gravities[i - 1])\n", + " A[i, i] = (\n", + " 1.0\n", + " / params.heights[i]\n", + " * (1 / params.reduced_gravities[i] + 1 / params.reduced_gravities[i - 1])\n", + " )\n", + " A[i, i + 1] = -1.0 / (params.heights[i] * params.reduced_gravities[i])\n", + " A[-1, -1] = 1.0 / (\n", + " params.heights[params.num_layers - 1]\n", + " * params.reduced_gravities[params.num_layers - 2]\n", + " )\n", + " A[-1, -2] = -1.0 / (\n", + " params.heights[params.num_layers - 1]\n", + " * params.reduced_gravities[params.num_layers - 2]\n", + " )\n", + " return A.type(torch.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "HeightParams(heights=[350.0, 750.0, 2900.0], reduced_gravities=[0.025, 0.0125], num_layers=3)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "height_params" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.1143, -0.1143, 0.0000],\n", + " [-0.0533, 0.1600, -0.1067],\n", + " [ 0.0000, -0.0276, 0.0276]], dtype=torch.float64)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = calculate_A_matrix(height_params)\n", + "A" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Calculate Layer To Mode Matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_layer_to_mode_matrices(A):\n", + " lambd_r, R = torch.linalg.eig(A)\n", + " _, L = torch.linalg.eig(A.T)\n", + " lambd = lambd_r.real\n", + " R, L = R.real, L.real\n", + " Cl2m = torch.diag(1.0 / torch.diag(L.T @ R)) @ L.T\n", + "\n", + " return lambd, Cl2m, R" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "@dataclass\n", + "class AMatrices:\n", + " A: torch.Tensor\n", + " lambd: torch.Tensor\n", + " Cl2m: torch.Tensor\n", + " Cm2l: torch.Tensor\n", + "\n", + " def __init__(self, A):\n", + " self.A = A\n", + " self.lambd, self.Cl2m, self.Cm2l = compute_layer_to_mode_matrices(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[-0.4319, 0.9224, -0.4905],\n", + " [-0.6580, -0.5009, 1.1589],\n", + " [ 0.1516, 0.3248, 1.2557]], dtype=torch.float64),\n", + " tensor([[-0.7050, -0.9240, 0.5774],\n", + " [ 0.7026, -0.3282, 0.5774],\n", + " [-0.0966, 0.1964, 0.5774]], dtype=torch.float64))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A_matrices = AMatrices(A=A)\n", + "A_matrices.Cl2m, A_matrices.Cm2l" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### HelmHoltz Matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "## functions to solve elliptic equation with homogeneous boundary conditions\n", + "def compute_laplace_dst(nx, ny, dx, dy, **kwargs):\n", + " \"\"\"Discrete sine transform of the 2D centered discrete laplacian\n", + " operator.\"\"\"\n", + " x, y = torch.meshgrid(\n", + " torch.arange(1, nx - 1, **kwargs),\n", + " torch.arange(1, ny - 1, **kwargs),\n", + " indexing=\"ij\",\n", + " )\n", + " return (\n", + " 2 * (torch.cos(torch.pi / (nx - 1) * x) - 1) / dx**2\n", + " + 2 * (torch.cos(torch.pi / (ny - 1) * y) - 1) / dy**2\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:19:18.914\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([95, 119]) | -5.687640e-01 | -2.844445e-01 | -2.844444e-01 | -1.248847e-04\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:18.918\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([95, 119]) | -7.969477e-01 | -5.126281e-01 | -5.126281e-01 | -2.283086e-01\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:18.920\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([95, 119]) | -6.424522e-01 | -3.581327e-01 | -3.581326e-01 | -7.381310e-02\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:18.921\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([95, 119]) | -5.687640e-01 | -2.844444e-01 | -2.844444e-01 | -1.248833e-04\u001b[0m\n" + ] + } + ], + "source": [ + "lap_dst = (\n", + " compute_laplace_dst(domain.nx, domain.ny, domain.dx, domain.dy) / params[\"f0\"] ** 2\n", + ")\n", + "print_debug_quantity(lap_dst)\n", + "\n", + "helmoltz_dst = lap_dst.reshape(\n", + " (1, domain.nx - 2, domain.ny - 2)\n", + ") - A_matrices.lambd.reshape((height_params.num_layers, 1, 1))\n", + "print_debug_quantity(helmoltz_dst[0])\n", + "print_debug_quantity(helmoltz_dst[1])\n", + "print_debug_quantity(helmoltz_dst[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(helmoltz_dst)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Inversion Scheme" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def dstI1D(x, norm=\"ortho\"):\n", + " \"\"\"1D type-I discrete sine transform.\"\"\"\n", + " return torch.fft.irfft(-1j * F.pad(x, (1, 1)), dim=-1, norm=norm)[\n", + " ..., 1 : x.shape[-1] + 1\n", + " ]\n", + "\n", + "\n", + "def dstI2D(x, norm=\"ortho\"):\n", + " \"\"\"2D type-I discrete sine transform.\"\"\"\n", + " return dstI1D(dstI1D(x, norm=norm).transpose(-1, -2), norm=norm).transpose(-1, -2)\n", + "\n", + "\n", + "def inverse_elliptic_dst(f, operator_dst):\n", + " \"\"\"Inverse elliptic operator (e.g. Laplace, Helmoltz)\n", + " using float32 discrete sine transform.\"\"\"\n", + " # return dstI2D((dstI2D(f.type(torch.float32)) / operator_dst).type(torch.float64))\n", + " return dstI2D(dstI2D(f.type(torch.float32)) / operator_dst).type(torch.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:19:24.262\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([3, 97, 121]) | 8.520065e-05 | 8.520065e-05 | 8.520065e-05 | 8.520065e-05\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:24.275\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([97, 121]) | -3.733863e-04 | -3.562605e-04 | -3.733862e-04 | 0.000000e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:24.276\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([97, 121]) | -1.156232e-03 | -1.088502e-03 | -1.156231e-03 | 0.000000e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:24.277\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([97, 121]) | -9.883048e-01 | -4.651709e-01 | -4.557938e-01 | 0.000000e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:24.282\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([2, 97, 121]) | -1.704109e-11 | 4.449327e-06 | 1.451378e-11 | 8.520065e-05\u001b[0m\n" + ] + } + ], + "source": [ + "def calculate_homogeneous_sol(domain, helmoltz_dst, lambd):\n", + " nl = helmoltz_dst.shape[0]\n", + "\n", + " # calculate constant field\n", + " constant_field = torch.ones((nl, domain.nx, domain.ny)) / (domain.nx * domain.ny)\n", + " print_debug_quantity(constant_field)\n", + "\n", + " # get solutions to inversion\n", + " s_solutions = torch.zeros_like(constant_field)\n", + " s_solutions[:, 1:-1, 1:-1] = inverse_elliptic_dst(\n", + " constant_field[:, 1:-1, 1:-1], helmoltz_dst\n", + " )\n", + " print_debug_quantity(s_solutions[0])\n", + " print_debug_quantity(s_solutions[1])\n", + " print_debug_quantity(s_solutions[2])\n", + "\n", + " # ignore last solution correponding to lambd = 0, i.e. Laplace equation\n", + " homogeneous_sol = (\n", + " constant_field + s_solutions * lambd.reshape((params[\"nl\"], 1, 1))\n", + " )[:-1]\n", + "\n", + " return homogeneous_sol\n", + "\n", + "\n", + "homogeneous_sol = calculate_homogeneous_sol(\n", + " domain, helmoltz_dst, lambd=A_matrices.lambd\n", + ")\n", + "\n", + "print_debug_quantity(homogeneous_sol)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(homogeneous_sol)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Alpha Matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:19:26.060\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([3, 3]) | -9.239602e-01 | 6.413960e-02 | 1.963961e-01 | 7.026015e-01\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:26.062\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([2, 97, 121]) | -1.704109e-11 | 4.449327e-06 | 1.451378e-11 | 8.520065e-05\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:26.065\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([2, 2]) | -3.123218e-06 | 1.992230e-06 | 2.618256e-06 | 5.500621e-06\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:26.079\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([2, 2]) | -1.255166e+05 | 8.726757e+04 | 1.105301e+05 | 2.322096e+05\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:26.082\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1m: torch.Size([2, 2]) | -2.558974e+05 | -1.140661e+05 | -2.003672e+05 | 1.455192e-11\u001b[0m\n" + ] + } + ], + "source": [ + "def compute_alpha_matrices(Cm2l, homogeneous_sol):\n", + " num_layers = len(Cm2l)\n", + " print_debug_quantity(Cm2l)\n", + " print_debug_quantity(homogeneous_sol)\n", + " M = (Cm2l[1:] - Cm2l[:-1])[\n", + " : num_layers - 1, : num_layers - 1\n", + " ] * homogeneous_sol.mean((1, 2)).reshape((1, num_layers - 1))\n", + " print_debug_quantity(M)\n", + " M_inv = torch.linalg.inv(M)\n", + " print_debug_quantity(M_inv)\n", + " return -M_inv @ (Cm2l[1:, :-1] - Cm2l[:-1, :-1])\n", + "\n", + "\n", + "alpha_matrix = compute_alpha_matrices(A_matrices.Cm2l, homogeneous_sol)\n", + "print_debug_quantity(alpha_matrix)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Forcing" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "$$\n", + "F(x,y) = - \\tau \\cos(\\frac{2\\pi y}{L})\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:19:27.276\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mTau: torch.Size([97, 121, 2]) | -1.999326e-05 | -1.666546e-13 | 0.000000e+00 | 2.000000e-05\u001b[0m\n" + ] + } + ], + "source": [ + "# initialize the Forcing term\n", + "tau = torch.zeros((domain.nx, domain.ny, 2)).type(torch.float64)\n", + "\n", + "# create staggered coordinates\n", + "y_coords = torch.arange(domain.ny) + 0.5\n", + "tau[:, :, 0] = -pde_params.tau0 * torch.cos(2 * torch.pi * (y_coords / domain.ny))\n", + "print_debug_quantity(tau, \"Tau\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwgAAAEaCAYAAAC1hHCuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9nklEQVR4nO3de3gV1b3/8c/kQgiEy45CjUJIFAXcKAXUkqLGICJakxSEB5V4qvUSpVqBqgW5aC2aU6FUBaqABVHwBrQQqICXAB6pnlMFlCeJ/kQSUIyiJlSU3Mie3x872bBJsi/J5DLj+/U8+9nMmrVm1mTCd/KdyxrDNE1TAAAAACApoq07AAAAAKD9IEEAAAAA4EOCAAAAAMCHBAEAAACADwkCAAAAAB8SBAAAAAA+JAgAAAAAfEgQAAAAAPiQIAAAAADwIUEA0KI+//xz3X333UpJSVGnTp1kGIaKi4tbtQ+XXXaZDMOo93n88cdbtR8AANhBVFt3AICz7d27V6+88oqGDh2qSy65RK+99lqb9OP888/X4sWL/cqSkpLapC8AALRnJAgAWtSll16qr776SpL0zDPPtFmC0KVLFw0bNqxN1g0AgJ1wixGAFhUREVqY+frrr3XHHXfojDPOUExMjPr3768lS5a0cO8AAMDJSBAAtLnvvvtOF198sV599VU99NBD+uc//6n09HTdeeedWrBggSXr2LVrl7p166bo6Gidf/75+tvf/mbJcgEAcBpuMQLQ5p544gnt379fe/bs0dlnny1JGjlypA4fPqw//OEPuvPOOxUV1fRwdemll2rixIk655xzdPjwYT333HO69dZbVVJSopkzZ1q1GQAAOIJhmqbZ1p0A8OPwzDPP6LbbblNRUZHfA8LDhw9XVFSU3nzzTb/669at0/jx4/XBBx/o/PPP1969e30JRCB9+vQJOlLSmDFjtHnzZn399deKi4tryuYAAOBIXEEA0OYOHTqkvXv3Kjo6usH53377rSTvH/6FhYVBl9fYck50/fXXa926ddqzZ49SUlLC6zAAAA5GggCgzZ1yyinq2bOnnnjiiQbn9+vXT5L3D//+/ftbum7DMCxdHgAAdkeCAKDNjR49WgsWLFBiYqJ69uzZKutctWqVYmNjdd5557XK+gAAsAtGMQLQ4tasWaM1a9bo/ffflyRt2rRJa9as0fbt2yVJU6ZMUc+ePXXJJZfo6aef1tatW7Vx40bNmzdPmZmZzVr3//zP/+gXv/iF/va3v+nNN9/U3//+d2VmZio3N1cPPvigOnfu3OztAwD8uHz22WcaN26cunXrpq5du2rs2LE6cOBASG0feOABjRo1SqeccooMw9Czzz7baN2lS5eqf//+iomJUb9+/fT0009btAWBcQUBQIsbP3683/SkSZMkSampqdq2bZu6deumf/3rX3r44Yf1pz/9SQcPHlT37t3Vr18/XXvttc1ad0JCgjwej2bPnq1vvvnGN8zpCy+8oOuvv75ZywYA/PgcPXpUI0aMUExMjFasWCHDMDRz5kylpaXpww8/DHriacGCBfrpT3+qa665Rs8991yj9ZYuXars7GxNnz5dI0eO1JtvvqlJkybJNE3deeedVm+WH0YxAgAAAEL0xBNPaOrUqfr444/Vt29fSVJRUZHOPvtsPfbYY5o6dWrA9h6PRxEREb6R+ZYvX66bbrrJr86xY8d0+umn66qrrtKKFSt85b/+9a+Vm5urkpKSkAbkaCpuMQIAAABClJubq2HDhvmSA0lKTk7W8OHDtX79+qDtIyKC//n9zjvv6Ouvv1ZWVpZf+Y033qhvv/1Wb7/9dvgdDwMJAgAAABCi/Px8DRw4sF652+1WQUGBZeuQVG89brdbkixbT2Ns/QxCUlKSDh06pI4dOyo5ObmtuwPAYkVFRaqoqFDPnj2DvvjsZBMnTtRHH30UVpv+/ftr1apVYbVByyLOA87VnBgvhR/nv/nmGx05ciSsWHL77bcrOzvbr6y0tFQul6te3fj4eJWVlYW87EBKS0slqd564uPj/ea3FFsnCIcOHVJ5ebnKy8st2yEA2p9Dhw6F3eajjz7Szp07W6A3aE3EecD5mhLjpabH+XBiSUlJSdjLdwJbJwgdO3ZUeXm5IiJiFNulj98836uPTnoJku+lSIb/9PFyo8FyI8I4YRne74gI/zoRvrpqcNrXztfef9owzNpps7aLjUzL4502PSdsb22Z56R5pn953bRqp01fuek/7ZvvX143fbz+Sd8nPPPe6DzfKuvm1zbw1atbgELjv+t8P9DjP/cTfgdOKjMiTvpupFz1yiP85/umI06qH+E3v65T5on3H9aVnTTPlH+5p266doM9ptHwtFk37V28b5f677rjvwon74cTy2q/PSftm5P3qW/fmo2Vy3+6Tl09Naz8yH55PJXq2LFjIzWCi5GhXkaHgHU+N6tUGfIvHFpTXZzv2LGjzjrrrLbuDgALffrpp6qoqGhWjJfCi/OxsbEaMGBAyMtOSEioV+ZyuRpMMhq7stAUdcspKyvz60PdlYO6KwktxdYJQnJyssrKyhTbpY9+eskSSfX/cDNq/7iKiIqUJEVGRvpNR0V7fwSRtd9109Ex0X7THToef1I8uoO3LKbjSd8xdd/edXbs6F1HTAdvXzrG1H17l9MpxvsXWcdos/a7xvsdVe39jjxW+13p7UNElXd5qvB+Hzt6vE/Hyr3fVT94+137HVFZXvtdW7fcW64Kb7mn3FtuVnjXUVPuLa/5wft9rLyi9rvS/7vC28fq8qqTpqt9far797GKmtpv7/bUVHlq13Xyt7ee51jtH43Vof3BZkTXJmhR3u/I2Np9HRvh9y1JkR28/46q3WdRtfsoOjba7zuqY910B7/pqNiYk769QS2yc2zturzfRu1Ojojt5F1xR2+5Yr1Dn3liOvn65InxzjvWwTuvuu47ylteGeWtWynvuqo83j5V1MTUfnu3peKYt48V1ZG1396fx9FK7zbX7mJVVHp/rpVV3u+K2v1TWXk8Q6is9O6rygr/7+oq73dV7f4+Vl1bXuk/XVP7XTftOeZdR01Njd+0aTaciNbZ/T+364f//L9m3VrSOzJGC7udGbDOXf/Zp701FU1eB1pOXZw/66yzlBvCw38A7CMjM1P5+fnNvn0wnDg/YMAA3zt5msrtdvueEThRQUGBzj333GYt+8R1SN5nEU5MEOqePbBqPY3hIWUAzmZ4k8dAHxnBFwMAaKdaOc5nZGTo3Xff1b59+3xlxcXF2rFjhzIyMixZR0pKik499dR6z8WtXLlS8fHxGj58uCXraYytryAAQDCGcfwqU6A6AAB7au04f9ttt2nhwoXKzMzUnDlzZBiGZs2apd69e/s90Lx//36dddZZmj17tmbPnu0r3759u77++mt9+eWXkqT33ntPcXFxkqRx48ZJkqKjo/XHP/5RkyZN0hlnnKGRI0cqLy9Py5Yt04IFC9ShQ+BbqpqLBAGAsxnHbz8LVAcAYFOtHOc7d+6svLw8TZkyRTfeeKNM09Tll1+uxx9/3PeHvuR97q6mpkaek26fffDBB7V9+3bf9KJFi7Ro0SJfmzp33HGHDMPQn//8Z82dO1eJiYlauHChJk2aZN3GNIIEAYCzGUbQM0tcQgAAG2uDOJ+YmKi1a9cGrJOUlFR/cA5J27ZtC3k92dnZ9YZZbQ0kCAAczTCkyJjAj1uRHwCAfRHnrUeCAMDZDCkikluMAMCxiPOWI0EA4HgnvscEAOA8xHlrkSAAcDTDMGREBrv0zIEFAOyKOG89EgQAjhf00jMAwNaI89YiQQDgaIYhRUbz8BoAOBVx3nokCACczTBkBH14jSMHANgWcd5yJAgAHM+ICHxmCQBgb8R5a5EgAHA2I4TRLTixBAD2RZy3HAkCAEczFPzhNY4bAGBfxHnrkSAAcDbDUERUZNA6AACbIs5bjgQBgOPxAh0AcDbivLVIEAA4mmGEcOmZ4woA2BZx3nokCAAczgjhzBJHDgCwL+K81UgQADibEcLwdxw3AMC+iPOWI0EA4HjcmwoAzkactxYJAgBHMwxDEVGBzywZ3JwKALZFnLceCQIAx+MNmwDgbMR5a5EgAHC2EEa34N5UALAx4rzlSBAAOB73pgKAsxHnrUWCAMDRDMMIeumZe1MBwL6I89YjQQDgbIaCPrzGpWcAsDHivOVIEAA4XPAzSxw5AMDOiPNWI0EA4HjcmwoAzkactxYJAgBHM0J4wya3pgKAfRHnrRf2oLE7duzQqFGj1LNnT3Xp0kVDhgzRsmXL/OpUVFTovvvuU0JCgmJjY5WSkqK33nrLsk4DQFgMI/AHfojzAGyHOG+psBKEDz/8UCNHjlR1dbWWLl2qv//977rwwgt1yy236KmnnvLVu+WWW7R06VI9/PDD2rhxoxISEnTllVdq9+7dVvcfAAIzDEVERQb8cPA4jjgPwHaI85YL6xajl156STU1NdqwYYPi4uIkSVdccYU+/PBDPffcc7rzzjv1wQcf6IUXXtCyZct08803S5JSU1Pldrs1e/Zs5ebmWr8VABAA96aGjjgPwI6I89YK6wpCVVWVoqOjFRsb61ferVs3eTweSVJubq6io6M1YcIE3/yoqChdd9112rJliyorKy3oNgCEqHZ87EAfziwdR5wHYDvEecuFdQXhpptu0lNPPaXf/va3mjFjhjp16qTVq1frzTff1PPPPy9Jys/PV3Jysjp16uTX1u12q6qqSnv37pXb7W50HYsXL9aSJUtC6k9hYWE43QfwI2Qo+JklDhvHEecB2A1x3nphJQgDBw7Utm3bNGbMGP31r3+VJEVHR+vpp5/WddddJ0kqLS2Vy+Wq1zY+Pt43P5CSkhLt3LkznG4BQEBceg4dcR6AHRHnrRVWgvDJJ5/o2muvldvt1tNPP63Y2FitX79ed9xxhzp27KiJEyc2u0MJCQkaMmRISHULCwtVXl7e7HUCcDDDkBEZGbQOvIjzAGyHOG+5sBKEBx54QNHR0dq4caOio6MlSZdffrm+/fZb3XPPPbr++uvlcrm0f//+em3rzijVnWFqTHZ2trKzs0Pqz9ChQzkLBSCo4G/YRB3iPAA7Is5bK6yf5p49ezRo0CDfQaPORRddpG+//VaHDh2S2+1WUVGRjh496lenoKBAHTp0UN++fZvfawAIleG99Bzow82pxxHnAdgOcd5yYSUIp512mnbv3q2qqiq/8v/93/9Vx44dFR8fr/T0dFVXV2v16tW++ceOHdPLL7+sUaNGKSYmxpqeA0BIDCkiIvCHI4cPcR6A/RDnrRbWLUZ33XWXxo8fr/T0dE2aNEmxsbHKzc3Viy++qClTpqhDhw4aPHiwJkyYoMmTJ6u6ulrJycl66qmnVFRUpFWrVrXUdgBAgwwjhNEtOG74EOcB2A1x3nphJQjjxo3Tq6++qj/96U+69dZbVVFRobPOOkuLFi3yu590+fLlmjFjhmbOnKnDhw9r0KBB2rx5c8gPpQGAlYI+vAYf4jwAOyLOWyusBEGSrrrqKl111VUB68TGxmr+/PmaP39+kzsGAJaofYFOsDo4jjgPwFaI85YLO0EAALthfGwAcDbivLVIEAA4n8HwdwDgaMR5S5EgAHA2wwh+ZolLzwBgX8R5y5FuAXA0Q96H1wJ+LF7n559/rrvvvlspKSnq1KmTDMNQcXGxxWsBAEhtE+c/++wzjRs3Tt26dVPXrl01duxYHThwIKS2FRUVuu+++5SQkKDY2FilpKTorbfeqlcvKSlJhmHU+6xbt87iramPBAGAw7X++Nh79+7VK6+8IpfLpUsuucTSZQMATta6cf7o0aMaMWKEPvroI61YsULPP/+8PvnkE6WlpemHH34I2v6WW27R0qVL9fDDD2vjxo1KSEjQlVdeqd27d9ere+WVV+qdd97x+6Smplq2LY3hFiMAzhbC+NhWn1q69NJL9dVXX0mSnnnmGb322mvWrgAAcFwrx/mlS5dq3759+vjjj31vjj///PN19tlna/HixZo6dWqjbT/44AO98MILWrZsmW6++WZJUmpqqtxut2bPnq3c3Fy/+qeeeqqGDRtmXedDxBUEAM5nRAT+WCwi2HB7AABrtWKcz83N1bBhw3zJgSQlJydr+PDhWr9+fdC20dHRmjBhgq8sKipK1113nbZs2aLKykpL+9pUXEEA4HwhDn9XWFiooUOHhrzY22+/3e/lYQCANtKKcT4/P1+ZmZn16rrdbq1evTrg8vLz85WcnKxOnTrVa1tVVaW9e/fK7Xb7yjds2KBOnTqppqZGgwcP1rRp0/TLX/4y5P43FQkCAGczjOBv2Kwd3aK8vFw7d+4MedElJSXN6RkAwAqtHOdLS0vlcrnqlcfHx6usrCzg8gK1rZtfJz09XRdeeKGSk5P11VdfaeHChRozZoyef/55ZWVlhbwNTUGCAMDxgr5hs1ZsbKwGDBgQ8nITEhKa2iUAgIWcGOcXLFjgNz1mzBgNGzZM06dPJ0EAgGYxjODjX9fOHzBggN5///1W6BQAwDKtHOddLleDVwoauzpwctv9+/c32FY6fiWhIZGRkRo/frx+//vfq6SkpEWTF56kA+B8QYe/AwDYWivGebfbrfz8/HrlBQUFOvfcc4O2LSoq0tGjR+u17dChg9+Dz4EYLfziN46MAJyv7uxSYx8AgL21YpzPyMjQu+++q3379vnKiouLtWPHDmVkZARsm56erurqar+HmY8dO6aXX35Zo0aNUkxMTKNt6+olJibqtNNOa/6GBMAtRgCczTBkRAYJdS2QJKxZs0aSfJeyN23apB49eqhHjx6t8pIbAPjRaOU4f9ttt2nhwoXKzMzUnDlzZBiGZs2apd69e/uNeLR//36dddZZmj17tmbPni1JGjx4sCZMmKDJkyerurpaycnJeuqpp1RUVKRVq1b52r744otav369rr76avXu3VtfffWVFi1apJ07d+rFF1+0bFsaQ4IAwPlCHP7OSuPHj/ebnjRpkiTvC3G2bdvW6v0BAEdrxTjfuXNn5eXlacqUKbrxxhtlmqYuv/xyPf7444qLi/PVM01TNTU18ng8fu2XL1+uGTNmaObMmTp8+LAGDRqkzZs3a8iQIb46ycnJOnTokO677z6Vlpaqc+fOuuCCC7R582ZdeeWVLb6NJAgAHM2QISPIS3IMq1+lLO+BAQDQ8toizicmJmrt2rUB6yQlJTV4LIiNjdX8+fM1f/78RtsOGzZMeXl5ze5nU5EgAHA2Q8HPLPEYAgDYF3HeciQIAJwvyJklAIDNEectRYIAwNkMQwrxDZsAABsizluOBAGA83FmCQCcjThvKRIEAM7XBqMYAQBaEXHeUiQIABzOCOHMEgcWALAv4rzVSBAAOJuh4PeectwAAPsizluOBAGA8wV7eA0AYG/EeUuRIABwOC49A4CzEeetRoIAwNkMSRFBDhwcNwDAvojzliNBAOB8jH8NAM5GnLcUCQIAh+PSMwA4G3HeaiQIAJzNUAhv2GyVngAAWgJx3nIkCAAczZQhM8ilZ5MjBwDYFnHeeiQIAJwv6KVnAICtEect1aSf5quvvqpLL71UcXFx6tq1qy644ALl5eX55peVlenWW2/Vqaeeqs6dO2vkyJHas2ePZZ0GgLAYEYE/qIc4D8BWiPOWCvsntnjxYmVmZmro0KH6xz/+odWrV2v8+PE6evSoJMk0TaWnp2vz5s1asGCB1q5dq+rqaqWlpenzzz+3fAMAICDDe+k50IfRL/wR5wHYCnHecmHdYlRcXKzJkydr7ty5mjx5sq/8yiuv9P07NzdXO3bsUF5entLS0iRJKSkpSk5O1mOPPaYnn3zSmp4DQKgieMNmqIjzAGyJOG+psK4gLFu2TBEREbrjjjsarZObm6vTTz/dd9CQpG7duik9PV3r169vek8BoEkM7wt0An14eM2HOA/AfojzVgvrCsLbb7+t/v3766WXXtIf//hH7d+/X0lJSZoyZYp+85vfSJLy8/M1cODAem3dbreee+45ff/994qLi2t0HYsXL9aSJUtC6k9hYWE43QfwY2Qo6OgWHDeOI84DsB3ivOXCShC++OILffHFF7rvvvv06KOP6qyzztLq1at111136dixY7rnnntUWlqqpKSkem3j4+MleR9sC3TgKCkp0c6dO8PbCgAIhAfUQkacB2BLxHlLhZUgeDweHTlyRM8++6zGjh0rSRoxYoSKi4uVk5Oj3/72t83uUEJCgoYMGRJS3cLCQpWXlzd7nQCczJDJGzZDRpwHYD/EeauFlSCccsop+uSTT3TFFVf4lY8aNUqbN29WSUmJXC6XysrK6rUtLS2VJLlcroDryM7OVnZ2dkj9GTp0KGehAARl8vBayIjzAOyIOG+tsK7HuN3uwAuLiJDb7VZ+fn69eQUFBUpMTAx42RkALGfIO7xdwE9bd7L9IM4DsB3ivOXCShDGjBkjSdqyZYtf+ebNm9WrVy+ddtppysjI0MGDB7V9+3bf/O+++04bNmxQRkaGBV0GgHAYIbxAhyNHHeI8APshzlstrFuMrr76aqWlpSk7O1vffPONzjzzTK1evVqvvfaali9fLknKyMhQSkqKsrKyNHfuXLlcLuXk5Mg0Td1///0tshEA0BhTwUe3MFunK7ZAnAdgN8R564WVIBiGoXXr1mn69Ol68MEHVVZWpv79+2vVqlW64YYbJHkvP2/cuFH33nuvJk2apIqKCqWkpGjr1q3q3bt3i2wEAATE6BYhI84DsCXivKXCShAkqWvXrlq0aJEWLVrUaJ34+HgtW7ZMy5Yta1bnAKD5DHmMYA+vcen5RMR5APZCnLda2AkCANiKoeBnljhuAIB9EectR4IAwOGM4G/Y5MgBADZGnLcaCQIAxwv+Ah0AgJ0R561FggDA+YKeWQIA2Bpx3lIkCAAczQzh4TWTS88AYFvEeeuRIABwNiOES88cNwDAvojzliNBAOB8XHoGAGcjzluKBAGAwxkyFezhNQ4sAGBfxHmrkSAAcLzgw98BAOyMOG8tEgQAjsbDawDgbMR565EgAHA8xscGAGcjzluLBAGAsxkhXHrmxBIA2Bdx3nKkWwAcz5QR8GO1zz77TOPGjVO3bt3UtWtXjR07VgcOHLB8PQAALzvF+YqKCt13331KSEhQbGysUlJS9NZbb9Wr5/F4lJOTo6SkJHXs2FGDBg3S2rVrrd6UBpEgAHA0U4ZMIyLwx8KDx9GjRzVixAh99NFHWrFihZ5//nl98sknSktL0w8//GDZegAAXnaL87fccouWLl2qhx9+WBs3blRCQoKuvPJK7d6926/erFmz9NBDD+muu+7Spk2bNGzYMI0fP16vvvqqZdvSGG4xAuB4wR5es9LSpUu1b98+ffzxx+rbt68k6fzzz9fZZ5+txYsXa+rUqa3WFwD4sbBLnP/ggw/0wgsvaNmyZbr55pslSampqXK73Zo9e7Zyc3MlSYcOHdK8efM0bdo03XvvvZKktLQ07d27V9OmTdPVV1/dotvIFQQADhf4srP3rJJ1Z5Zyc3M1bNgw30FDkpKTkzV8+HCtX7/esvUAAOrYJ87n5uYqOjpaEyZM8JVFRUXpuuuu05YtW1RZWSlJ2rJli6qqqpSVleXXPisrS3v27FFRUZFl29MQEgQAjhfs0rOV8vPzNXDgwHrlbrdbBQUFlq4LAOBllzifn5+v5ORkderUqV7bqqoq7d2711cvJibGLwmpqyepxY8n3GIEwNFMBR//2qz9Liws1NChQ0Ne9u23367s7Gy/stLSUrlcrnp14+PjVVZWFvKyAQChsVOcD9S2bn7dd/fu3WWcNDrTyfVaCgkCAMcL9Q2b5eXl2rlzZ8jLLSkpaWqXAAAWIs5biwQBgMMZ8pjBHl7zHlhiY2M1YMCAkJeckJBQr8zlcjV4Bqmxs0YAgOayT5x3uVzav39/g22l41cIXC6XDh8+LNM0/a4inFyvpZAgAHC8UIe3GzBggN5///1mrcvtdis/P79eeUFBgc4999xmLRsA0DC7xHm3261//OMfOnr0qN9zCAUFBerQoYPvmQO3263Kykp9+umnfs8h1D170NLHEx5SBuBodfemBv5YJyMjQ++++6727dvnKysuLtaOHTuUkZFh4ZoAAJK94nx6erqqq6u1evVqX9mxY8f08ssva9SoUYqJiZEkjR49WtHR0Vq1apVf+5UrV2rgwIFKTk62cIvqI0EA4HCtO/zdbbfdpqSkJGVmZmr9+vXKzc1VZmamevfuXe9BNwCAFdpnnN+/f7+ioqL08MMP+8oGDx6sCRMmaPLkyXrmmWf05ptv6rrrrlNRUZH+8Ic/+Or17NlTU6dOVU5OjubPn69t27bpzjvvVF5ennJycizblsZwixEAx7PyDZrBdO7cWXl5eZoyZYpuvPFGmaapyy+/XI8//rji4uJarR8A8GPSHuO8aZqqqamRx+Pxa798+XLNmDFDM2fO1OHDhzVo0CBt3rxZQ4YM8av3yCOPKC4uTk888YS+/PJL9evXT6+88oquueaaFt9GEgQAjucxW/diaWJiotauXduq6wSAH7P2GOeTkpJkmvVvboqNjdX8+fM1f/78gO0jIyM1c+ZMzZw5s1l9bQoSBACOFs742AAA+yHOW48EAYDDGSFcem69S9MAAKsR561GggDA8UyTAwMAOBlx3lokCAAcz8OZIwBwNOK8tUgQADiaqeAPr3FvKgDYF3HeeiQIAByOe1MBwNmI81Zr9phQo0ePlmEY9YZgKisr06233qpTTz1VnTt31siRI7Vnz57mrg4AwmN6700N9OHUUmDEeQDtGnHecs1KEF588UV98MEH9cpN01R6ero2b96sBQsWaO3ataqurlZaWpo+//zz5qwSAMIW/A2baAxxHoAdEOet1eQEoaysTFOmTGnwJQ+5ubnasWOHnn/+eV1//fUaPXq0cnNz5fF49NhjjzWrwwAQDlPBzyxxYqlhxHkAdkCct16TE4Tf//73GjhwoK6//vp683Jzc3X66acrLS3NV9atWzelp6dr/fr1TV0lADRJjWkE/KBhxHkAdkGct1aTEoS3335bzz33nBYtWtTg/Pz8fA0cOLBeudvt1oEDB/T99983ZbUA0ASBLzt7Lz1z8DgZcR6AfRDnrRb2KEZVVVXKzs7Wvffeq379+jVYp7S0VElJSfXK4+PjJXkvW8fFxTXYdvHixVqyZElIfSksLAyt0wB+tOouPQerg+OI8wDshDhvvbAThMcee0zl5eWaMWNGS/RHJSUl2rlzZ4ssG8CPEw+ohYc4D8BuiPPWCitBOHDggB555BE988wzqqysVGVlpW9eZWWlDh8+rC5dusjlcqmsrKxe+9LSUkmSy+VqdB0JCQkaMmRISP0pLCxUeXl5OJsA4EfIw6mjkBHnAdgRcd5aYSUI+/btU0VFhbKysurNmzdvnubNm6ddu3bJ7Xbrtddeq1enoKBAiYmJjV52lqTs7GxlZ2eH1J+hQ4dyFgpAUJxZCh1xHoAdEeetFVaC8NOf/lRbt26tV56WlqasrCzdcsst6tu3rzIyMrR8+XJt375dqampkqTvvvtOGzZs0A033GBNzwEgBKYpeTxB7k3lzJMPcR6A3RDnrRdWgtC9e3dddtllDc7r06ePb15GRoZSUlKUlZWluXPnyuVyKScnR6Zp6v77729unwEgDIY8Qc8sceapDnEegP0Q563WrDcpN7rQiAht3LhRV1xxhSZNmqQxY8YoMjJSW7duVe/evVtilQDQqGAv0EH4iPMA2hPivLXCHsWoIWYD123i4+O1bNkyLVu2zIpVAECTeIe/C14HgRHnAbRXxHnrWZIgAEB7xsNrAOBsxHlrkSAAcDZTqgny8BqnlgDAxojzliNBAOBoXHoGAGcjzluPBAGA4wUf3QIAYGfEeWuRIABwPMa/BgBnI85biwQBgMOFMsQdZ54AwL6I81YjQQDgaKYp1XiC1wEA2BNx3nokCAAcj+HvAMDZiPPWIkEA4GimJA+jWwCAYxHnrUeCAMDxuLQMAM5GnLcWCQIAx+PAAQDORpy3FgkCAEczQ3jDJgcWALAv4rz1SBAAOB4HBgBwNuK8tUgQADhesIfXAAD2Rpy3FgkCAMcL/gIdAICdEeetRYIAwNFMBb/0zIknALAv4rz1SBAAOFsIb9jkyAEANkactxwJAgDH4+E1AHA24ry1SBAAOBpv2AQAZyPOW48EAYDjcWYJAJyNOG8tEgQAzmZKHu5NBQDnIs5bLqKtOwAALcmU98AR6NMejhvz589Xenq6EhISZBiGHnroobbuEgDYgl3ivMfjUU5OjpKSktSxY0cNGjRIa9euDbn9unXrNHjwYHXs2FF9+vTRnDlzVFNT41fnoYcekmEY9T6//OUvw+orVxAAOJ4dXqCzdOlSde3aVb/85S/19NNPt3V3AMBW7BDnZ82apXnz5umRRx7R0KFD9dJLL2n8+PHauHGjrr766oBtt2zZomuvvVa33HKL5s+fr127dumBBx7QkSNH9Kc//ale/bfffluRkZG+6fj4+LD6SoIAwNlMybTBANn5+fmKiIjQsWPHSBAAIBw2iPOHDh3SvHnzNG3aNN17772SpLS0NO3du1fTpk0LmiBMmzZNF198sZYsWeJr+/3332vOnDmaMmWKTjvtNL/6P/vZzxQV1fQ/87nFCICj1b1AJ+CnrTspKSKCcAwATWGHOL9lyxZVVVUpKyvLrzwrK0t79uxRUVFRo20/++wz7d69u17bG2+8UdXV1dq0aZPl/eWIBMDxgt2bCgCwt/Ye5/Pz8xUTE6O+ffv6lbvdbklSQUFBwLaSNHDgQL/y5ORkderUqcG2vXv3VmRkpPr06aPf//73Ki8vD6u/3GIEwNnCeMNmYWGhhg4dGvKib7/9dmVnZze9bwCA5rNBnC8tLVX37t1lGIZfed2zAaWlpQHbSpLL5ao3z+Vy+bXt27ev/vu//1uDBw+WYRh67bXX9Je//EU7d+7U66+/HnJ/SRAAOFrdpedgdSSpvLxcO3fuDHnZJSUlDZa/8cYbuuKKK4K2T01N1bZt20JeHwCgPuL8cSffhnTFFVeoV69emjx5st544w2NHDkypOWQIABwPDPE4S1iY2M1YMCAkJebkJDQYPnPf/5zFRYWBm3fqVOnkNcFAGhce4/zLpdLhw8flmmaflcR6s7+BxplqO7KQVlZWb15ZWVlQUcouv766zV58mT9+9//JkEAgDqhDn83YMAAvf/++81eX6dOndS/f/9mLwcAEJr2HufdbrcqKyv16aef+j2HUPf8wLnnnhuwreR9FiElJcVXXlxcrKNHjwZse6KTb28KhIeUAThbsJEtTLX98BYAgKazQZwfPXq0oqOjtWrVKr/ylStXauDAgUpOTm60bWJiogYNGtRg2+joaF111VUB113X7qKLLgq5v2ElCGvWrNG1116rPn36KDY2Vv369dP06dN15MgRv3plZWW69dZbdeqpp6pz584aOXKk9uzZE86qAMASpqSaGjPgpz3kB++9957WrFmjv//975K8Z5XWrFmjNWvW6OjRo63WD+I8ALuxQ5zv2bOnpk6dqpycHM2fP1/btm3TnXfeqby8POXk5PjVvfzyy+uNdvToo49q+/btys7O1rZt2/SXv/xFc+bM0T333OP3DoTBgwfrL3/5i1599VVt2rRJU6dO1f3336/Ro0drxIgRIfc3rFuM5s2bp8TERD366KPq1auXdu3apYceekhbt27Vv/71L0VERMg0TaWnp6u4uFgLFiyQy+VSTk6O0tLStHv3bvXq1SucVQJAswV7eK09WLhwoVasWOGbXr16tVavXi1JKioqUlJSUqv0gzgPwI7sEOcfeeQRxcXF6YknntCXX36pfv366ZVXXtE111zjV6+mpkbHjh3zK7v66qu1Zs0a/eEPf9Czzz6rn/zkJ3rggQc0Y8YMv3r9+vXTwoULVVJSIo/HozPPPFOzZ8/W/fffH1Zfw0oQNmzYoB49evimU1NTFR8fr1/96lfatm2bRowYodzcXO3YsUN5eXlKS0uTJKWkpCg5OVmPPfaYnnzyybA6CADNYZqmPEGOHEHfwNkKnn32WT377LNt3Q3iPADbsUucj4yM1MyZMzVz5syA9Rob9Wjs2LEaO3ZswLYvvfRSU7vnJ6xbjE48aNS58MILJUkHDx6UJOXm5ur000/3HTQkqVu3bkpPT9f69eub01cAaBLTE/iD44jzAOyIOG+tZj+kvH37dknyDRmVn59f701vkvcJ7AMHDuj7779v7ioBICymaQb8IDDiPID2jjhvrWYNc3rw4EHNnj1bI0eO1AUXXCDJO55rQ/fK1o3RWlZWpri4uEaXuXjxYi1ZsiSk9Ycy/iyAHzfT9D68FqwOGkacB9DeEeet1+QE4fvvv1dmZqaioqK0fPlyyzpUUlIS1hvuACCYUMfHhj/iPAC7IM5bq0kJQnl5udLT07Vv3z5t377db8QKl8vV4Jve6t4UV/c2uMYkJCRoyJAhIfWjsLBQ5eXlYfQcwI9RqG/YxHHEeQB2Qpy3VtgJQnV1tcaNG6f33ntPr7/+us477zy/+W63W6+99lq9dgUFBUpMTAx42VmSsrOzlZ2dHVJfhg4dylkoAIGZIVxa5rjihzgPwFaI85YL6yFlj8ejiRMnKi8vT+vWrdOwYcPq1cnIyNDBgwd9D7VJ0nfffacNGzYoIyOj+T0GgDCYkjweM+CH48ZxxHkAdkOct15YVxB+85vfaPXq1ZoxY4Y6d+6sd9991zevV69e6tWrlzIyMpSSkqKsrCzNnTvX9wId0zTDfkkDADSbacoT5OE1nl47jjgPwHaI85YL6wrCpk2bJHnfBJeSkuL3eeaZZ7wLjIjQxo0bdcUVV2jSpEkaM2aMIiMjtXXrVvXu3dv6LQCAAExJntqX6DT24bBxHHEegN0Q560X1hWE4uLikOrFx8dr2bJlWrZsWVP6BACWYgzs0BHnAdgRcd5azXoPAgDYgYfRLQDA0Yjz1iJBAOBsjG4BAM5GnLccCQIARzNlqqbGE7QOAMCeiPPWI0EA4Hi8QAcAnI04by0SBADOZoZw4OC4AgD2RZy3HAkCAEfzDn8XvA4AwJ6I89YjQQDgeFx6BgBnI85biwQBgKOZZggPrzF+NgDYFnHeeiQIAByPAwMAOBtx3lokCACcjYfXAMDZiPOWI0EA4HjcmwoAzkactxYJAgBH845uEfjAwWEFAOyLOG89EgQAzmaa8gR5eE3cuwoA9kWctxwJAgDH83DpGQAcjThvLRIEAI5mhvDwGieWAMC+iPPWI0EA4HgMfwcAzkactxYJAgCHM2V6gtybyuNrAGBjxHmrkSAAcDTTVAhv2GylzgAALEectx4JAgDHY3xsAHA24ry1SBAAOJtphvCGTQ4sAGBbxHnLkSAAcDyPGezeVACAnRHnrUWCAMDRTIUw/F3rdAUA0AKI89YjQQDgbLxhEwCcjThvORIEAI7nCTr8HQDAzojz1iJBAOBovGETAJyNOG89EgQADmfKDPrwGkcOALAv4rzVSBAAOB7jYwOAsxHnrUWCAMDRvG/YrAlaBwBgT8R565EgAHC4EF6gw6VnALAx4rzVSBAAOJspmcFGt+C4AQD2RZy3HAkCAMfj3lQAcDbivLUiWmrBn332mcaNG6du3bqpa9euGjt2rA4cONBSqwOARnhHtwj04dRS0xDnAbQP9ojzHo9HOTk5SkpKUseOHTVo0CCtXbs2pLYbNmzQDTfcoHPOOUcRERG67LLLGq2bn5+vUaNGKS4uTqeccopuvvlmlZaWhtXXFkkQjh49qhEjRuijjz7SihUr9Pzzz+uTTz5RWlqafvjhh5ZYJQA0yDSlmmM1AT88vBY+4jyA9sIucX7WrFl66KGHdNddd2nTpk0aNmyYxo8fr1dffTVo23Xr1mn37t0aNmyYevXq1Wi9L774QpdddpnKy8u1Zs0aLVq0SG+88YauueaasF4m1yK3GC1dulT79u3Txx9/rL59+0qSzj//fJ199tlavHixpk6d2hKrBYAGcenZesR5AO1Je4/zhw4d0rx58zRt2jTde++9kqS0tDTt3btX06ZN09VXXx2w/dKlSxUR4T2vf/HFFzdab+7cuaqurtaGDRvUvXt3SdLpp5+u1NRUrVu3TmPHjg2pvy1yBSE3N1fDhg3zHTQkKTk5WcOHD9f69etbYpUA0DAzhEvP7eHUks0Q5wG0GzaI81u2bFFVVZWysrL8yrOysrRnzx4VFRUFbF+XHASTm5urX/ziF77kQJIuvfRSJSYmhhWbWyRByM/P18CBA+uVu91uFRQUtMQqAaBBprxnlgJ+2rqTNkScB9Be2CHO5+fnKyYmxu+kiuSNmZIsiZvl5eUqKiqyJDa3yC1GpaWlcrlc9crj4+NVVlYWsO3ixYu1ZMmSkNbzwQcfSJLKj+zX7v+53W+e4fuH4V9eN234Tx8vNxosNyKME5bh/Y6I8K8T4aurBqd97Xzt/acNw6ydNmu72Mi0vPeQGSe8VtyoK/OcNM/0L6+bVu20b1iw2szaN+2b71/uu4Tnq3/S9wkZeqPzfKusm1/bwFevbgEKTe27UXy7uvzkn/sJvwMnldXtVyOi4f1tRJz0e+Erj/Cf75uOOKl+hN/8uk6ZJ54JqCs7aZ4p/3JP3XTtL6/HNBqeNuumvYv37VL/XXf8V+Hk/XBiWe2356R9c/I+9e1bs7Fy+U/XqaunhpUf2S9JQc+sBFJ+ZL92bb81aB2Ep7Xj/KeffqqMzMzwOwqg3fr0008lNS/GS+HF+cLCQg0dOjTkZd9+++3Kzs5uVv8kb8zs3r27/98k8sbMuvnNVVZWJtM0G43NH3/8ccjLanfDnJaUlGjnzp1htfF4KvXDf/5fC/UI7d7JCUXoz+DAJioqKprclvjQ/jQlzldUVCg/P7+FegSgLTUnxkvhxfny8vKw4k9JSUmD5W+88YauuOKKoO1TU1O1bdu2kNfXXrRIguByuRo8g9TYGacTJSQkaMiQISGtZ9euXTJNU5GRkRo0aFCT+tpeFBYWqry8XLGxsRowYEBbd6fZnLQ9bEvbKSoqUkVFhXr27Bl22/79+7dKmx8r4nz47Pb/LxAnbYvkrO2x07Y0J8ZL4cfsb775RkeOHFFycnLIbRISEhos//nPf67CwsKg7Tt16iTJGzMPHz4s0zT9riLUXTmou5LQHHVXKBqLzWGtw2wBaWlp5vDhw+uVp6ammpdeeqll6xkyZIgpyRwyZIhly2wrTtoW03TW9rAtQH3E+fCxLe2Xk7bHSdviJCtWrDAlmZ988olf+fLly01J5r59+0Je1vDhw83U1NQG5yUnJ5sTJ06sV96nTx/zv/7rv0JeR4s8pJyRkaF3331X+/bt85UVFxdrx44dysjIaIlVAgBaEXEeAEI3evRoRUdHa9WqVX7lK1eu1MCBA8O6qhFIRkaG/vnPf+o///mPr+ztt9/W/v37w4rNLXKL0W233aaFCxcqMzNTc+bMkWEYmjVrlnr37m3Jgx4AgLZFnAeA0PXs2VNTp05VTk6OunTpoiFDhujll19WXl6ecnNz/epefvnl2r9/v/bu3esr279/v/79739Lkr799ltFRERozZo1kqQLL7xQffr0kSTdd999WrlypTIyMjR9+nT95z//0f3336+f/exnGjNmTMj9bZEEoXPnzsrLy9OUKVN04403yjRNXX755Xr88ccVFxfXEqsEALQi4jwAhOeRRx5RXFycnnjiCX355Zfq16+fXnnlFV1zzTV+9WpqanTs2DG/sq1bt+rmm2/2Kxs/frwkafny5brpppskSWeccYa2bt2qqVOn6tprr1WHDh2UmZmpP//5zyG/S0FqwVGMEhMTtXbt2pZaPACgjRHnASB0kZGRmjlzpmbOnBmwXkOjHt10002+JCCY8847T6+//noTenhcizyDAAAAAMCeSBAAAAAA+JAgAAAAAPAhQQAAAADgQ4IAAAAAwIcEAQAAAIBPiw1z2hpuv/12lZSUKCEhoa270mxO2hbJWdvDtgBtx0m/s2xL++Wk7XHStqDtGKZpmm3dCQAAAADtA7cYAQAAAPAhQQAAAADgY8sE4bPPPtO4cePUrVs3de3aVWPHjtWBAwfaulsBrVmzRtdee6369Omj2NhY9evXT9OnT9eRI0d8dYqLi2UYRoOfw4cPt13nG7Bt27YG+9m9e3e/emVlZbr11lt16qmnqnPnzho5cqT27NnTNp1uxGWXXdboz3306NGS2u+++fzzz3X33XcrJSVFnTp1kmEYKi4urlevoqJC9913nxISEhQbG6uUlBS99dZb9ep5PB7l5OQoKSlJHTt21KBBg7R27dpW2BLAH3G+7RHn28e+Ic6jLdjuIeWjR49qxIgRiomJ0YoVK2QYhmbOnKm0tDR9+OGH6ty5c1t3sUHz5s1TYmKiHn30UfXq1Uu7du3SQw89pK1bt+pf//qXIiKO52rTp09XRkaGX/suXbq0dpdD8uSTT+rCCy/0TUdFHf+VMk1T6enpKi4u1oIFC+RyuZSTk6O0tDTt3r1bvXr1aosu1/PXv/5V3333nV/ZO++8o6lTp9bbD+1t3+zdu1evvPKKhg4dqksuuUSvvfZag/VuueUW/fOf/9TcuXN15plnatGiRbryyiv1zjvv6Kc//amv3qxZszRv3jw98sgjGjp0qF566SWNHz9eGzdu1NVXX91KW4UfO+J8+0KcJ87jR8i0mccff9yMiIgwP/nkE1/Zvn37zMjISPPPf/5zG/YssEOHDtUrW7FihSnJfPPNN03TNM2ioiJTkrl06dLW7l7Ytm7dakoyX3/99UbrrFu3zpRk5uXl+coOHz5sulwu8+67726NbjbZr3/9a7NDhw7mt99+a5pm+903NTU1vn8vXbrUlGQWFRX51dm9e7cpyVy2bJmvrLq62jznnHPM9PR0X9lXX31ldujQwZw9e7Zf+xEjRpjnnXdey2wA0ADifPtAnG8fiPNoC7a7xSg3N1fDhg1T3759fWXJyckaPny41q9f34Y9C6xHjx71yurOyBw8eLC1u9MqcnNzdfrppystLc1X1q1bN6Wnp7frfXX06FGtXr1a6enpio+Pb+vuBHTiGcnG5ObmKjo6WhMmTPCVRUVF6brrrtOWLVtUWVkpSdqyZYuqqqqUlZXl1z4rK0t79uxRUVGRtZ0HGkGctw/ifMsjzqMt2C5ByM/P18CBA+uVu91uFRQUtEGPmm779u2SpAEDBviVT58+XVFRUerWrZsyMjLa3b2cJ5o4caIiIyN1yimn6IYbbvC7RzjQvjpw4IC+//771uxqyP7xj3/oyJEj+tWvflVvnp32TZ38/HwlJyerU6dOfuVut1tVVVXau3evr15MTIzfH2V19STZ7v8X7Is4374Q59vvvqlDnIfVbPcMQmlpqVwuV73y+Ph4lZWVtUGPmubgwYOaPXu2Ro4cqQsuuECSFBMTo+zsbI0aNUo9evTQRx99pEcffVQ///nP9X//93/1DjBtqVu3bvrd736n1NRUde3aVbt27dKjjz6qlJQU7dq1Sz179lRpaamSkpLqta07W1NWVqa4uLhW7nlwzz33nHr27KmrrrrKV2anfXOyQP9n6ubXfXfv3l2GYQSsB7Q04nz7QJxvv/vmZMR5WM12CYITfP/998rMzFRUVJSWL1/uK09ISNDTTz/tm77kkks0evRoud1uPfLII1q5cmVbdLdBgwcP1uDBg33TqampuvTSS3XRRRfpySef1Jw5c9qwd033xRdf6I033tA999zj9yCenfYNgLZHnG+/iPNAcLa7xcjlcjV4Bqmx7Lm9KS8vV3p6uvbt26ctW7YEHeGhd+/euvjii/Xvf/+7lXrYdEOGDNE555zj62ugfVU3v71ZuXKlPB5Pg5edT2aXfRNsP9SdOXK5XDp8+LDMk16ufnI9oKUR59sv4nz7RJyH1WyXILjdbuXn59crLygo0LnnntsGPQpddXW1xo0bp/fee0+vvvqqzjvvvJDbnnw5sD2r62ugfZWYmNguLzuvWLFCgwYN0qBBg0Ju0973jdvtVlFRkY4ePepXXlBQoA4dOvjuRXW73aqsrNSnn35ar56kdv//C85BnG//iPPtC3EeVrNdgpCRkaF3331X+/bt85UVFxdrx44d9cYtbk88Ho8mTpyovLw8rVu3TsOGDQup3YEDB/T222/roosuauEeNt97772njz/+2NfXjIwMHTx40PeQniR999132rBhQ7vcV++9954KCgpCOqsk2WffpKenq7q6WqtXr/aVHTt2TC+//LJGjRqlmJgYSdLo0aMVHR2tVatW+bVfuXKlBg4cqOTk5FbtN368iPPtF3G+fSLOw2q2ewbhtttu08KFC5WZmak5c+bIMAzNmjVLvXv3VnZ2dlt3r1G/+c1vtHr1as2YMUOdO3fWu+++65vXq1cv9erVS7/73e/k8XiUkpKiHj166OOPP1ZOTo4iIiI0Y8aMNux9fRMnTlRycrKGDBmi7t27a9euXcrJydEZZ5yh3/72t5K8B46UlBRlZWVp7ty5vhfomKap+++/v423oL7nnntOUVFRmjhxYr157XnfrFmzRpL0/vvvS5I2bdqkHj16qEePHkpNTdXgwYM1YcIETZ48WdXV1UpOTtZTTz2loqIiv4NEz549NXXqVOXk5KhLly4aMmSIXn75ZeXl5Sk3N7dNtg0/TsT59oE43372DXEera5tX8PQNPv37zfHjh1rdunSxYyLizMzMzPrvTSkvenTp48pqcHPgw8+aJqmaf7tb38zL7jgArN79+5mVFSU+ZOf/MS8/vrrzY8++qhtO9+ARx991DzvvPPMrl27mlFRUWavXr3M2267zfziiy/86n377bfmzTffbLpcLjM2NtYcMWKEuXv37jbqdeOqqqrMU0891bzmmmsanN+e901jv1epqam+OkePHjWnTJli/uQnPzFjYmLMiy66yNy6dWu9ZR07dsz84x//aCYmJpodOnQwzzvvPHP16tWttzFALeJ82yPOt599Q5xHazNM86QnVQAAAAD8aNnuGQQAAAAALYcEAQAAAIAPCQIAAAAAHxIEAAAAAD4kCAAAAAB8SBAAAAAA+JAgAAAAAPAhQQAAAADgQ4IAAAAAwIcEAQAAAIAPCQIAAAAAHxIEAAAAAD7/H60TeGJgVKjdAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(tau.transpose(2, 0).transpose(1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def curl_wind(tau, dx, dy):\n", + " tau_x = 0.5 * (tau[:-1, :, 0] + tau[1:, :, 0])\n", + " print_debug_quantity(tau_x, \"tau_x\")\n", + " tau_y = 0.5 * (tau[:, :-1, 1] + tau[:, 1:, 1])\n", + " print_debug_quantity(tau_y, \"tau_y\")\n", + " dF2dX = (tau_y[1:] - tau_y[:-1]) / dx\n", + " print_debug_quantity(dF2dX, \"dF2dX\")\n", + " dF1dY = (tau_x[:, 1:] - tau_x[:, :-1]) / dy\n", + " print_debug_quantity(dF1dY, \"dF1dY\")\n", + " return dF2dX - dF1dY\n", + "\n", + "\n", + "def center_average_2D(u):\n", + " return 0.25 * (u[:-1, :-1] + u[:-1, 1:] + u[1:, :-1] + u[1:, 1:])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:19:28.445\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mtau_x: torch.Size([96, 121]) | -1.999326e-05 | -3.333091e-13 | 2.596290e-07 | 2.000000e-05\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:28.447\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mtau_y: torch.Size([97, 120]) | 0.000000e+00 | 0.000000e+00 | 0.000000e+00 | 0.000000e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:28.449\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdF2dX: torch.Size([96, 120]) | 0.000000e+00 | 0.000000e+00 | 0.000000e+00 | 0.000000e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:28.452\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdF1dY: torch.Size([96, 120]) | -2.595868e-11 | -3.789561e-19 | -6.739356e-13 | 2.595844e-11\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:28.458\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mWind curl_stagg: torch.Size([96, 120]) | -2.595844e-11 | 3.789561e-19 | -6.739356e-13 | 2.595868e-11\u001b[0m\n", + "\u001b[32m2023-07-11 18:19:28.463\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mWind Forcing: torch.Size([95, 119]) | -7.908486e-10 | 1.164619e-17 | 0.000000e+00 | 7.908477e-10\u001b[0m\n" + ] + } + ], + "source": [ + "curl_stagg = curl_wind(tau, domain.dx, domain.dy)\n", + "print_debug_quantity(curl_stagg, \"Wind curl_stagg\")\n", + "wind_forcing = center_average_2D(curl_stagg) / (\n", + " pde_params.f0 * height_params.heights[0]\n", + ")\n", + "print_debug_quantity(wind_forcing, \"Wind Forcing\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "pts = ax.pcolormesh(wind_forcing)\n", + "plt.colorbar(pts)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Initialize State" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Pressure" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "p_shape = (height_params.num_layers, domain.nx, domain.ny)\n", + "p_shape_flat = p_shape[:-2] + (domain.nx * domain.ny,)\n", + "# p = torch.zeros(p_shape).type(torch.float64)\n", + "p = torch.from_numpy(np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True)).type(\n", + " torch.float64\n", + ")\n", + "p_modes = torch.zeros_like(p).type(torch.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Vorticity" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "def laplacian_h_boundaries(f, fc):\n", + " return fc * (\n", + " torch.cat([f[..., 1, 1:-1], f[..., -2, 1:-1], f[..., 1], f[..., -2]], dim=-1)\n", + " - torch.cat([f[..., 0, 1:-1], f[..., -1, 1:-1], f[..., 0], f[..., -1]], dim=-1)\n", + " )\n", + "\n", + "\n", + "def laplacian_h_nobc(f):\n", + " return (\n", + " f[..., 2:, 1:-1]\n", + " + f[..., :-2, 1:-1]\n", + " + f[..., 1:-1, 2:]\n", + " + f[..., 1:-1, :-2]\n", + " - 4 * f[..., 1:-1, 1:-1]\n", + " )\n", + "\n", + "\n", + "def laplacian_h(f, fc):\n", + " delta_f = torch.zeros_like(f)\n", + "\n", + " # Laplacian w/o BCs\n", + " out = laplacian_h_nobc(f)\n", + " # print_debug_quantity(out, \"NABLA F (INTERIOR)\")\n", + " delta_f[..., 1:-1, 1:-1] = out\n", + " # print_debug_quantity(delta_f, \"NABLA F (FULL | No Bnds)\")\n", + "\n", + " # Laplacian w/ BCs\n", + " delta_f_bound = laplacian_h_boundaries(f, fc)\n", + " # print_debug_quantity(delta_f_bound, \"NABLA F (Bnds)\")\n", + " nx, ny = f.shape[-2:]\n", + "\n", + " delta_f[..., 0, 1:-1] = delta_f_bound[..., : ny - 2]\n", + " delta_f[..., -1, 1:-1] = delta_f_bound[..., ny - 2 : 2 * ny - 4]\n", + " delta_f[..., 0] = delta_f_bound[..., 2 * ny - 4 : nx + 2 * ny - 4]\n", + " delta_f[..., -1] = delta_f_bound[..., nx + 2 * ny - 4 : 2 * nx + 2 * ny - 4]\n", + " # print_debug_quantity(delta_f_bound, \"NABLA F (FULL)\")\n", + " return delta_f\n", + "\n", + "\n", + "def pressure_to_vorticity(p, A, pde_params):\n", + " # matrix multiply the nodes\n", + " Ap = -torch.einsum(\"ij,jkl->ikl\", A, p)\n", + " # print_debug_quantity(Ap, \"Ap\")\n", + "\n", + " # print(Ap.min(), Ap.max())\n", + "\n", + " # calculate beta term\n", + " beta_term = (pde_params.beta / pde_params.f0) * (domain.y - pde_params.y0)\n", + " # print_debug_quantity(beta_term, \"Beta Term\")\n", + "\n", + " # calculate Laplacian\n", + " lap_term = laplacian_h(p, pde_params.zfbc) / (pde_params.f0 * domain.dx) ** 2\n", + " # print_debug_quantity(lap_term, \"Lap Term\")\n", + "\n", + " # calculate vorticity\n", + " q = lap_term + Ap + beta_term\n", + " return q" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:49:40.638\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mPRESSURE: torch.Size([3, 97, 121]) | -4.332182e+00 | 3.335592e-02 | 3.041292e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:49:40.642\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mVORTICITY: torch.Size([3, 97, 121]) | -4.657202e-01 | -6.788327e-06 | -2.769970e-03 | 4.963626e-01\u001b[0m\n" + ] + } + ], + "source": [ + "print_debug_quantity(p, \"PRESSURE\")\n", + "q = pressure_to_vorticity(p, A_matrices.A, pde_params)\n", + "print_debug_quantity(q, \"VORTICITY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(q)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# def pressure_to_vorticity(p, A, pde_params):\n", + "# logger.debug(f\"Pressure --> Vorticity\")\n", + "# logger.debug(\"PRESSURE\")\n", + "# print_debug_quantity(p)\n", + "# logger.debug(\"A\")\n", + "# print_debug_quantity(A)\n", + "# # matrix multiply the nodes\n", + "# Ap = - torch.einsum(\"ij,jkl->ikl\", A, p)\n", + "# logger.debug(f\"Ap, {Ap.shape}\")\n", + "# print_debug_quantity(-Ap)\n", + "\n", + "# # print(Ap.min(), Ap.max())\n", + "\n", + "# # calculate beta term\n", + "# beta_term = (pde_params.beta / pde_params.f0) * (domain.y - pde_params.y0)\n", + "# logger.debug(f\"Beta, {beta_term.shape}\")\n", + "# print_debug_quantity(beta_term)\n", + "\n", + "# # calculate Laplacian\n", + "# logger.debug(\"PRESSURE\")\n", + "# print_debug_quantity(p)\n", + "# logger.debug(f\"zfbc: {pde_params.zfbc} | f0: {pde_params.f0} | nx\")\n", + "# lap_term = laplacian_h(p, pde_params.zfbc) / (pde_params.f0 * domain.dx)**2\n", + "# logger.debug(f\"Lap, {lap_term.shape}\")\n", + "# print_debug_quantity(lap_term)\n", + "\n", + "# # calculate vorticity\n", + "# q = lap_term + Ap + beta_term\n", + "# return q\n", + "\n", + "\n", + "def pressure_to_vorticity(p, A, pde_params):\n", + " # matrix multiply the nodes\n", + " Ap = -torch.einsum(\"ij,jkl->ikl\", A, p)\n", + "\n", + " # print(Ap.min(), Ap.max())\n", + "\n", + " # calculate beta term\n", + " beta_term = (pde_params.beta / pde_params.f0) * (domain.y - pde_params.y0)\n", + "\n", + " # calculate Laplacian\n", + " lap_term = laplacian_h(p, pde_params.zfbc) / (pde_params.f0 * domain.dx) ** 2\n", + "\n", + " # calculate vorticity\n", + " q = lap_term + Ap + beta_term\n", + " return q" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Compute Velocities" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "We are going to compute them on a staggered grid.\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "u &= -\\partial_y\\psi \\\\\n", + "v &= \\partial_y\\psi\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "def grad_perp(f):\n", + " \"\"\"Orthogonal gradient computed ...,on staggered grid.\"\"\"\n", + " return f[..., :-1] - f[..., 1:], f[..., 1:, :] - f[..., :-1, :]\n", + "\n", + "\n", + "def compute_velocities(p):\n", + " return grad_perp(p / (pde_params.f0 * domain.dx))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Compute Determinant Jacobian Term" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "## discrete spatial differential operators\n", + "def jacobi_h(f, g):\n", + " \"\"\"Arakawa discretisation of Jacobian J(f,g).\n", + " Scalar fields f and g must have the same dimension.\n", + " Grid is regular and dx = dy.\"\"\"\n", + " dx_f = f[..., 2:, :] - f[..., :-2, :]\n", + " dx_g = g[..., 2:, :] - g[..., :-2, :]\n", + " dy_f = f[..., 2:] - f[..., :-2]\n", + " dy_g = g[..., 2:] - g[..., :-2]\n", + " return (\n", + " (dx_f[..., 1:-1] * dy_g[..., 1:-1, :] - dx_g[..., 1:-1] * dy_f[..., 1:-1, :])\n", + " + (\n", + " (\n", + " f[..., 2:, 1:-1] * dy_g[..., 2:, :]\n", + " - f[..., :-2, 1:-1] * dy_g[..., :-2, :]\n", + " )\n", + " - (f[..., 1:-1, 2:] * dx_g[..., 2:] - f[..., 1:-1, :-2] * dx_g[..., :-2])\n", + " )\n", + " + (\n", + " (g[..., 1:-1, 2:] * dx_f[..., 2:] - g[..., 1:-1, :-2] * dx_f[..., :-2])\n", + " - (\n", + " g[..., 2:, 1:-1] * dy_f[..., 2:, :]\n", + " - g[..., :-2, 1:-1] * dy_f[..., :-2, :]\n", + " )\n", + " )\n", + " ) / 12.0" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:52:38.128\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mRHS DET JACOBIAN: torch.Size([3, 95, 119]) | -1.564097e-06 | -1.405443e-12 | -1.383592e-11 | 1.195297e-06\u001b[0m\n" + ] + } + ], + "source": [ + "rhs = 1.0 / (pde_params.f0 * domain.dx * domain.dy) * jacobi_h(q, p)\n", + "print_debug_quantity(rhs, \"RHS DET JACOBIAN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "def diffusion_term(p, pde_params, domain):\n", + " return pde_params.a_2 / pde_params.f0**2 / domain.dx**4 * laplacian_h_nobc(p)\n", + "\n", + "\n", + "def hyperdiffusion_term(p, pde_params, domain):\n", + " return (\n", + " -(pde_params.a_4 / pde_params.f0**2)\n", + " / domain.dx**6\n", + " * laplacian_h_nobc(laplacian_h(p, pde_params.zfbc))\n", + " )\n", + "\n", + "\n", + "def bottom_friction(p, pde_params, domain, height_params):\n", + " return (\n", + " pde_params.delta_ek\n", + " / (2 * np.abs(pde_params.f0) * domain.dx**2 * (-height_params.heights[-1]))\n", + " * laplacian_h_nobc(p[..., -1:, :, :])\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 18:55:04.114\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mLaplacian Term: torch.Size([3, 97, 121]) | -2.852461e+00 | -9.280515e-05 | 7.083754e-04 | 3.835035e+00\u001b[0m\n", + "\u001b[32m2023-07-11 18:55:04.119\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mDiffusion Term: torch.Size([3, 95, 119]) | -7.209133e-07 | -4.914557e-12 | 8.343140e-13 | 6.775439e-07\u001b[0m\n", + "\u001b[32m2023-07-11 18:55:04.122\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mBottom Friction: torch.Size([1, 95, 119]) | -1.221567e-09 | 4.609835e-13 | -2.387789e-12 | 1.503295e-09\u001b[0m\n" + ] + } + ], + "source": [ + "p_diff = p\n", + "\n", + "# calculate\n", + "delta2_p = laplacian_h(p_diff, pde_params.zfbc)\n", + "print_debug_quantity(delta2_p, \"Laplacian Term\")\n", + "if pde_params.a_2 != 0.0:\n", + " diff_term = diffusion_term(delta2_p, pde_params, domain)\n", + " print_debug_quantity(diff_term, \"Diffusion Term\")\n", + " rhs += diff_term\n", + "if pde_params.a_4 != 0.0:\n", + " hyperdiff_term = hyperdiffusion_term(delta2_p, pde_params, domain)\n", + " print_debug_quantity(hyperdiff_term, \"Diffusion Term\")\n", + " rhs += hyperdiff_term\n", + "\n", + "rhs[..., 0:1, :, :] += wind_forcing\n", + "bottom_term = bottom_friction(p, pde_params, domain, height_params)\n", + "print_debug_quantity(bottom_term, \"Bottom Friction\")\n", + "rhs[..., -1:, :, :] += bottom_term" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def advection_rhs(q, p):\n", + " rhs = 1.0 / (pde_params.f0 * domain.dx * domain.dy) * jacobi_h(q, p)\n", + "\n", + " # calculate\n", + " delta2_p = laplacian_h(p, pde_params.zfbc)\n", + " if pde_params.a_2 != 0.0:\n", + " rhs += diffusion_term(delta2_p, pde_params, domain)\n", + " if pde_params.a_4 != 0.0:\n", + " rhs += hyperdiffusion_term(delta2_p, pde_params, domain)\n", + "\n", + " rhs[..., 0:1, :, :] += wind_forcing\n", + " rhs[..., -1:, :, :] += bottom_friction(p, pde_params, domain, height_params)\n", + "\n", + " return rhs" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "# %timeit rhs = advection_rhs(q, p)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 19:03:37.372\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mRHS: torch.Size([3, 95, 119]) | -1.502200e-06 | -6.166335e-12 | 1.789505e-12 | 1.339342e-06\u001b[0m\n" + ] + } + ], + "source": [ + "advection_rhs_jitted = torch.jit.trace(advection_rhs, (q, p))\n", + "rhs = advection_rhs_jitted(q, p)\n", + "print_debug_quantity(rhs, \"RHS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_field(rhs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Time Derivatives" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 19:12:18.096\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mPRESSURE: torch.Size([3, 97, 121]) | -4.332182e+00 | 3.335592e-02 | 3.041292e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-11 19:12:18.117\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mVORTICITY: torch.Size([3, 97, 121]) | -4.657202e-01 | -6.788327e-06 | -2.769970e-03 | 4.963626e-01\u001b[0m\n" + ] + } + ], + "source": [ + "# initialize terms\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "q = pressure_to_vorticity(p, A_matrices.A, pde_params)\n", + "print_debug_quantity(q, \"VORTICITY\")\n", + "\n", + "# advect vorticity inside of the domain\n", + "# print(f\"Vorticity: {q.shape}\")\n", + "# print(f\"Pressure: {p.shape}\")\n", + "dq_over_f0 = F.pad(advection_rhs(q, p), (1, 1, 1, 1))\n", + "\n", + "# print(f\"RHS Vorticity: {dq_over_f0.shape}\")\n", + "\n", + "# solve helmholtz eq for pressure\n", + "rhs_helmholtz = torch.einsum(\"ij,jkl->ikl\", A_matrices.Cl2m, dq_over_f0)\n", + "dp_modes = F.pad(\n", + " inverse_elliptic_dst(rhs_helmholtz[..., 1:-1, 1:-1], helmoltz_dst), (1, 1, 1, 1)\n", + ")\n", + "# print(f\"dp (Modes): {dp_modes.shape}\")\n", + "\n", + "# ensure mass convervation\n", + "dalpha = (\n", + " alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1)).unsqueeze(-1)\n", + ").unsqueeze(-1)\n", + "# print(f\"dalpha: {dalpha.shape}\")\n", + "\n", + "dp_modes[..., :-1, :, :] += dalpha * homogeneous_sol\n", + "# print(f\"dp (Modes): {dp_modes.shape}\")\n", + "\n", + "dp = torch.einsum(\"ij,jkl->ikl\", A_matrices.Cm2l, dp_modes)\n", + "# print(f\"dp: {dp.shape}\")\n", + "\n", + "# update vorticity at the boundaries\n", + "dp_bound = torch.cat(\n", + " [dp[..., 0, 1:-1], dp[..., -1, 1:-1], dp[..., :, 0], dp[..., :, -1]], dim=-1\n", + ")\n", + "# print(f\"dp_bound: {dp_bound.shape}\")\n", + "delta_p_bound = laplacian_h_boundaries(\n", + " dp / (pde_params.f0 * domain.dx) ** 2, pde_params.zfbc\n", + ")\n", + "# print(f\"delta_p_bound: {delta_p_bound.shape}\")\n", + "dq_over_f0_bound = delta_p_bound - A_matrices.A @ dp_bound\n", + "# print(f\"dq_over_f_bound: {dq_over_f0_bound.shape}\")\n", + "\n", + "dq_over_f0[..., 0, 1:-1] = dq_over_f0_bound[..., : domain.ny - 2]\n", + "dq_over_f0[..., -1, 1:-1] = dq_over_f0_bound[..., domain.ny - 2 : 2 * domain.ny - 4]\n", + "dq_over_f0[..., 0] = dq_over_f0_bound[\n", + " ..., 2 * domain.ny - 4 : domain.nx + 2 * domain.ny - 4\n", + "]\n", + "dq_over_f0[..., -1] = dq_over_f0_bound[\n", + " ..., domain.nx + 2 * domain.ny - 4 : 2 * domain.nx + 2 * domain.ny - 4\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_field(dp)\n", + "\n", + "plot_field(dq_over_f0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "def time_derivative(q, p):\n", + " # advect vorticity inside of the domain\n", + " dq_over_f0 = advection_rhs(q, p)\n", + " print_debug_quantity(dq_over_f0, \"dq_f0\")\n", + " dq_over_f0 = F.pad(dq_over_f0, (1, 1, 1, 1))\n", + " print_debug_quantity(dq_over_f0, \"dq_f0\")\n", + "\n", + " # solve helmholtz eq for pressure\n", + " rhs_helmholtz = torch.einsum(\"ij,jkl->ikl\", A_matrices.Cl2m, dq_over_f0)\n", + " print_debug_quantity(rhs_helmholtz, \"rhs_helmholtz\")\n", + " dp_modes = inverse_elliptic_dst(rhs_helmholtz[..., 1:-1, 1:-1], helmoltz_dst)\n", + " dp_modes = F.pad(dp_modes, (1, 1, 1, 1))\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + "\n", + " # ensure mass convervation\n", + " dalpha = alpha_matrix @ dp_modes[..., :-1, :, :].mean((-2, -1))\n", + " print_debug_quantity(dalpha, \"dalpha\")\n", + " dalpha = dalpha.unsqueeze(-1).unsqueeze(-1)\n", + " print_debug_quantity(dalpha, \"dalpha\")\n", + " dp_modes[..., :-1, :, :] += dalpha * homogeneous_sol\n", + " print_debug_quantity(dp_modes, \"dp_modes\")\n", + " dp = torch.einsum(\"ij,jkl->ikl\", A_matrices.Cm2l, dp_modes)\n", + " print_debug_quantity(dp, \"dp\")\n", + "\n", + " # update vorticity at the boundaries\n", + " delta_p_bound = laplacian_h_boundaries(\n", + " dp / (pde_params.f0 * domain.dx) ** 2, pde_params.zfbc\n", + " )\n", + " print_debug_quantity(delta_p_bound, \"delta_p_bound\")\n", + "\n", + " dp_bound = torch.cat(\n", + " [dp[..., 0, 1:-1], dp[..., -1, 1:-1], dp[..., :, 0], dp[..., :, -1]], dim=-1\n", + " )\n", + " print_debug_quantity(dp_bound, \"dp_bound\")\n", + " dq_over_f0_bound = delta_p_bound - A_matrices.A @ dp_bound\n", + " print_debug_quantity(dp_bound, \"dp_bound\")\n", + "\n", + " dq_over_f0[..., 0, 1:-1] = dq_over_f0_bound[..., : domain.ny - 2]\n", + " dq_over_f0[..., -1, 1:-1] = dq_over_f0_bound[..., domain.ny - 2 : 2 * domain.ny - 4]\n", + " dq_over_f0[..., 0] = dq_over_f0_bound[\n", + " ..., 2 * domain.ny - 4 : domain.nx + 2 * domain.ny - 4\n", + " ]\n", + " dq_over_f0[..., -1] = dq_over_f0_bound[\n", + " ..., domain.nx + 2 * domain.ny - 4 : 2 * domain.nx + 2 * domain.ny - 4\n", + " ]\n", + "\n", + " return dq_over_f0, dp" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2023-07-11 19:48:15.601\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mPRESSURE: torch.Size([3, 97, 121]) | -4.332182e+00 | 3.335592e-02 | 3.041292e-02 | 3.561408e+00\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.607\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mVORTICITY: torch.Size([3, 97, 121]) | -4.657202e-01 | -6.788327e-06 | -2.769970e-03 | 4.963626e-01\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.611\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdq_f0: torch.Size([3, 95, 119]) | -1.502200e-06 | -6.166335e-12 | 1.789505e-12 | 1.339342e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.612\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdq_f0: torch.Size([3, 97, 121]) | -1.502200e-06 | -5.939373e-12 | 0.000000e+00 | 1.339342e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.614\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mrhs_helmholtz: torch.Size([3, 97, 121]) | -8.917591e-07 | -1.924375e-11 | 0.000000e+00 | 9.745410e-07\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.619\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdp_modes: torch.Size([3, 97, 121]) | -4.214962e-06 | 1.710896e-08 | 1.804562e-10 | 3.790947e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.621\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdalpha: torch.Size([2]) | -5.508371e-05 | -2.625944e-05 | -5.508371e-05 | 2.564840e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.622\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdalpha: torch.Size([2, 1, 1]) | -5.508371e-05 | -2.625944e-05 | -5.508371e-05 | 2.564840e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.623\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdp_modes: torch.Size([3, 97, 121]) | -4.214962e-06 | 1.702066e-08 | 2.185260e-10 | 3.790947e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.626\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdp: torch.Size([3, 97, 121]) | -5.169435e-06 | 2.948065e-08 | 2.266897e-08 | 5.236781e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.628\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdelta_p_bound: torch.Size([3, 432]) | -3.056796e-08 | 5.116914e-11 | 0.000000e+00 | 2.598716e-08\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.628\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdp_bound: torch.Size([3, 432]) | -9.428341e-10 | 1.644440e-09 | 1.693913e-09 | 4.182241e-09\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.629\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdp_bound: torch.Size([3, 432]) | -9.428341e-10 | 1.644440e-09 | 1.693913e-09 | 4.182241e-09\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.631\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdp: torch.Size([3, 97, 121]) | -5.169435e-06 | 2.948065e-08 | 2.266897e-08 | 5.236781e-06\u001b[0m\n", + "\u001b[32m2023-07-11 19:48:15.632\u001b[0m | \u001b[34m\u001b[1mDEBUG \u001b[0m | \u001b[36m__main__\u001b[0m:\u001b[36mprint_debug_quantity\u001b[0m:\u001b[36m14\u001b[0m - \u001b[34m\u001b[1mdq: torch.Size([3, 97, 121]) | -1.502200e-06 | -8.475074e-12 | -1.366953e-11 | 1.339342e-06\u001b[0m\n" + ] + } + ], + "source": [ + "# initialize terms\n", + "print_debug_quantity(p, \"PRESSURE\")\n", + "q = pressure_to_vorticity(p, A_matrices.A, pde_params)\n", + "print_debug_quantity(q, \"VORTICITY\")\n", + "\n", + "dq, dp = time_derivative(q, p)\n", + "print_debug_quantity(dp, \"dp\")\n", + "print_debug_quantity(dq, \"dq\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_field(dp)\n", + "plot_field(dq)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def one_step(q, p, dt):\n", + " # print(f\"VORTICITY:\", q.min(), q.max())\n", + " q_ = torch.clone(q)\n", + " logger.debug(\"Starting Time Step...\")\n", + " logger.debug(f\"q_f0\")\n", + " print_debug_quantity(q)\n", + " logger.debug(f\"p\")\n", + " print_debug_quantity(p)\n", + " logger.debug(\"Computing RHS...\")\n", + " dq, dp = time_derivative(q_, p)\n", + " logger.debug(f\"dq_f0\")\n", + " print_debug_quantity(dq)\n", + " logger.debug(f\"dp\")\n", + " print_debug_quantity(dp)\n", + " # plot_field(dp)\n", + " # plot_field(dq)\n", + " # print(f\"DERVORTICITY:\", dq.min(), dq.max())\n", + " # print(f\"VORTICITY:\", q.min(), q.max())\n", + "\n", + " # Euler Step\n", + " logger.debug(\"Euler Step...\")\n", + " dq_0, dp_0 = torch.clone(dq), torch.clone(dp)\n", + " q += dt * dq_0\n", + " p += dt * dp_0\n", + " logger.debug(f\"q_f0\")\n", + " print_debug_quantity(q)\n", + " logger.debug(f\"p\")\n", + " print_debug_quantity(p)\n", + "\n", + " # plot_field(p)\n", + " # plot_field(q)\n", + "\n", + " # 2nd Order Runge-Kutta Step\n", + " logger.debug(\"Computing RHS...\")\n", + " dq, dp = time_derivative(q, p)\n", + " logger.debug(f\"dq_f0\")\n", + " print_debug_quantity(dq)\n", + " logger.debug(f\"dp\")\n", + " print_debug_quantity(dp)\n", + " q += dt * 0.5 * (dq - dq_0)\n", + " p += dt * 0.5 * (dp - dp_0)\n", + " logger.debug(f\"q_f0\")\n", + " print_debug_quantity(q)\n", + " logger.debug(f\"p\")\n", + " print_debug_quantity(p)\n", + " # plot_field(p)\n", + " # plot_field(q)\n", + "\n", + " return q, p\n", + "\n", + "\n", + "# def one_step(q, p, dt):\n", + "# # print(f\"VORTICITY:\", q.min(), q.max())\n", + "# q_ = torch.clone(q)\n", + "\n", + "# dq, dp = time_derivative(q_, p)\n", + "\n", + "# # plot_field(dp)\n", + "# # plot_field(dq)\n", + "# # print(f\"DERVORTICITY:\", dq.min(), dq.max())\n", + "# # print(f\"VORTICITY:\", q.min(), q.max())\n", + "\n", + "\n", + "# # Euler Step\n", + "\n", + "# dq_0, dp_0 = torch.clone(dq), torch.clone(dp)\n", + "# q += dt * dq_0\n", + "# p += dt * dp_0\n", + "\n", + "# # plot_field(p)\n", + "# # plot_field(q)\n", + "\n", + "# # 2nd Order Runge-Kutta Step\n", + "# dq, dp = time_derivative(q, p)\n", + "\n", + "# q += dt * 0.5 * (dq - dq_0)\n", + "# p += dt * 0.5 * (dp - dp_0)\n", + "# # plot_field(p)\n", + "# # plot_field(q)\n", + "\n", + "# return q, p" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize terms\n", + "# p = torch.zeros((height_params.num_layers, domain.nx, domain.ny)).type(torch.float64)\n", + "p = torch.from_numpy(np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True)).type(\n", + " torch.float64\n", + ")\n", + "q = pressure_to_vorticity(p, A_matrices.A, pde_params).type(torch.float64)\n", + "\n", + "# dt = 1_200. # LR # 600 # HR\n", + "# q1, p1 = one_step(q, p, dt)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(ncols=3)\n", + "\n", + "for i in range(3):\n", + " ax[i].pcolormesh(p1[i], cmap=\"coolwarm\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "\n", + "fig, ax = plt.subplots(ncols=3)\n", + "\n", + "for i in range(3):\n", + " ax[i].pcolormesh(q1[i], cmap=\"coolwarm\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize terms\n", + "p0 = torch.zeros((height_params.num_layers, domain.nx, domain.ny)).type(torch.float64)\n", + "q0 = pressure_to_vorticity(p0, A_matrices.A, pde_params).type(torch.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dt = 1_200 # LR # 600 # HR\n", + "\n", + "freq_plot = 100 # LR\n", + "# freq_plot = 50 # HR\n", + "freq_checknan = 100\n", + "freq_log = 1000\n", + "n_years = 2\n", + "n_steps = int(n_years * 365 * 24 * 3600 / dt)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_diagnostics(q, p):\n", + " import matplotlib.pyplot as plt\n", + "\n", + " p_plot = torch.clone(p)\n", + " q_plot = torch.clone(q)\n", + " plt.ion()\n", + " plt.figure()\n", + " f, a = plt.subplots(1, 2)\n", + " u = (compute_velocities(p_plot)[0]).cpu().numpy()\n", + " um, uM = -1.1 * np.abs(u).max(), 1.1 * np.abs(u).max()\n", + " im = a[0].imshow(\n", + " u[0].T, cmap=\"bwr\", origin=\"lower\", vmin=um, vmax=uM, animated=True\n", + " )\n", + " a[0].set_title(\"zonal velocity\")\n", + " f.colorbar(im, ax=a[0])\n", + " q_plot = (q_plot * pde_params.f0).cpu().numpy()\n", + " qm, qM = -1.1 * np.abs(q_plot).max(), 1.1 * np.abs(q_plot).max()\n", + " im = a[1].imshow(\n", + " q_plot[0].T, cmap=\"bwr\", origin=\"lower\", vmin=qm, vmax=qM, animated=True\n", + " )\n", + " a[1].set_title(\"potential vorticity\")\n", + " f.colorbar(im, ax=a[1])\n", + " plt.tight_layout()\n", + " plt.show()\n", + " plt.pause(1)\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.notebook import trange\n", + "import time\n", + "\n", + "dt = 1_200 # LR # 600 # HR\n", + "\n", + "freq_plot = 100 # LR\n", + "# freq_plot = 50 # HR\n", + "freq_checknan = 100\n", + "freq_log = 1000\n", + "n_years = 2\n", + "n_steps = int(n_years * 365 * 24 * 3600 / dt)\n", + "\n", + "# initialize terms\n", + "p = torch.zeros((height_params.num_layers, domain.nx, domain.ny)).type(torch.float64)\n", + "p = torch.from_numpy(np.load(\"./p_380yrs_HRDS.npy\", allow_pickle=True)).type(\n", + " torch.float64\n", + ")\n", + "q = pressure_to_vorticity(p, A_matrices.A, pde_params).type(torch.float64)\n", + "t = 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t0 = time.time()\n", + "if freq_plot > 0:\n", + " # plot_diagnostics(q,p)\n", + "\n", + " with trange(1, n_steps + 1) as pbar:\n", + " for n in pbar:\n", + " q, p = one_step(q, p, dt)\n", + " t += dt\n", + "\n", + " if n % freq_checknan == 0 and torch.isnan(p).any():\n", + " raise ValueError(\"Stopping, NAN number in p at iteration {n}.\")\n", + "\n", + " # if freq_plot > 0 and n % freq_plot == 0:\n", + " # plot_diagnostics(q, p)\n", + "\n", + " logger.debug(f\"Time Step: {t}\")\n", + " print_debug_quantity(q)\n", + " print_debug_quantity(p)\n", + " if n == 10:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if freq_plot > 0:\n", + " import matplotlib.pyplot as plt\n", + "\n", + " plt.ion()\n", + " plt.figure()\n", + " f, a = plt.subplots(1, 2)\n", + " u = (compute_velocities(p)[0]).cpu().numpy()\n", + " um, uM = -1.1 * np.abs(u).max(), 1.1 * np.abs(u).max()\n", + " im = a[0].imshow(\n", + " u[0].T, cmap=\"bwr\", origin=\"lower\", vmin=um, vmax=uM, animated=True\n", + " )\n", + " a[0].set_title(\"zonal velocity\")\n", + " f.colorbar(im, ax=a[0])\n", + " q = (q * pde_params.f0).cpu().numpy()\n", + " qm, qM = -1.1 * np.abs(q).max(), 1.1 * np.abs(q).max()\n", + " im = a[1].imshow(\n", + " q[0].T, cmap=\"bwr\", origin=\"lower\", vmin=qm, vmax=qM, animated=True\n", + " )\n", + " a[1].set_title(\"potential vorticity\")\n", + " f.colorbar(im, ax=a[1])\n", + " plt.tight_layout()\n", + " plt.pause(5)\n", + "\n", + "times, outputs = [], []" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def time_derivatives(\n", + " q,\n", + " p,\n", + " matrices,\n", + "):\n", + " return q, p\n", + "\n", + "\n", + "out = time_derivatives(q, p)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:jax_eo_py310]", + "language": "python", + "name": "conda-env-jax_eo_py310-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/dev/eman/QG/ssh_free_run.ipynb b/notebooks/dev/eman/QG/ssh_free_run.ipynb new file mode 100644 index 0000000..57a157c --- /dev/null +++ b/notebooks/dev/eman/QG/ssh_free_run.ipynb @@ -0,0 +1,2061 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "d5bca1fd-b90e-43b2-90ba-4cf6ea2a6884", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "# SSH Free Run" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ef9b5897-79b7-41ac-8476-44ccc04243e1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import autoroot\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.scipy as jsp\n", + "from jax.config import config\n", + "import numpy as np\n", + "import numba as nb\n", + "import pandas as pd\n", + "import equinox as eqx\n", + "import finitediffx as fdx\n", + "import diffrax as dfx\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from einops import rearrange, repeat, reduce\n", + "from tqdm.notebook import tqdm, trange\n", + "from jaxtyping import Array, Float\n", + "\n", + "from jaxsw._src.operators.functional import advection as F_adv\n", + "from jaxsw._src.operators.functional import geostrophic as F_geos\n", + "from jaxsw._src.operators.functional import cgrid as F_cgrid\n", + "from jaxsw._src.operators.functional import grid as F_grid\n", + "from jaxsw._src.boundaries.helmholtz import enforce_boundaries_helmholtz\n", + "\n", + "sns.reset_defaults()\n", + "sns.set_context(context=\"talk\", font_scale=0.7)\n", + "config.update(\"jax_enable_x64\", True)\n", + "\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0dc829a9-a35c-49ca-8f95-aedb5ff5f61c", + "metadata": { + "user_expressions": [] + }, + "source": [ + "In this problem, we are looking at sea surface height (SSH) in relation to the Quasi-Geostrophic (QG) equations. These equations are a simplified form for the Navier-Stokes equations with approximations like *hydrostatic approximation*, *small aspect ratio*, and a *small Rossby number*. Ideally, these equations might be a decent approximation at mesoscale (100km - 10,000km). In this application, we will see how SSH propagates with the QG equations." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "692a7d6b-1de0-462e-9fe8-34a5105eec5b", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Equations\n", + "\n", + "\n", + "This is a very simplified equation but\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\partial_t q &= - \\det\\boldsymbol{J}(\\psi,q) - \\beta\\partial_x\\psi \\\\\n", + "\\psi &= \\frac{g}{f_0}\\eta \\\\\n", + "q &= \\nabla^2 \\psi - \\frac{f_0^2}{c_1^2}\\psi \\\\\n", + "\\psi &= \\frac{f_0}{g}\\eta \\\\\n", + "u &= -\\partial_y\\psi \\\\\n", + "v &= \\partial_x\\psi \\\\\n", + "f &= 2\\Omega\\sin\\theta_0 + \\frac{1}{R}2\\Omega\\cos\\theta_0 y \\\\\n", + "f_0 &= \\mathcal{E}[f] \\\\\n", + "L_R &= \\frac{c_1}{f_0}\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "where:\n", + "* $\\theta_0$ is the mean latitude\n", + "* $f_0=2\\Omega\\sin\\theta_0$ is the Coriolis parameter at mean latitude\n", + "* $\\beta=\\frac{1}{R}2\\Omega\\cos\\theta_0$ is the $\\beta$-plane approximation at mean latitude\n", + "* $L_R$ is the Rossby deformation radius\n", + "* $\\Omega$ is the angular frequency of rotation\n", + "* $R$ is the radius of the Earth\n", + "\n", + "Source:\n", + "* [Geophysical Fluid Dynamcis - Pedlosky](https://doi.org/10.1007/978-1-4612-4650-3)\n", + "* [Atmosphere and Oceanic Fluid Dynamics - Vallis](https://doi.org/10.1017/9781107588417)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f589e7b9-e033-41e7-b122-6d0a9ca6e8c8", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Read input SSH" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e6e092d-226d-433c-accf-2fc43f284514", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (time: 365, lat: 201, lon: 201)\n",
+       "Coordinates:\n",
+       "  * lon      (lon) float64 -65.0 -64.95 -64.9 -64.85 ... -55.1 -55.05 -55.0\n",
+       "  * lat      (lat) float64 33.0 33.05 33.1 33.15 33.2 ... 42.85 42.9 42.95 43.0\n",
+       "  * time     (time) datetime64[ns] 2012-10-01 2012-10-02 ... 2013-09-30\n",
+       "Data variables:\n",
+       "    ssh      (time, lat, lon) float64 ...
" + ], + "text/plain": [ + "\n", + "Dimensions: (time: 365, lat: 201, lon: 201)\n", + "Coordinates:\n", + " * lon (lon) float64 -65.0 -64.95 -64.9 -64.85 ... -55.1 -55.05 -55.0\n", + " * lat (lat) float64 33.0 33.05 33.1 33.15 33.2 ... 42.85 42.9 42.95 43.0\n", + " * time (time) datetime64[ns] 2012-10-01 2012-10-02 ... 2013-09-30\n", + "Data variables:\n", + " ssh (time, lat, lon) float64 ..." + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "file = \"/gpfswork/rech/yrf/commun/data_challenges/dc20a_osse/staging/natl60/NATL60-CJM165_GULFSTREAM_ssh_y2013.1y.nc\"\n", + "file = \"/Users/eman/code_projects/data/scratch/NATL60-CJM165_GULFSTREAM_ssh_y2013.1y.nc\"\n", + "\n", + "\n", + "# ds = xr.open_dataset('/Users/eman/code_projects/data/scratch/NATL60_GULFSTREAM_degraded.nc')\n", + "# ds = xr.open_dataset('/Users/eman/code_projects/data/scratch/NATL60-CJM165_GULFSTREAM_ssh_y2013.1y.nc', decode_times=False).assign_coords(time=lambda ds: pd.to_datetime(ds.time))\n", + "# ds = xr.open_dataset(\"/Users/eman/code_projects/data/scratch/NATL60-CJM165_GULFSTREAM_ssh_y2013.1y.decoded.nc\")\n", + "ds = xr.open_dataset(\n", + " file,\n", + " decode_times=False,\n", + ").assign_coords(time=lambda ds: pd.to_datetime(ds.time))\n", + "# ds = ds.coarsen(lon=3,lat=3).mean()\n", + "ds" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "572baa71", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds.ssh.isel(time=0).plot.pcolormesh(cmap=\"viridis\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "09a42be3-6671-4aeb-ab63-1c3170ff740a", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Strategy" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "1b0a998f-5229-4d24-8670-c625020ff64d", + "metadata": { + "user_expressions": [] + }, + "source": [ + "This is a slightly different problem than some of the previous problems.\n", + "\n", + "**Lat/Lon Domain**. Our domain is in \n", + "\n", + "**SSH**. In this case, we have sea surface height \"observations\" but they are not actually used within the QG equations. So we need to do a transformation into the QG domain which is in terms of the stream function, $\\psi$, and the potential vorticity, $q$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ce8154fc-8f1c-49d2-829f-2ffcf5669754", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Domain" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "dbcc0d50-f783-4e4e-a533-39500e41e568", + "metadata": { + "user_expressions": [] + }, + "source": [ + "Already, we have to do something slightly different than the previous tutorials. \n", + "We are dealing with latitude/longitude so we need to do a coordinate transformation to x,y space, i.e. a local tangent plane.\n", + "I have a specialized tutorial about how we do this in practice which can be found [here]() (**TODO**).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a3e10847-e6b0-48c5-9390-76c0c39d2d4b", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.domain.latlon import LatLonMeanDomain" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "351c8573-090f-4e0e-b52c-3615e69e8f47", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((201, 201), (201, 201))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lon = ds.lon.values\n", + "lat = ds.lat.values\n", + "ssh = jnp.asarray(ds.ssh[0].values.T)\n", + "\n", + "domain = LatLonMeanDomain(lat=lat, lon=lon)\n", + "\n", + "assert domain.size == (lon.shape[0], lat.shape[0])\n", + "\n", + "domain.size, ssh.shape" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "017e0ca2-f71b-4356-8644-f9e358053f24", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## State\n", + "\n", + "So here, we need to keep track of the following state variables: \n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\eta=\\boldsymbol{\\eta}(\\vec{\\mathbf{x}}) &&\n", + "\\psi=\\boldsymbol{\\psi}(\\vec{\\mathbf{x}}) &&\n", + "q = \\boldsymbol{q}(\\vec{\\mathbf{x}}) && &&\n", + "\\vec{\\mathbf{x}}\\in\\Omega,\\partial\\Omega\n", + "\\end{aligned}\n", + "$$ (eq:qg_state)\n", + "\n", + "where $\\eta$ is the Sea Surface Height, $\\psi$ is the stream function, and $q$ is the potential vorticity. \n", + "All of them are along the same domain.\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8e43c912-1f4f-4bf8-8e84-50d4574df717", + "metadata": { + "user_expressions": [] + }, + "source": [ + "We also have some constants that we need to keep track of:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "f_0\\in\\mathbb{R} &&\n", + "\\beta\\in\\mathbb{R}\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "where $f_0$ is the coriolis parameter and $\\beta$ is the beta-plane approximation at mean latitudes.\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "9982d53a-9c57-470e-85d9-8d1cd10e1d13", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Initial Conditions" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "7e53f208-ec7e-4851-9330-b9f2607e82fa", + "metadata": { + "user_expressions": [] + }, + "source": [ + "So these initial conditions are going to be slightly different than the previous cases: 1) we will initialize with real data and 2) we will have to \"precalculate\" some of the variables with the formulas listed above.\n", + "So, let's come back to this until after we define all of the functions necessary." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "85cdaf90", + "metadata": {}, + "source": [ + "### Boundary Conditions" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b662bac4", + "metadata": {}, + "source": [ + "More information can be found in the tutorial...\n", + "\n", + "```python\n", + "# q = enforce_boundaries_helmholtz(q, psi, beta=(f0/c1)**2)\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "84fd0532-1a30-4fca-976e-6f191ae9d8dc", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Stream Function" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8b256a89-955d-4ada-8965-9b664dbb468f", + "metadata": { + "user_expressions": [] + }, + "source": [ + "Here, we can directly relate the sea surface height to the stream function via this equation.\n", + "\n", + "$$\n", + "\\psi = \\frac{g}{f}\\eta\n", + "$$ \n", + "\n", + "We already have some (simple) specialized functions that can do the calculation for us.\n", + "Run the below cells to see the internal code." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "21283b7f-c7c4-482a-9ee6-42982dbd07d9", + "metadata": {}, + "outputs": [], + "source": [ + "# F_geos.ssh_to_streamfn??\n", + "# F_geos.streamfn_to_ssh??" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "379dcadb", + "metadata": {}, + "source": [ + "We will do the forward and inverse transformation.\n", + "We will also check to ensure that they are invertible." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5eb2c404-7626-479b-9cca-0831a1dc25d6", + "metadata": {}, + "outputs": [], + "source": [ + "# forward transformation\n", + "psi = F_geos.ssh_to_streamfn(jnp.asarray(ssh), f0=domain.f0)\n", + "\n", + "# inverse transform\n", + "ssh_ = F_geos.streamfn_to_ssh(psi, f0=domain.f0)\n", + "\n", + "# check the inverse transformation\n", + "np.testing.assert_array_almost_equal(ssh, ssh_)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "e508c36a-e985-4b82-a1bd-1c05f9486f3e", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Stream Function and Potential Vorticity" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "455bfd3f-b7ab-441f-91c8-a462b0d765c9", + "metadata": { + "user_expressions": [] + }, + "source": [ + "The potential vorticity is related to the stream function via the following function.\n", + "\n", + "$$\n", + "q = \\nabla^2\\psi - \\frac{f_0^2}{c_1^2}\\psi\n", + "$$\n", + "\n", + "We can think of this as the HelmHoltz decomposition because we have the form of \n", + "\n", + "$$\n", + "\\left(\\alpha\\boldsymbol{\\nabla} - \\beta\\right)\n", + "$$" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f93cb8f4", + "metadata": {}, + "source": [ + "#### Forward Transformation" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "465f7bbe", + "metadata": {}, + "source": [ + "Below we have a convenience function for calculate this transformation.\n", + "Uncomment the below code to see what it looks like under the hood." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "316be736-15de-463b-9094-90457fbeca32", + "metadata": {}, + "outputs": [], + "source": [ + "# F_geos.streamfn_to_pvort??" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "80518fff", + "metadata": {}, + "source": [ + "Now, we can apply the function on the stream function to get the potential vorticity." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "da0949da-7bc1-4edd-a1ac-dfb6b81702b4", + "metadata": {}, + "outputs": [], + "source": [ + "c1 = 1.5\n", + "q = F_geos.streamfn_to_pvort(\n", + " psi, dx=domain.dx_mean, dy=domain.dx_mean, f0=domain.f0, c1=c1, accuracy=1\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8bddfcf8-66d0-4919-83fd-c223498590da", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Inverse Transformation" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "93239f3a", + "metadata": {}, + "source": [ + "We are trying to solve an inversion problem of the type:\n", + "\n", + "$$\n", + "\\mathbf{u} = \\mathbf{L}^{-1}\\mathbf{b}\n", + "$$\n", + "\n", + "where $\\mathbf{L}=\\left(\\alpha\\boldsymbol{\\nabla} - \\beta\\right)$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "46d7ef3d", + "metadata": {}, + "source": [ + "We will use an approximate method to solve for the potential vorticity.\n", + "We can check to see if this works using our Discrete Sine Transformation framework." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fcfef0e4-9683-441f-bd7d-56099b4432ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.7462298274040222e-10\n", + "1.5543122344752192e-15\n" + ] + } + ], + "source": [ + "psi_rec = F_geos.pvort_to_streamfn(\n", + " q,\n", + " psi,\n", + " dx=domain.dx_mean,\n", + " dy=domain.dx_mean,\n", + " f0=domain.f0,\n", + " c1=c1,\n", + " accuracy=1,\n", + ")\n", + "\n", + "print(np.max(np.abs(psi_rec - psi)))\n", + "\n", + "ssh_rec = F_geos.streamfn_to_ssh(psi_rec, f0=domain.f0)\n", + "# np.testing.assert_array_almost_equal(psi, psi_rec)\n", + "\n", + "print(np.max(np.abs(ssh_rec - ssh)))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f783a490", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(ncols=3, figsize=(9, 3))\n", + "\n", + "ax[0].pcolormesh(ssh.T)\n", + "ax[0].set(title=\"True SSH\")\n", + "\n", + "ax[1].pcolormesh(ssh_rec.T)\n", + "ax[1].set(title=\"Reconstructed SSH\")\n", + "\n", + "ax[2].pcolormesh(np.abs(ssh_rec - ssh).T, cmap=\"Reds\")\n", + "ax[2].set(title=\"Error\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "28ce6e55", + "metadata": {}, + "source": [ + "### Forcing" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "920cca0a", + "metadata": {}, + "source": [ + "I am going to use the simplest assumption available.\n", + "We will use a steady zonal wind that is expressed as:\n", + "\n", + "$$\n", + "\\boldsymbol{F}(x,y) = - \\tau \\sin \\left( \\frac{2\\pi y}{L}\\right)\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ed404bc0", + "metadata": {}, + "outputs": [], + "source": [ + "def forcing_zonal(y, L, tau):\n", + " return -tau * jnp.sin((2 * jnp.pi * y) / L)\n", + "\n", + "\n", + "def matrix(f, x, y):\n", + " mapx1 = jax.vmap(lambda x, y: f(x, y), in_axes=(0, None), out_axes=0)\n", + " mapx2 = jax.vmap(lambda x, y: mapx1(x, y), in_axes=(None, 0), out_axes=1)\n", + "\n", + " return mapx2(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "a35154af", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(1111984.17303058, dtype=float64)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "domain.coords[1].max()" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "f664ee16", + "metadata": {}, + "outputs": [], + "source": [ + "import functools as ft\n", + "\n", + "\n", + "# @ft.partial(jax.jit, static_argnames=(\"x\", \"y\", \"L\"))\n", + "def forcing(tau, x, y, L):\n", + " # get y coordinate\n", + " # characteristic length scale\n", + " # x = domain.coords[0]\n", + " # y = domain.coords[1]\n", + "\n", + " f = lambda x, y: forcing_zonal(y, L, tau)\n", + " return matrix(f, x, y)\n", + "\n", + "\n", + "tau = 0.0\n", + "F = forcing(tau, domain.coords[0], domain.coords[1], domain.coords[1].max())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b4774962", + "metadata": {}, + "source": [ + "## State\n", + "\n", + "Seeing the above strategy, we see that we are stepping through the potential vorticity. \n", + "So this is the variable that will make up our state." + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "1fea2071", + "metadata": {}, + "outputs": [], + "source": [ + "import equinox as eqx\n", + "\n", + "\n", + "class State(eqx.Module):\n", + " q: Array" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "6369cd3d", + "metadata": {}, + "source": [ + "## Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "e39e9b6e", + "metadata": {}, + "outputs": [], + "source": [ + "class Params(eqx.Module):\n", + " c1: Array = eqx.static_field()\n", + " f0: Array = eqx.static_field()\n", + " beta: Array = eqx.static_field()\n", + " eta: Array\n", + " F: Array = eqx.static_field()\n", + " domain: LatLonMeanDomain" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "3fbb7c8c", + "metadata": {}, + "source": [ + "### Initial State\n", + "\n", + "Most of the work will go into getting into transforming the SSH into the initial state.\n", + "So we can create a few specialized functions to do so.\n", + "\n", + "First, we need to extract the dataarray or dataset to get it into a LatLon Domain and a jax array." + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "df1b5434", + "metadata": {}, + "outputs": [], + "source": [ + "def xrda_to_latlon_field(da: xr.DataArray):\n", + " # get domain\n", + " domain = LatLonMeanDomain(lat=da.lat.values, lon=da.lon.values)\n", + "\n", + " # transpose to get the correct dimensions\n", + " da = da.transpose(\"lon\", \"lat\")\n", + "\n", + " # get field\n", + " return jnp.asarray(da), domain\n", + "\n", + "\n", + "def xrds_to_latlon_field(ds: xr.DataArray, variable: str, time: str):\n", + " return xrda_to_latlon_field(da=ds[variable].sel(time=time))" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "e6ca7cdb", + "metadata": {}, + "outputs": [], + "source": [ + "# using the xr.DataArray\n", + "eta_init, domain = xrda_to_latlon_field(ds.ssh[0])\n", + "\n", + "assert eta_init.shape == domain.size\n", + "\n", + "# using the xr.Dataset\n", + "eta_init, domain = xrds_to_latlon_field(ds, \"ssh\", \"2012-10-01\")\n", + "\n", + "assert eta_init.shape == domain.size" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "0a3392e9", + "metadata": {}, + "outputs": [], + "source": [ + "def init_state(params):\n", + " # parse domain\n", + " dx = dy = params.domain.dx_mean\n", + "\n", + " # parse parameters\n", + " c1, f0, eta = params.c1, params.f0, params.eta\n", + "\n", + " # SSH -->> Stream Function\n", + " psi = F_geos.ssh_to_streamfn(eta, f0=f0)\n", + "\n", + " # Stream Function -->> Potential Vorticity\n", + " q = F_geos.streamfn_to_pvort(psi, dx=dx, dy=dy, f0=f0, c1=c1, accuracy=1)\n", + "\n", + " # enforce boundary conditions\n", + " q = enforce_boundaries_helmholtz(q, psi, beta=(f0 / c1) ** 2)\n", + "\n", + " # return state module\n", + " return State(q=q)" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "c2287671", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize parameters\n", + "params = Params(\n", + " c1=1.5, f0=domain.f0, beta=domain.beta, domain=domain, eta=eta_init, F=F\n", + ")\n", + "\n", + "# initialize state\n", + "state_init = init_state(params=params)\n", + "\n", + "# check that we can update the state\n", + "state_new = eqx.tree_at(lambda x: x.q, state_init, state_init.q + 1)\n", + "np.testing.assert_array_equal(state_new.q, state_init.q + 1)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "151cacc0", + "metadata": {}, + "source": [ + "It's also useful to calculate the SSH from the PV. This will be useful later in the analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "52392b75", + "metadata": {}, + "outputs": [], + "source": [ + "def ssh_from_state(state, params, axis: int = -1) -> Array:\n", + " dx = dy = params.domain.dx_mean\n", + " f0, c1, eta = params.f0, params.c1, params.eta\n", + " q = state.q\n", + "\n", + " if jnp.ndim(q) > 2:\n", + " q = q[axis]\n", + "\n", + " psi_bv = F_geos.ssh_to_streamfn(ssh=eta, f0=f0)\n", + "\n", + " psi = F_geos.pvort_to_streamfn(q, psi_bv, dx=dx, dy=dy, f0=f0, c1=c1)\n", + "\n", + " return F_geos.streamfn_to_ssh(psi, f0=domain.f0)" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "id": "f566b663", + "metadata": {}, + "outputs": [], + "source": [ + "# using the xr.DataArray\n", + "eta_init, domain = xrda_to_latlon_field(ds.ssh[0])\n", + "\n", + "# initialize parameters\n", + "params = Params(\n", + " c1=1.5, f0=domain.f0, beta=domain.beta, domain=domain, eta=eta_init, F=F\n", + ")\n", + "\n", + "# initialize state\n", + "state_init = init_state(params=params)\n", + "\n", + "eta_new = ssh_from_state(state_init, params)\n", + "\n", + "np.testing.assert_array_almost_equal(eta_new, eta_init, decimal=9)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "48f85b08-83fd-48ab-861c-85032a430607", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Right Hand Side" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "808bb026-b78e-47b8-a3cc-c165a92ccf71", + "metadata": { + "user_expressions": [] + }, + "source": [ + "We have the advection term which is the dot product between the geostrophic velocities and the gradient of the \n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\begin{pmatrix}\n", + "u \\\\ v\n", + "\\end{pmatrix} \\cdot\n", + "\\nabla q &= u \\partial_x q + v \\partial_y q\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "if we plug in the actual $u,v$ terms, we get\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\begin{pmatrix}\n", + "u \\\\ v\n", + "\\end{pmatrix} \\cdot\n", + "\\nabla q &= - \\partial_y\\psi\\partial_y q + \\partial_x\\psi\\partial_y q \\\\\n", + "&= \\partial_x\\psi\\partial_y q - \\partial_y\\psi\\partial_y q\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "7e252f30-28d7-49b2-80ee-21d7ce014aee", + "metadata": { + "user_expressions": [] + }, + "source": [ + "Note, there is a famous common term that is used for a short hand notation. It's call the **determinant Jacobian** which is denoted as:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\det J(\\psi, q) &= \n", + "\\frac{\\partial\\psi}{\\partial_x}\\frac{\\partial q}{\\partial_y} -\n", + "\\frac{\\partial\\psi}{\\partial_y}\\frac{\\partial q}{\\partial_x} \\\\\n", + "&= \n", + "\\frac{\\partial}{\\partial_x}\\left(\\psi\\frac{\\partial q}{\\partial_y}\\right) -\n", + "\\frac{\\partial}{\\partial_y}\\left(\\psi\\frac{\\partial q}{\\partial_x}\\right) \\\\\n", + "&= \n", + "\\frac{\\partial}{\\partial_y}\\left(q\\frac{\\partial\\psi}{\\partial_x}\\right) -\n", + "\\frac{\\partial}{\\partial_x}\\left(q\\frac{\\partial\\psi}{\\partial_y}\\right)\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "We can see that this is exactly equal to the above expression when we set $u=-\\partial_y\\psi$ and $v=\\partial_x\\psi$\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\det J(\\psi, q) &= \n", + "v\\frac{\\partial q}{\\partial_y} +\n", + "u \\frac{\\partial q}{\\partial_x} \\\\\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "5ea05580-aafe-4497-acca-ea6d58f01834", + "metadata": { + "user_expressions": [] + }, + "source": [ + "### Upwind Scheme" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "fa446c73-6f38-49b1-aa20-3a9a2ed14d5e", + "metadata": { + "user_expressions": [] + }, + "source": [ + "This term is an advection equation. So we can use the upwind scheme to deal with this.\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "u\\partial_x q := u^+ D_x^- q + u^- D_x^+ q \\\\\n", + "v\\partial_y q := v^+ D_y^- q + v^- D_y^+ q \\\\\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "where:\n", + "* $u^+,v^+ = u>0,v>0$\n", + "* $u^-,v^-=u<0,v<0$\n", + "* $D_x^-, D_y^-$ is a backward finite difference scheme\n", + "* $D_x^+, D_y^-$ is a forward finite difference scheme\n", + "\n", + "Source: [Wikipedia](https://en.wikipedia.org/wiki/Upwind_scheme) | [Blog](https://en.wikipedia.org/wiki/Upwind_scheme)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "eb6ea648-8258-4151-af90-a82e18214249", + "metadata": { + "user_expressions": [] + }, + "source": [ + "#### Plus/Minus\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\text{u-velocity}: && && u^+ &= \\max(u,0) && && u^- = \\min(u,0) \\\\\n", + "\\text{v-velocity}: && && v^+ &= \\max(v,0) && && v^- = \\min(v,0)\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "cf02e90a-b031-4a2f-9afe-43356c844b35", + "metadata": {}, + "source": [ + "We have a convenience function to see how it is calculated below.\n", + "Uncomment the code in the cell below to see how it works." + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "5100c158-d24b-4ba2-a124-70096f7194ec", + "metadata": {}, + "outputs": [], + "source": [ + "# F_adv.advection_upwind_2D??\n", + "# F_adv.advection_upwind_1D??" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "f199de80-6bfc-46a2-a6d6-4285de2758d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.3750228959774459e-07 1.3953795940515203e-07\n" + ] + } + ], + "source": [ + "def advection_term_upwind(q, psi, dx, dy, **kwargs) -> Array:\n", + " # u,v schemes\n", + " u, v = F_geos.uv_velocity(psi, dx=dx, dy=dy, accuracy=kwargs.get(\"accuracy\", 1))\n", + "\n", + " # # Average Center Pixel\n", + " # u = F_grid.center_average_2D(u, padding=\"same\")\n", + " # v = F_grid.center_average_2D(v, padding=\"same\")\n", + "\n", + " # # Average East-West & North-South\n", + " # u = F_grid.x_average_2D(u, padding=\"same\")\n", + " # v = F_grid.y_average_2D(v, padding=\"same\")\n", + "\n", + " # print(u_avg.shape, v_avg.shape, q.shape)\n", + "\n", + " adv_term = F_adv.advection_upwind_2D(\n", + " q, a=u, b=v, step_size=(dx, dy), way=kwargs.get(\"way\", 1)\n", + " )\n", + "\n", + " rhs = jnp.zeros_like(q)\n", + "\n", + " # rhs = rhs.at[1:-1, 1:-1].set(udq_dx[1:-1, 1:-1] + vdq_dy[1:-1, 1:-1])\n", + " rhs = rhs.at[1:-1, 1:-1].set(adv_term[1:-1, 1:-1])\n", + "\n", + " return rhs\n", + "\n", + "\n", + "rhs = advection_term_upwind(\n", + " q, psi, domain.dx_mean, domain.dx_mean, method=\"central\", way=1\n", + ")\n", + "\n", + "print(rhs.min(), rhs.max())" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "71798612", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "pts = ax.pcolormesh(rhs.T, cmap=\"gray\")\n", + "ax.set(title=\"Advection (RHS)\")\n", + "plt.colorbar(pts)\n", + "\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d759aecb-4f10-42aa-8548-b8adcc374012", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Equation of Motion" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "d7eca152-0817-4ef0-aa5b-87420a6a7347", + "metadata": { + "user_expressions": [] + }, + "source": [ + "Recall the PDE we want to solve.\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\partial_t q &= - \\det\\boldsymbol{J}(\\psi,q) - \\beta\\partial_x\\psi \\\\\n", + "\\psi &= \\frac{g}{f_0}\\eta\n", + "\\end{aligned}\n", + "$$\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "61bc8a49-c9b2-4614-b6f2-135bac8bcbf5", + "metadata": { + "user_expressions": [] + }, + "source": [ + "Here, we outline a quick algorithm for how we can step through calculating the RHS of the PDE\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\text{SSH, PV:} &&\\eta^n,q^n &= \\ldots \\\\\n", + "\\text{SF:} && \\psi^n_b &= f(\\eta^n) \\\\\n", + "\\text{SF:} && \\psi^{n} &= \\text{LinearSolve}(q^{n}, \\psi^n_b) \\\\\n", + "\\text{RHS:} && rhs^n &= \\mathbf{rhs}(\\psi^n, q^n) \\\\\n", + "\\text{PV:} && q^{n+1} &= q^{n} + \\Delta t \\hspace{1mm} rhs\n", + "\\end{aligned}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "e0f0fa36-5463-43c2-b889-14a53a527744", + "metadata": {}, + "outputs": [], + "source": [ + "# from jaxsw._src.operators.functional.fd import jacobian" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "58190c7d-be79-48c2-a2d4-598dd2ccd7af", + "metadata": {}, + "outputs": [], + "source": [ + "from jaxsw._src.domain.base import Domain\n", + "from jaxsw._src.models.pde import DynamicalSystem\n", + "from jaxsw._src.domain.time import TimeDomain\n", + "\n", + "\n", + "class QG(DynamicalSystem):\n", + " @staticmethod\n", + " def equation_of_motion(t: float, state: State, args):\n", + " \"\"\"Quasi-Geostrophic Equations\n", + "\n", + " Equation:\n", + " ∂q/∂t + det J(Ψ,q) = -β ∂Ψ/∂x\n", + " q = ∇²Ψ - (f₀²/c₁²) Ψ\n", + " Ψ = (f₀/g) η\n", + " \"\"\"\n", + " # parse params\n", + " params = args\n", + " dx = dy = params.domain.dx_mean\n", + " f0, beta, c1, eta, F = params.f0, params.beta, params.c1, params.eta, params.F\n", + "\n", + " # parse state\n", + " q = state.q\n", + "\n", + " # ssh -> stream function\n", + " psi_bv = F_geos.ssh_to_streamfn(ssh=eta, f0=f0)\n", + "\n", + " # potential vorticity -> stream function\n", + " psi = F_geos.pvort_to_streamfn(q, psi_bv, dx=dx, dy=dy, f0=f0, c1=c1)\n", + "\n", + " # upwind scheme for advection\n", + " q_rhs = -advection_term_upwind(q=q, psi=psi, dx=dx, dy=dy, way=1)\n", + "\n", + " # beta term\n", + " _, v = F_geos.uv_velocity(psi, dx=dx, dy=dy)\n", + "\n", + " q_rhs += -beta * v\n", + "\n", + " q_rhs += F\n", + "\n", + " # update state\n", + " state = eqx.tree_at(lambda x: x.q, state, q_rhs)\n", + "\n", + " return state" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "db247b84", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[-0., -0., -0., ..., 0., 0., 0.],\n", + " [-0., -0., -0., ..., 0., 0., 0.],\n", + " [-0., -0., -0., ..., 0., 0., 0.],\n", + " ...,\n", + " [-0., -0., -0., ..., 0., 0., 0.],\n", + " [-0., -0., -0., ..., 0., 0., 0.],\n", + " [-0., -0., -0., ..., 0., 0., 0.]], dtype=float64)" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "F" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "8ddb6a7d-8c72-4fe3-87fa-8717ca4f257d", + "metadata": {}, + "outputs": [], + "source": [ + "# SPATIAL DISCRETIZATION\n", + "# using the xr.DataArray\n", + "eta_init, domain = xrda_to_latlon_field(ds.ssh[0])\n", + "\n", + "# initialize parameters\n", + "params = Params(\n", + " c1=1.5, f0=domain.f0, beta=domain.beta, domain=domain, eta=eta_init, F=F\n", + ")\n", + "\n", + "# initialize state\n", + "state_init = init_state(params=params)\n", + "# right hand side\n", + "state_out = QG.equation_of_motion(0, state_init, params)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "27f25f55-1aee-40b8-9439-618303972eec", + "metadata": {}, + "outputs": [], + "source": [ + "# plot_state_2D(state_out)\n", + "# plot_state_3D(state_out)\n", + "# plot_vectorfield_2D(state_out)" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "0fe4692d-3937-47d6-9d6b-c6f35d6c876e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "pts = ax.imshow(state_out.q.T, origin=\"lower\")\n", + "plt.colorbar(pts)\n", + "\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "24c7bde1-2fd6-41fd-9204-1693a1dd61f2", + "metadata": { + "user_expressions": [] + }, + "source": [ + "## Time Stepping with Diffrax (All together)" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "87a4418c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3600.0" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dt_ = np.timedelta64(1, \"h\")\n", + "pd.to_timedelta(dt_).total_seconds()" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "d6d50964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10.0" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "600 / 60" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "8bc3cf03-b273-475a-a647-0f566ecffc1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step Size (dt): 10 minutes\n", + "Tmax: 1 days\n", + "Tmax: 86,400.0 seconds | 1 day(s)\n" + ] + } + ], + "source": [ + "# TEMPORAL DISCRETIZATION\n", + "# initialize temporal domain\n", + "\n", + "\n", + "num_minutes = 10\n", + "dt = pd.to_timedelta(num_minutes, unit=\"minutes\").total_seconds()\n", + "debug = False\n", + "num_days = 1\n", + "tmin = 0.0\n", + "tmax = pd.to_timedelta(num_days, unit=\"days\").total_seconds()\n", + "\n", + "num_hours_save = 12\n", + "dt_save = pd.to_timedelta(num_hours_save, unit=\"hours\").total_seconds()\n", + "\n", + "print(f\"Step Size (dt): {int(dt/60)} minutes\")\n", + "print(f\"Tmax: {num_days} days\")\n", + "print(f\"Tmax: {tmax:,} seconds | {int(tmax/60/60/24)} day(s)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "f157c0c8-ec13-40b7-baf0-6f25293222b8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "TimeDomain(tmin=0.0, tmax=86400.0, dt=600.0)" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# time domain\n", + "t_domain = TimeDomain(tmin=tmin, tmax=tmax, dt=dt)\n", + "\n", + "\n", + "t_domain" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "99071485-d844-4a0c-9ce1-34e4d6b18c5c", + "metadata": {}, + "outputs": [], + "source": [ + "num_hours_save = 6\n", + "dt_save = pd.to_timedelta(num_hours_save, unit=\"hours\").total_seconds()\n", + "\n", + "ts = jnp.arange(tmin, tmax, dt_save)\n", + "saveat = dfx.SaveAt(ts=ts)" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "7de9cf41-a5d2-4082-8ab2-f91ec705f0b3", + "metadata": {}, + "outputs": [], + "source": [ + "# SPATIAL DISCRETIZATION\n", + "# initialize state\n", + "solver = dfx.Tsit5() #\n", + "# max_steps = 10\n", + "# DYNAMICAL SYSTEM\n", + "dyn_model = QG(t_domain=t_domain, saveat=saveat, solver=solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "7f1b67ac-2a91-44c4-8cf7-afd06d7e5413", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 56.4 s, sys: 1.07 s, total: 57.4 s\n", + "Wall time: 57.5 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "# using the xr.DataArray\n", + "eta_init, domain = xrda_to_latlon_field(ds.ssh[0])\n", + "\n", + "# initialize parameters\n", + "params = Params(\n", + " c1=1.5, f0=domain.f0, beta=domain.beta, domain=domain, eta=eta_init, F=F\n", + ")\n", + "\n", + "# initialize state\n", + "state_init = init_state(params=params)\n", + "\n", + "state_sol = dyn_model.integrate(state_init, dt, params, max_steps=10_000)" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "6e972709-f912-49c9-bba5-bd3ea98d3e45", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(4, 201, 201)" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state_sol.q.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "4badb0a8-2fbc-44dd-a415-7529ef315f33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array(-0.36652181, dtype=float64), Array(1.16310116, dtype=float64))" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ssh_t = ssh_from_state(state_sol, params)\n", + "\n", + "ssh_t.min(), ssh_t.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "cf00cfae-21a0-432a-be41-69193755c790", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(ncols=3, nrows=2, figsize=(10, 5))\n", + "\n", + "#\n", + "ds.ssh[0].plot.pcolormesh(ax=ax[0, 0], cmap=\"viridis\")\n", + "ds.ssh[0].plot.contour(ax=ax[0, 0], cmap=\"viridis\")\n", + "\n", + "ax[0, 0].set(title=f\"SSH ($t=0$ days)\")\n", + "ax[0, 1].contour(ds.ssh[num_days].values, cmap=\"viridis\")\n", + "pts = ax[0, 1].imshow(ds.ssh[num_days].values, origin=\"lower\", cmap=\"viridis\")\n", + "plt.colorbar(pts)\n", + "ax[0, 1].set(title=f\"True SSH ($t={num_days}$ days)\")\n", + "\n", + "ax[0, 2].contour(np.flipud(ssh_t.T), cmap=\"viridis\")\n", + "pts = ax[0, 2].imshow(np.flipud(ssh_t.T), cmap=\"viridis\")\n", + "ax[0, 2].set(title=f\"QG Model ($t={num_days}$ days)\")\n", + "plt.colorbar(pts)\n", + "\n", + "\n", + "pts = ax[1, 0].imshow(np.abs(ds.ssh[0].values.T - ds.ssh[num_days].values), cmap=\"Reds\")\n", + "plt.colorbar(pts)\n", + "ax[1, 0].set(title=f\"Diff SSH (T - $t_0$)\")\n", + "\n", + "pts = ax[1, 1].imshow(np.abs(ds.ssh[0].values.T - ssh_t.T), cmap=\"Reds\")\n", + "plt.colorbar(pts)\n", + "ax[1, 1].set(title=f\"Diff QG (T - $t_0$)\")\n", + "\n", + "\n", + "pts = ax[1, 2].imshow(np.abs(ds.ssh[num_days].values - ssh_t.T), cmap=\"Reds\")\n", + "plt.colorbar(pts)\n", + "ax[1, 2].set(title=f\"Diff QG vs SSH (@T={num_days})\")\n", + "\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c499d88", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d5f83c0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "jax_eo_py310", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/poetry.lock b/poetry.lock index 7d1e6b1..bde8d4b 100644 --- a/poetry.lock +++ b/poetry.lock @@ -203,36 +203,33 @@ lxml = ["lxml"] [[package]] name = "black" -version = "23.3.0" +version = "23.7.0" description = "The uncompromising code formatter." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "black-23.3.0-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:0945e13506be58bf7db93ee5853243eb368ace1c08a24c65ce108986eac65915"}, - {file = "black-23.3.0-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:67de8d0c209eb5b330cce2469503de11bca4085880d62f1628bd9972cc3366b9"}, - {file = "black-23.3.0-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:7c3eb7cea23904399866c55826b31c1f55bbcd3890ce22ff70466b907b6775c2"}, - {file = "black-23.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32daa9783106c28815d05b724238e30718f34155653d4d6e125dc7daec8e260c"}, - {file = "black-23.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:35d1381d7a22cc5b2be2f72c7dfdae4072a3336060635718cc7e1ede24221d6c"}, - {file = "black-23.3.0-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:a8a968125d0a6a404842fa1bf0b349a568634f856aa08ffaff40ae0dfa52e7c6"}, - {file = "black-23.3.0-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:c7ab5790333c448903c4b721b59c0d80b11fe5e9803d8703e84dcb8da56fec1b"}, - {file = "black-23.3.0-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:a6f6886c9869d4daae2d1715ce34a19bbc4b95006d20ed785ca00fa03cba312d"}, - {file = "black-23.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f3c333ea1dd6771b2d3777482429864f8e258899f6ff05826c3a4fcc5ce3f70"}, - {file = "black-23.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:11c410f71b876f961d1de77b9699ad19f939094c3a677323f43d7a29855fe326"}, - {file = "black-23.3.0-cp37-cp37m-macosx_10_16_x86_64.whl", hash = "sha256:1d06691f1eb8de91cd1b322f21e3bfc9efe0c7ca1f0e1eb1db44ea367dff656b"}, - {file = "black-23.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50cb33cac881766a5cd9913e10ff75b1e8eb71babf4c7104f2e9c52da1fb7de2"}, - {file = "black-23.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:e114420bf26b90d4b9daa597351337762b63039752bdf72bf361364c1aa05925"}, - {file = "black-23.3.0-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:48f9d345675bb7fbc3dd85821b12487e1b9a75242028adad0333ce36ed2a6d27"}, - {file = "black-23.3.0-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:714290490c18fb0126baa0fca0a54ee795f7502b44177e1ce7624ba1c00f2331"}, - {file = "black-23.3.0-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:064101748afa12ad2291c2b91c960be28b817c0c7eaa35bec09cc63aa56493c5"}, - {file = "black-23.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:562bd3a70495facf56814293149e51aa1be9931567474993c7942ff7d3533961"}, - {file = "black-23.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:e198cf27888ad6f4ff331ca1c48ffc038848ea9f031a3b40ba36aced7e22f2c8"}, - {file = "black-23.3.0-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:3238f2aacf827d18d26db07524e44741233ae09a584273aa059066d644ca7b30"}, - {file = "black-23.3.0-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:f0bd2f4a58d6666500542b26354978218a9babcdc972722f4bf90779524515f3"}, - {file = "black-23.3.0-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:92c543f6854c28a3c7f39f4d9b7694f9a6eb9d3c5e2ece488c327b6e7ea9b266"}, - {file = "black-23.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a150542a204124ed00683f0db1f5cf1c2aaaa9cc3495b7a3b5976fb136090ab"}, - {file = "black-23.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:6b39abdfb402002b8a7d030ccc85cf5afff64ee90fa4c5aebc531e3ad0175ddb"}, - {file = "black-23.3.0-py3-none-any.whl", hash = "sha256:ec751418022185b0c1bb7d7736e6933d40bbb14c14a0abcf9123d1b159f98dd4"}, - {file = "black-23.3.0.tar.gz", hash = "sha256:1c7b8d606e728a41ea1ccbd7264677e494e87cf630e399262ced92d4a8dac940"}, + {file = "black-23.7.0-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:5c4bc552ab52f6c1c506ccae05681fab58c3f72d59ae6e6639e8885e94fe2587"}, + {file = "black-23.7.0-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:552513d5cd5694590d7ef6f46e1767a4df9af168d449ff767b13b084c020e63f"}, + {file = "black-23.7.0-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:86cee259349b4448adb4ef9b204bb4467aae74a386bce85d56ba4f5dc0da27be"}, + {file = "black-23.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:501387a9edcb75d7ae8a4412bb8749900386eaef258f1aefab18adddea1936bc"}, + {file = "black-23.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:fb074d8b213749fa1d077d630db0d5f8cc3b2ae63587ad4116e8a436e9bbe995"}, + {file = "black-23.7.0-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:b5b0ee6d96b345a8b420100b7d71ebfdd19fab5e8301aff48ec270042cd40ac2"}, + {file = "black-23.7.0-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:893695a76b140881531062d48476ebe4a48f5d1e9388177e175d76234ca247cd"}, + {file = "black-23.7.0-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:c333286dc3ddca6fdff74670b911cccedacb4ef0a60b34e491b8a67c833b343a"}, + {file = "black-23.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:831d8f54c3a8c8cf55f64d0422ee875eecac26f5f649fb6c1df65316b67c8926"}, + {file = "black-23.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:7f3bf2dec7d541b4619b8ce526bda74a6b0bffc480a163fed32eb8b3c9aed8ad"}, + {file = "black-23.7.0-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:f9062af71c59c004cd519e2fb8f5d25d39e46d3af011b41ab43b9c74e27e236f"}, + {file = "black-23.7.0-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:01ede61aac8c154b55f35301fac3e730baf0c9cf8120f65a9cd61a81cfb4a0c3"}, + {file = "black-23.7.0-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:327a8c2550ddc573b51e2c352adb88143464bb9d92c10416feb86b0f5aee5ff6"}, + {file = "black-23.7.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d1c6022b86f83b632d06f2b02774134def5d4d4f1dac8bef16d90cda18ba28a"}, + {file = "black-23.7.0-cp38-cp38-win_amd64.whl", hash = "sha256:27eb7a0c71604d5de083757fbdb245b1a4fae60e9596514c6ec497eb63f95320"}, + {file = "black-23.7.0-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:8417dbd2f57b5701492cd46edcecc4f9208dc75529bcf76c514864e48da867d9"}, + {file = "black-23.7.0-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:47e56d83aad53ca140da0af87678fb38e44fd6bc0af71eebab2d1f59b1acf1d3"}, + {file = "black-23.7.0-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:25cc308838fe71f7065df53aedd20327969d05671bac95b38fdf37ebe70ac087"}, + {file = "black-23.7.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:642496b675095d423f9b8448243336f8ec71c9d4d57ec17bf795b67f08132a91"}, + {file = "black-23.7.0-cp39-cp39-win_amd64.whl", hash = "sha256:ad0014efc7acf0bd745792bd0d8857413652979200ab924fbf239062adc12491"}, + {file = "black-23.7.0-py3-none-any.whl", hash = "sha256:9fd59d418c60c0348505f2ddf9609c1e1de8e7493eab96198fc89d9f865e7a96"}, + {file = "black-23.7.0.tar.gz", hash = "sha256:022a582720b0d9480ed82576c920a8c1dde97cc38ff11d8d8859b3bd6ca9eedb"}, ] [package.dependencies] @@ -383,86 +380,86 @@ numpy = ">1.13.3" [[package]] name = "charset-normalizer" -version = "3.1.0" +version = "3.2.0" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7.0" files = [ - {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-win32.whl", hash = "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-win32.whl", hash = "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-win32.whl", hash = "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-win32.whl", hash = "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b"}, - {file = "charset_normalizer-3.1.0-py3-none-any.whl", hash = "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d"}, + {file = "charset-normalizer-3.2.0.tar.gz", hash = "sha256:3bb3d25a8e6c0aedd251753a79ae98a093c7e7b471faa3aa9a93a81431987ace"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b87549028f680ca955556e3bd57013ab47474c3124dc069faa0b6545b6c9710"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7c70087bfee18a42b4040bb9ec1ca15a08242cf5867c58726530bdf3945672ed"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a103b3a7069b62f5d4890ae1b8f0597618f628b286b03d4bc9195230b154bfa9"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94aea8eff76ee6d1cdacb07dd2123a68283cb5569e0250feab1240058f53b623"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db901e2ac34c931d73054d9797383d0f8009991e723dab15109740a63e7f902a"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b0dac0ff919ba34d4df1b6131f59ce95b08b9065233446be7e459f95554c0dc8"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:193cbc708ea3aca45e7221ae58f0fd63f933753a9bfb498a3b474878f12caaad"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09393e1b2a9461950b1c9a45d5fd251dc7c6f228acab64da1c9c0165d9c7765c"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:baacc6aee0b2ef6f3d308e197b5d7a81c0e70b06beae1f1fcacffdbd124fe0e3"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:bf420121d4c8dce6b889f0e8e4ec0ca34b7f40186203f06a946fa0276ba54029"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c04a46716adde8d927adb9457bbe39cf473e1e2c2f5d0a16ceb837e5d841ad4f"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:aaf63899c94de41fe3cf934601b0f7ccb6b428c6e4eeb80da72c58eab077b19a"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62e51710986674142526ab9f78663ca2b0726066ae26b78b22e0f5e571238dd"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-win32.whl", hash = "sha256:04e57ab9fbf9607b77f7d057974694b4f6b142da9ed4a199859d9d4d5c63fe96"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:48021783bdf96e3d6de03a6e39a1171ed5bd7e8bb93fc84cc649d11490f87cea"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4957669ef390f0e6719db3613ab3a7631e68424604a7b448f079bee145da6e09"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46fb8c61d794b78ec7134a715a3e564aafc8f6b5e338417cb19fe9f57a5a9bf2"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f779d3ad205f108d14e99bb3859aa7dd8e9c68874617c72354d7ecaec2a054ac"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f25c229a6ba38a35ae6e25ca1264621cc25d4d38dca2942a7fce0b67a4efe918"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2efb1bd13885392adfda4614c33d3b68dee4921fd0ac1d3988f8cbb7d589e72a"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f30b48dd7fa1474554b0b0f3fdfdd4c13b5c737a3c6284d3cdc424ec0ffff3a"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:246de67b99b6851627d945db38147d1b209a899311b1305dd84916f2b88526c6"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bd9b3b31adcb054116447ea22caa61a285d92e94d710aa5ec97992ff5eb7cf3"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8c2f5e83493748286002f9369f3e6607c565a6a90425a3a1fef5ae32a36d749d"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3170c9399da12c9dc66366e9d14da8bf7147e1e9d9ea566067bbce7bb74bd9c2"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7a4826ad2bd6b07ca615c74ab91f32f6c96d08f6fcc3902ceeedaec8cdc3bcd6"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3b1613dd5aee995ec6d4c69f00378bbd07614702a315a2cf6c1d21461fe17c23"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9e608aafdb55eb9f255034709e20d5a83b6d60c054df0802fa9c9883d0a937aa"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-win32.whl", hash = "sha256:f2a1d0fd4242bd8643ce6f98927cf9c04540af6efa92323e9d3124f57727bfc1"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:681eb3d7e02e3c3655d1b16059fbfb605ac464c834a0c629048a30fad2b27489"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c57921cda3a80d0f2b8aec7e25c8aa14479ea92b5b51b6876d975d925a2ea346"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41b25eaa7d15909cf3ac4c96088c1f266a9a93ec44f87f1d13d4a0e86c81b982"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f058f6963fd82eb143c692cecdc89e075fa0828db2e5b291070485390b2f1c9c"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7647ebdfb9682b7bb97e2a5e7cb6ae735b1c25008a70b906aecca294ee96cf4"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eef9df1eefada2c09a5e7a40991b9fc6ac6ef20b1372abd48d2794a316dc0449"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e03b8895a6990c9ab2cdcd0f2fe44088ca1c65ae592b8f795c3294af00a461c3"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:ee4006268ed33370957f55bf2e6f4d263eaf4dc3cfc473d1d90baff6ed36ce4a"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c4983bf937209c57240cff65906b18bb35e64ae872da6a0db937d7b4af845dd7"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:3bb7fda7260735efe66d5107fb7e6af6a7c04c7fce9b2514e04b7a74b06bf5dd"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:72814c01533f51d68702802d74f77ea026b5ec52793c791e2da806a3844a46c3"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:70c610f6cbe4b9fce272c407dd9d07e33e6bf7b4aa1b7ffb6f6ded8e634e3592"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-win32.whl", hash = "sha256:a401b4598e5d3f4a9a811f3daf42ee2291790c7f9d74b18d75d6e21dda98a1a1"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:c0b21078a4b56965e2b12f247467b234734491897e99c1d51cee628da9786959"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:95eb302ff792e12aba9a8b8f8474ab229a83c103d74a750ec0bd1c1eea32e669"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a100c6d595a7f316f1b6f01d20815d916e75ff98c27a01ae817439ea7726329"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6339d047dab2780cc6220f46306628e04d9750f02f983ddb37439ca47ced7149"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4b749b9cc6ee664a3300bb3a273c1ca8068c46be705b6c31cf5d276f8628a94"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38856a971c602f98472050165cea2cdc97709240373041b69030be15047691f"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f87f746ee241d30d6ed93969de31e5ffd09a2961a051e60ae6bddde9ec3583aa"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89f1b185a01fe560bc8ae5f619e924407efca2191b56ce749ec84982fc59a32a"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1c8a2f4c69e08e89632defbfabec2feb8a8d99edc9f89ce33c4b9e36ab63037"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2f4ac36d8e2b4cc1aa71df3dd84ff8efbe3bfb97ac41242fbcfc053c67434f46"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a386ebe437176aab38c041de1260cd3ea459c6ce5263594399880bbc398225b2"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:ccd16eb18a849fd8dcb23e23380e2f0a354e8daa0c984b8a732d9cfaba3a776d"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:e6a5bf2cba5ae1bb80b154ed68a3cfa2fa00fde979a7f50d6598d3e17d9ac20c"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:45de3f87179c1823e6d9e32156fb14c1927fcc9aba21433f088fdfb555b77c10"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-win32.whl", hash = "sha256:1000fba1057b92a65daec275aec30586c3de2401ccdcd41f8a5c1e2c87078706"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b2c760cfc7042b27ebdb4a43a4453bd829a5742503599144d54a032c5dc7e9e"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:855eafa5d5a2034b4621c74925d89c5efef61418570e5ef9b37717d9c796419c"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:203f0c8871d5a7987be20c72442488a0b8cfd0f43b7973771640fc593f56321f"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e857a2232ba53ae940d3456f7533ce6ca98b81917d47adc3c7fd55dad8fab858"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e86d77b090dbddbe78867a0275cb4df08ea195e660f1f7f13435a4649e954e5"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fb39a81950ec280984b3a44f5bd12819953dc5fa3a7e6fa7a80db5ee853952"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dee8e57f052ef5353cf608e0b4c871aee320dd1b87d351c28764fc0ca55f9f4"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8700f06d0ce6f128de3ccdbc1acaea1ee264d2caa9ca05daaf492fde7c2a7200"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1920d4ff15ce893210c1f0c0e9d19bfbecb7983c76b33f046c13a8ffbd570252"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c1c76a1743432b4b60ab3358c937a3fe1341c828ae6194108a94c69028247f22"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f7560358a6811e52e9c4d142d497f1a6e10103d3a6881f18d04dbce3729c0e2c"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:c8063cf17b19661471ecbdb3df1c84f24ad2e389e326ccaf89e3fb2484d8dd7e"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:cd6dbe0238f7743d0efe563ab46294f54f9bc8f4b9bcf57c3c666cc5bc9d1299"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1249cbbf3d3b04902ff081ffbb33ce3377fa6e4c7356f759f3cd076cc138d020"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-win32.whl", hash = "sha256:6c409c0deba34f147f77efaa67b8e4bb83d2f11c8806405f76397ae5b8c0d1c9"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:7095f6fbfaa55defb6b733cfeb14efaae7a29f0b59d8cf213be4e7ca0b857b80"}, + {file = "charset_normalizer-3.2.0-py3-none-any.whl", hash = "sha256:8e098148dd37b4ce3baca71fb394c81dc5d9c7728c95df695d2dca218edf40e6"}, ] [[package]] @@ -487,13 +484,13 @@ typing-extensions = {version = ">=4.2.0", markers = "python_version < \"3.11\""} [[package]] name = "click" -version = "8.1.3" +version = "8.1.4" description = "Composable command line interface toolkit" optional = false python-versions = ">=3.7" files = [ - {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"}, - {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"}, + {file = "click-8.1.4-py3-none-any.whl", hash = "sha256:2739815aaa5d2c986a88f1e9230c55e17f0caad3d958a5e13ad0797c166db9e3"}, + {file = "click-8.1.4.tar.gz", hash = "sha256:b97d0c74955da062a7d4ef92fadb583806a585b2ea81958a81bd72726cbb8e37"}, ] [package.dependencies] @@ -686,13 +683,13 @@ files = [ [[package]] name = "dask" -version = "2023.6.0" +version = "2023.7.0" description = "Parallel PyData with Task Scheduling" optional = false python-versions = ">=3.9" files = [ - {file = "dask-2023.6.0-py3-none-any.whl", hash = "sha256:294f449108397c4ca7a3bca27e32cb0fe9c65599c57d6301b3b70f825c2457d4"}, - {file = "dask-2023.6.0.tar.gz", hash = "sha256:980741966ef4d14c62dfb146f315f57d5eaaa6bedc52866f99687bc6054c2d4b"}, + {file = "dask-2023.7.0-py3-none-any.whl", hash = "sha256:ceb10a806a8a6dca2d4623868687f9e166b4302f9a079e5a297e0780a2cd750d"}, + {file = "dask-2023.7.0.tar.gz", hash = "sha256:83212f085e9f59d6c724f32d4ce1dc1fed5405e868f5bfff701cc54912424c3d"}, ] [package.dependencies] @@ -710,7 +707,7 @@ array = ["numpy (>=1.21)"] complete = ["dask[array,dataframe,diagnostics,distributed]", "lz4 (>=4.3.2)", "pyarrow (>=7.0)"] dataframe = ["numpy (>=1.21)", "pandas (>=1.3)"] diagnostics = ["bokeh (>=2.4.2)", "jinja2 (>=2.10.3)"] -distributed = ["distributed (==2023.6.0)"] +distributed = ["distributed (==2023.7.0)"] test = ["pandas[test]", "pre-commit", "pytest", "pytest-cov", "pytest-rerunfailures", "pytest-xdist"] [[package]] @@ -874,29 +871,29 @@ files = [ [[package]] name = "equinox" -version = "0.10.6" +version = "0.10.10" description = "Elegant easy-to-use neural networks in JAX." optional = false python-versions = "~=3.9" files = [ - {file = "equinox-0.10.6-py3-none-any.whl", hash = "sha256:dcde6bda650bf1c0bc2e2d2f74e537f660426ced5f6a4ba98f5d1c347991b72c"}, - {file = "equinox-0.10.6.tar.gz", hash = "sha256:ea3cc9159ae01adb7ef58e2618caf798388ae9ad1a1d7ecfee7e61635d8f4f88"}, + {file = "equinox-0.10.10-py3-none-any.whl", hash = "sha256:ee40b6485c5c39beb864b4af3b69025d15a8ef6446cc653367eaf66327eca4e9"}, + {file = "equinox-0.10.10.tar.gz", hash = "sha256:861d3e0060b156294754b716be5ad8c60b6e87a7b73c1f9aa6083a489f32297b"}, ] [package.dependencies] -jax = ">=0.4.11" +jax = ">=0.4.13" jaxtyping = ">=0.2.20" typing-extensions = ">=4.5.0" [[package]] name = "exceptiongroup" -version = "1.1.1" +version = "1.1.2" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ - {file = "exceptiongroup-1.1.1-py3-none-any.whl", hash = "sha256:232c37c63e4f682982c8b6459f33a8981039e5fb8756b2074364e5055c498c9e"}, - {file = "exceptiongroup-1.1.1.tar.gz", hash = "sha256:d484c3090ba2889ae2928419117447a14daf3c1231d5e30d0aae34f354f01785"}, + {file = "exceptiongroup-1.1.2-py3-none-any.whl", hash = "sha256:e346e69d186172ca7cf029c8c1d16235aa0e04035e5750b4b95039e65204328f"}, + {file = "exceptiongroup-1.1.2.tar.gz", hash = "sha256:12c3e887d6485d16943a309616de20ae5582633e0a2eda17f4e10fd61c1e8af5"}, ] [package.extras] @@ -1095,13 +1092,13 @@ smmap = ">=3.0.1,<6" [[package]] name = "gitpython" -version = "3.1.31" +version = "3.1.32" description = "GitPython is a Python library used to interact with Git repositories" optional = false python-versions = ">=3.7" files = [ - {file = "GitPython-3.1.31-py3-none-any.whl", hash = "sha256:f04893614f6aa713a60cbbe1e6a97403ef633103cdd0ef5eb6efe0deb98dbe8d"}, - {file = "GitPython-3.1.31.tar.gz", hash = "sha256:8ce3bcf69adfdf7c7d503e78fd3b1c492af782d58893b650adb2ac8912ddd573"}, + {file = "GitPython-3.1.32-py3-none-any.whl", hash = "sha256:e3d59b1c2c6ebb9dfa7a184daf3b6dd4914237e7488a1730a6d8f6f5d0b4187f"}, + {file = "GitPython-3.1.32.tar.gz", hash = "sha256:8d9b8cb1e80b9735e8717c9362079d3ce4c6e5ddeebedd0361b228c3a67a62f6"}, ] [package.dependencies] @@ -1234,13 +1231,13 @@ files = [ [[package]] name = "importlib-metadata" -version = "6.6.0" +version = "6.8.0" description = "Read metadata from Python packages" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "importlib_metadata-6.6.0-py3-none-any.whl", hash = "sha256:43dd286a2cd8995d5eaef7fee2066340423b818ed3fd70adf0bad5f1fac53fed"}, - {file = "importlib_metadata-6.6.0.tar.gz", hash = "sha256:92501cdf9cc66ebd3e612f1b4f0c0765dfa42f0fa38ffb319b6bd84dd675d705"}, + {file = "importlib_metadata-6.8.0-py3-none-any.whl", hash = "sha256:3ebb78df84a805d7698245025b975d9d67053cd94c79245ba4b3eb694abe68bb"}, + {file = "importlib_metadata-6.8.0.tar.gz", hash = "sha256:dbace7892d8c0c4ac1ad096662232f831d4e64f4c4545bd53016a3e9d4654743"}, ] [package.dependencies] @@ -1249,25 +1246,25 @@ zipp = ">=0.5" [package.extras] docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] perf = ["ipython"] -testing = ["flake8 (<5)", "flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"] [[package]] name = "importlib-resources" -version = "5.12.0" +version = "6.0.0" description = "Read resources from Python packages" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "importlib_resources-5.12.0-py3-none-any.whl", hash = "sha256:7b1deeebbf351c7578e09bf2f63fa2ce8b5ffec296e0d349139d43cca061a81a"}, - {file = "importlib_resources-5.12.0.tar.gz", hash = "sha256:4be82589bf5c1d7999aedf2a45159d10cb3ca4f19b2271f8792bc8e6da7b22f6"}, + {file = "importlib_resources-6.0.0-py3-none-any.whl", hash = "sha256:d952faee11004c045f785bb5636e8f885bed30dc3c940d5d42798a2a4541c185"}, + {file = "importlib_resources-6.0.0.tar.gz", hash = "sha256:4cf94875a8368bd89531a756df9a9ebe1f150e0f885030b461237bc7f2d905f2"}, ] [package.dependencies] zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} [package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["flake8 (<5)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff"] [[package]] name = "iniconfig" @@ -1331,13 +1328,13 @@ zarr = "*" [[package]] name = "ipykernel" -version = "6.23.2" +version = "6.24.0" description = "IPython Kernel for Jupyter" optional = false python-versions = ">=3.8" files = [ - {file = "ipykernel-6.23.2-py3-none-any.whl", hash = "sha256:7ccb6e2d32fd958c21453db494c914f3474908a2fdefd99ab548a5375b548d1f"}, - {file = "ipykernel-6.23.2.tar.gz", hash = "sha256:fcfb67c5b504aa1bfcda1c5b3716636239e0f7b9290958f1c558c79b4c0e7ed5"}, + {file = "ipykernel-6.24.0-py3-none-any.whl", hash = "sha256:2f5fffc7ad8f1fd5aadb4e171ba9129d9668dbafa374732cf9511ada52d6547f"}, + {file = "ipykernel-6.24.0.tar.gz", hash = "sha256:29cea0a716b1176d002a61d0b0c851f34536495bc4ef7dd0222c88b41b816123"}, ] [package.dependencies] @@ -1401,6 +1398,27 @@ qtconsole = ["qtconsole"] test = ["pytest (<7.1)", "pytest-asyncio", "testpath"] test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.21)", "pandas", "pytest (<7.1)", "pytest-asyncio", "testpath", "trio"] +[[package]] +name = "ipywidgets" +version = "8.0.7" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.0.7-py3-none-any.whl", hash = "sha256:e0aed0c95a1e55b6a123f64305245578bdc09e52965a34941c2b6a578b8c64a0"}, + {file = "ipywidgets-8.0.7.tar.gz", hash = "sha256:50ace0a8886e9a0d68b980db82f94c25d55d21ff2340ed36f802dd9365e94acf"}, +] + +[package.dependencies] +ipykernel = ">=4.5.1" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.7,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.7,<4.1.0" + +[package.extras] +test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + [[package]] name = "isort" version = "5.12.0" @@ -1420,12 +1438,12 @@ requirements-deprecated-finder = ["pip-api", "pipreqs"] [[package]] name = "jax" -version = "0.4.12" +version = "0.4.13" description = "Differentiate, compile, and transform Numpy code." optional = false python-versions = ">=3.8" files = [ - {file = "jax-0.4.12.tar.gz", hash = "sha256:d2de9a2388ffe002f16506d3ad1cc6e34d7536b98948e49c7e05bbcfe8e57998"}, + {file = "jax-0.4.13.tar.gz", hash = "sha256:03bfe6749dfe647f16f15f6616638adae6c4a7ca7167c75c21961ecfd3a3baaa"}, ] [package.dependencies] @@ -1437,58 +1455,54 @@ scipy = ">=1.7" [package.extras] australis = ["protobuf (>=3.13,<4)"] -ci = ["jaxlib (==0.4.11)"] -cpu = ["jaxlib (==0.4.12)"] -cuda = ["jaxlib (==0.4.12+cuda11.cudnn86)"] -cuda11-cudnn82 = ["jaxlib (==0.4.12+cuda11.cudnn82)"] -cuda11-cudnn86 = ["jaxlib (==0.4.12+cuda11.cudnn86)"] -cuda11-local = ["jaxlib (==0.4.12+cuda11.cudnn86)"] -cuda11-pip = ["jaxlib (==0.4.12+cuda11.cudnn86)", "nvidia-cublas-cu11 (>=11.11)", "nvidia-cuda-cupti-cu11 (>=11.8)", "nvidia-cuda-nvcc-cu11 (>=11.8)", "nvidia-cuda-runtime-cu11 (>=11.8)", "nvidia-cudnn-cu11 (>=8.8)", "nvidia-cufft-cu11 (>=10.9)", "nvidia-cusolver-cu11 (>=11.4)", "nvidia-cusparse-cu11 (>=11.7)"] -cuda12-local = ["jaxlib (==0.4.12+cuda12.cudnn88)"] -cuda12-pip = ["jaxlib (==0.4.12+cuda12.cudnn88)", "nvidia-cublas-cu12", "nvidia-cuda-cupti-cu12", "nvidia-cuda-nvcc-cu12", "nvidia-cuda-runtime-cu12", "nvidia-cudnn-cu12 (>=8.9)", "nvidia-cufft-cu12", "nvidia-cusolver-cu12", "nvidia-cusparse-cu12"] +ci = ["jaxlib (==0.4.12)"] +cpu = ["jaxlib (==0.4.13)"] +cuda = ["jaxlib (==0.4.13+cuda11.cudnn86)"] +cuda11-cudnn86 = ["jaxlib (==0.4.13+cuda11.cudnn86)"] +cuda11-local = ["jaxlib (==0.4.13+cuda11.cudnn86)"] +cuda11-pip = ["jaxlib (==0.4.13+cuda11.cudnn86)", "nvidia-cublas-cu11 (>=11.11)", "nvidia-cuda-cupti-cu11 (>=11.8)", "nvidia-cuda-nvcc-cu11 (>=11.8)", "nvidia-cuda-runtime-cu11 (>=11.8)", "nvidia-cudnn-cu11 (>=8.8)", "nvidia-cufft-cu11 (>=10.9)", "nvidia-cusolver-cu11 (>=11.4)", "nvidia-cusparse-cu11 (>=11.7)"] +cuda12-local = ["jaxlib (==0.4.13+cuda12.cudnn89)"] +cuda12-pip = ["jaxlib (==0.4.13+cuda12.cudnn89)", "nvidia-cublas-cu12", "nvidia-cuda-cupti-cu12", "nvidia-cuda-nvcc-cu12", "nvidia-cuda-runtime-cu12", "nvidia-cudnn-cu12 (>=8.9)", "nvidia-cufft-cu12", "nvidia-cusolver-cu12", "nvidia-cusparse-cu12"] minimum-jaxlib = ["jaxlib (==0.4.11)"] -tpu = ["jaxlib (==0.4.12)", "libtpu-nightly (==0.1.dev20230608)"] +tpu = ["jaxlib (==0.4.13)", "libtpu-nightly (==0.1.dev20230622)"] [[package]] name = "jaxdf" -version = "0.2.4" +version = "0.2.6" description = "A JAX-based research framework for writing differentiable numerical simulators with arbitrary discretizations" optional = false -python-versions = ">=3.8" +python-versions = ">=3.9,<4.0" files = [ - {file = "jaxdf-0.2.4-py3-none-any.whl", hash = "sha256:291d87eec431d500e03d8a2f11b9a280dc1d8ae99ade74c633477197d48f6fe1"}, - {file = "jaxdf-0.2.4.tar.gz", hash = "sha256:3edcd457fa07b58f5d31226576c02189db1c8b6b7d955e3c373bce1fedd4516c"}, + {file = "jaxdf-0.2.6-py3-none-any.whl", hash = "sha256:65af40488b16c39f31b3fe4bdc9cb967a452f69abaa6b4ac70dcdf9f579fea0c"}, + {file = "jaxdf-0.2.6.tar.gz", hash = "sha256:639dc02c7c70b6293db2a54fde2f05c11cbda804e991a18f07dcd03edc1ce047"}, ] [package.dependencies] -jax = ">=0.3.0,<0.5" -jaxlib = ">=0.3.0,<0.5" -plum-dispatch = ">=1.6.0,<=1.8" - -[package.extras] -dev = ["coverage (>=6.4.2,<6.5)", "flake8 (>=4.0.1,<4.1)", "isort (>=5.10.1,<5.11)", "markdown-katex (==202112.1034)", "matplotlib (>=3.5.2,<3.6)", "mkdocs (>=1.3.1,<1.4)", "mkdocs-autorefs (>=0.4.1,<0.5)", "mkdocs-jupyter (>=0.21.0,<0.22)", "mkdocs-material (>=8.3.9,<8.4)", "mkdocs-material-extensions (>=1.0.3,<1.1)", "mkdocs-mermaid2-plugin (>=0.6.0,<0.7)", "mkdocstrings (>=0.19.0,<0.20)", "mypy (>=0.971,<1.0)", "plumkdocs (<0.1)", "pre-commit (>=2.20.0,<2.21)", "pycln (>=2.0.4,<2.1)", "pytest (>=7.1.2,<7.2)"] -doc = ["jupyter", "markdown-katex (>=202112.1034)", "mkdocs (>=1.3.1)", "mkdocs-autorefs (>=0.4.1)", "mkdocs-jupyter (>=0.21.0)", "mkdocs-macros-plugin (>0.5)", "mkdocs-material (>=8.3.9)", "mkdocs-material-extensions (>=1.0.3)", "mkdocs-mermaid2-plugin (>=0.6.0)", "mkdocstrings (>=0.19.0)", "mkdocstrings-python (>=0.7.1)", "plumkdocs (<0.1)", "pygments (>=2.12.0)", "pystache (==0.6.0)"] -test = ["coverage (>=6.4.2,<6.5)", "flake8 (>=4.0.1,<4.1)", "isort (>=5.10.1,<5.11)", "mypy (>=0.971,<1.0)", "plumkdocs (<0.1)", "pre-commit (>=2.20.0,<2.21)", "pygments (>=2.12.0,<2.13)", "pytest (>=7.1.2,<7.2)"] +jax = ">=0.4.11,<0.5.0" +plum-dispatch = ">=1.6,<2.0" [[package]] name = "jaxlib" -version = "0.4.12" +version = "0.4.13" description = "XLA library for JAX" optional = false python-versions = ">=3.8" files = [ - {file = "jaxlib-0.4.12-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:238cd7d6fbf82f9224f5e5ab27c7ca774108b790bd5d33782657c1f211fe9797"}, - {file = "jaxlib-0.4.12-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3a983f0c1e300154a6e4bdfe1b8ef41e204f0e847f04ee2a3f4397f4749b792a"}, - {file = "jaxlib-0.4.12-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:f1e7f968c3fb337fc57ad4aa7ddcf63826950ade822c745230cb15b55d9b08b7"}, - {file = "jaxlib-0.4.12-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1b6ecc95f7bafe2b2222b5ecefdf47f0f1ba323c2eb3036f312ec7c84f9fe7d2"}, - {file = "jaxlib-0.4.12-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:165dc6d377033458273144077973fa0c789b60efa2a4a83c69d5737b0a86b0bd"}, - {file = "jaxlib-0.4.12-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:6ddfa506d2f9b02a6339ad1ad01bc92cb42300f0383614058a10e25a35f15878"}, - {file = "jaxlib-0.4.12-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:6d32fec5a334deab66bb22d4db4310559e82870cb1810449e26cea223314373b"}, - {file = "jaxlib-0.4.12-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e3bafd366a138a409c545c0969fbae5c7bd6d8286a0151448c26ce169dba7784"}, - {file = "jaxlib-0.4.12-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:13245bcbd652e61f8a86c5fabaaf27d949efd163aa3baac9542015cb7315bf6d"}, - {file = "jaxlib-0.4.12-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:abf561b9ef22e43efa5ad35a81761e7d84f5f00058f46514440662de4b948d44"}, - {file = "jaxlib-0.4.12-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:880b66e99741dfe2c79274d5700cf433f183c6e0779870030bcf1a36eb1c49e1"}, - {file = "jaxlib-0.4.12-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:b163cf61363da0fbd4baa36b75d9f922119db70b681f339b6322f40e0c86683c"}, + {file = "jaxlib-0.4.13-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:532ebc4fb11386282ad63b83941d4557f4038c1144acf026f1f8565f64c7e9c0"}, + {file = "jaxlib-0.4.13-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a259bb35429bfbd3b76e43019dfc8f7d6ea94bb217400b78f7d0824ce07a58ac"}, + {file = "jaxlib-0.4.13-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:ea1bc9811ef7d73a15e3213115e88fe7f5d14b59d95027bea9fccc98e5a14af8"}, + {file = "jaxlib-0.4.13-cp310-cp310-win_amd64.whl", hash = "sha256:fde66a93e9be89d99e5792f677ed8e319667d6b2396865b1c52c1312844c47f9"}, + {file = "jaxlib-0.4.13-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:49690fcdd26560515fd15399fc3a44777e0bfc5db5c48fe76ff7bc7228e8b2fb"}, + {file = "jaxlib-0.4.13-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f4e9e34e5d8a6556f62fead14aee0b1614c2c6296f0078d8e6139d6aff109649"}, + {file = "jaxlib-0.4.13-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:8000c0d15c107328e8f7b7b3ac91dd822f5c287a80231882b620503ed141fa89"}, + {file = "jaxlib-0.4.13-cp311-cp311-win_amd64.whl", hash = "sha256:19ae4c316b17a49342432c69f7f89f190b975333f3f9e9e175f686a651bc7347"}, + {file = "jaxlib-0.4.13-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:522635d5e159401a386c79f1236c218c1f68fbb4ca6648115c3ad3c2c3f518ab"}, + {file = "jaxlib-0.4.13-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:411334d903df07dc1ace8d52fc53c17f6bc1d55aff7f6e0e5cf61ec149f758a0"}, + {file = "jaxlib-0.4.13-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:839173b2e9593f5e9a6d3c42852cd15070fe80a939246efbb5cf40eec815de89"}, + {file = "jaxlib-0.4.13-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:c230ef85712e608d0f048869766a5a63afeb2e72309943db0df9f959ab17307f"}, + {file = "jaxlib-0.4.13-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d19c05c15f962e098d49b45e2758aacf19330d192ec5395f9ef136f62db90edc"}, + {file = "jaxlib-0.4.13-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:b5c0a9737efd95fe18fd7715ce30dfce476546705ea8934aad6731777a9631a5"}, + {file = "jaxlib-0.4.13-cp39-cp39-win_amd64.whl", hash = "sha256:bebb4cf001f180dc431f9604daf930c2d9cc778e4dda26f401ac939b7bac912e"}, ] [package.dependencies] @@ -1571,23 +1585,39 @@ i18n = ["Babel (>=2.7)"] [[package]] name = "jsonschema" -version = "4.17.3" +version = "4.18.0" description = "An implementation of JSON Schema validation for Python" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "jsonschema-4.17.3-py3-none-any.whl", hash = "sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6"}, - {file = "jsonschema-4.17.3.tar.gz", hash = "sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d"}, + {file = "jsonschema-4.18.0-py3-none-any.whl", hash = "sha256:b508dd6142bd03f4c3670534c80af68cd7bbff9ea830b9cf2625d4a3c49ddf60"}, + {file = "jsonschema-4.18.0.tar.gz", hash = "sha256:8caf5b57a990a98e9b39832ef3cb35c176fe331414252b6e1b26fd5866f891a4"}, ] [package.dependencies] -attrs = ">=17.4.0" -pyrsistent = ">=0.14.0,<0.17.0 || >0.17.0,<0.17.1 || >0.17.1,<0.17.2 || >0.17.2" +attrs = ">=22.2.0" +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rpds-py = ">=0.7.1" [package.extras] format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] +[[package]] +name = "jsonschema-specifications" +version = "2023.6.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.6.1-py3-none-any.whl", hash = "sha256:3d2b82663aff01815f744bb5c7887e2121a63399b49b104a3c96145474d091d7"}, + {file = "jsonschema_specifications-2023.6.1.tar.gz", hash = "sha256:ca1c4dd059a9e7b34101cf5b3ab7ff1d18b139f35950d598d629837ef66e8f28"}, +] + +[package.dependencies] +referencing = ">=0.28.0" + [[package]] name = "jupyter-book" version = "0.15.1" @@ -1654,13 +1684,13 @@ testing = ["coverage", "ipykernel", "jupytext", "matplotlib", "nbdime", "nbforma [[package]] name = "jupyter-client" -version = "8.2.0" +version = "8.3.0" description = "Jupyter protocol implementation and client libraries" optional = false python-versions = ">=3.8" files = [ - {file = "jupyter_client-8.2.0-py3-none-any.whl", hash = "sha256:b18219aa695d39e2ad570533e0d71fb7881d35a873051054a84ee2a17c4b7389"}, - {file = "jupyter_client-8.2.0.tar.gz", hash = "sha256:9fe233834edd0e6c0aa5f05ca2ab4bdea1842bfd2d8a932878212fc5301ddaf0"}, + {file = "jupyter_client-8.3.0-py3-none-any.whl", hash = "sha256:7441af0c0672edc5d28035e92ba5e32fadcfa8a4e608a434c228836a89df6158"}, + {file = "jupyter_client-8.3.0.tar.gz", hash = "sha256:3af69921fe99617be1670399a0b857ad67275eefcfa291e2c81a160b7b650f5f"}, ] [package.dependencies] @@ -1695,19 +1725,30 @@ traitlets = ">=5.3" docs = ["myst-parser", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"] +[[package]] +name = "jupyterlab-widgets" +version = "3.0.8" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.8-py3-none-any.whl", hash = "sha256:4715912d6ceab839c9db35953c764b3214ebbc9161c809f6e0510168845dfdf5"}, + {file = "jupyterlab_widgets-3.0.8.tar.gz", hash = "sha256:d428ab97b8d87cc7c54cbf37644d6e0f0e662f23876e05fa460a73ec3257252a"}, +] + [[package]] name = "jupytext" -version = "1.14.6" +version = "1.14.7" description = "Jupyter notebooks as Markdown documents, Julia, Python or R scripts" optional = false python-versions = "~=3.6" files = [ - {file = "jupytext-1.14.6-py3-none-any.whl", hash = "sha256:6a0f9b1d850b4173115065853b8a81956bbbe6ee7d4a7906e9817cd6f6892414"}, - {file = "jupytext-1.14.6.tar.gz", hash = "sha256:f34b045d89edcecb47772761feaf001daf270fff9470c9b2125345eae9064eb6"}, + {file = "jupytext-1.14.7-py3-none-any.whl", hash = "sha256:ab2fd066dce8112ac95a7c4f9218c1a40d6cefa76b09352c8d08acf21dad5349"}, + {file = "jupytext-1.14.7.tar.gz", hash = "sha256:53cbfe90857369cf30ac055acf7820d6d9d1c53683eecd58edef5072de34b455"}, ] [package.dependencies] -markdown-it-py = ">=1.0.0,<3.0.0" +markdown-it-py = ">=1.0.0" mdit-py-plugins = "*" nbformat = "*" pyyaml = "*" @@ -1861,35 +1902,35 @@ test = ["coverage", "pytest", "pytest-cov"] [[package]] name = "llvmlite" -version = "0.40.0" +version = "0.40.1" description = "lightweight wrapper around basic LLVM functionality" optional = false python-versions = ">=3.8" files = [ - {file = "llvmlite-0.40.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90a46db1ed219d93ef05245ec17cf243074ec2b2687209cb310a803a2c2510dc"}, - {file = "llvmlite-0.40.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b9d742b66023298532d0e7beddd3d9f04334c046df7a02a1ec2ba8b4046a978c"}, - {file = "llvmlite-0.40.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ff38c309dc758b996d556e599e00647e6b8dbd21125c06b2d0584a9984a2288"}, - {file = "llvmlite-0.40.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66ecb8cdee35bbbdad9b331f446641977645de1973f6270bf4194307a1753666"}, - {file = "llvmlite-0.40.0-cp310-cp310-win32.whl", hash = "sha256:83dd5148f6ddd4d35585b69ebaa50605fdf8011a5b7259a0463afd4aefc62414"}, - {file = "llvmlite-0.40.0-cp310-cp310-win_amd64.whl", hash = "sha256:f72d6ccbfd9cc7da43098fcef23ffbe173ce2d986215072dbb2e7929412f9ff8"}, - {file = "llvmlite-0.40.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bbf19077144e159406ef222348d5330d5061177fb79d3f7f82abf2cf29b77c0b"}, - {file = "llvmlite-0.40.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a4732d6c981f658f014dd2ab2b682ac631cd12a6695e77c2d460cc68dc767868"}, - {file = "llvmlite-0.40.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2754c4d2b6f027ab45425abd94dee4cbd228b598531b1e9e1fc15f3298265d88"}, - {file = "llvmlite-0.40.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb79b992bdc2e62c5f5f86263d5546b5298d498e7c1a9d64b3a6f0d31f46ba5b"}, - {file = "llvmlite-0.40.0-cp311-cp311-win_amd64.whl", hash = "sha256:be0ff5b68a86e47a7ec6cd5389bb17b4b8f020b981628c9e714dc2cfdbe89c86"}, - {file = "llvmlite-0.40.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f5d4445eccd9c9c5639b35cb6279231f97cbd77a1c49fb41c05081ff96e041db"}, - {file = "llvmlite-0.40.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:060f00611d8e65d6db80cabba17fbefde9ebefbfb6937fe5677f06cd3e7bbe3c"}, - {file = "llvmlite-0.40.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58f5ba5febb2372418a3d37bd76d51bb987276a6fd979c2f2772b60b9061e575"}, - {file = "llvmlite-0.40.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d1622237e6ce543ac185751f782c7e10cabe45abf2de802cd5dca8023805a5c"}, - {file = "llvmlite-0.40.0-cp38-cp38-win32.whl", hash = "sha256:06803a1a38f911576bbe63a4082334d6661c59f2080e4681de1c66ec4924b0ac"}, - {file = "llvmlite-0.40.0-cp38-cp38-win_amd64.whl", hash = "sha256:87c2114567f95c715ae35b03d82caa0df66a978c93a1ff752964949e9ce596d5"}, - {file = "llvmlite-0.40.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8a3382d81fcda57f5502f45a9ca62e0c9103fabd5f817c9820c7e61b9375f3d7"}, - {file = "llvmlite-0.40.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:260b0241c17a1ec585020e1df58ed30b9975c3573c619fa1724ceb4cd53cbe42"}, - {file = "llvmlite-0.40.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f980992b6c9dfee20a1608c5a4d875f8a52d76353ca02470550a85be6e5d3680"}, - {file = "llvmlite-0.40.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:52eee9e245ef6eb911d6c2a3a1a66378745a40c637284386031b0915754f457e"}, - {file = "llvmlite-0.40.0-cp39-cp39-win32.whl", hash = "sha256:d27c2ec699b820296659dfd36ead1c527eb190c6d5cb3de24bfbee1024bdc20a"}, - {file = "llvmlite-0.40.0-cp39-cp39-win_amd64.whl", hash = "sha256:6cf84141d1793c69285b88acf4216370cb831eab99778546a2a9002fadac932d"}, - {file = "llvmlite-0.40.0.tar.gz", hash = "sha256:c910b8fbfd67b8e9d0b10ebc012b23cd67cbecef1b96f00d391ddd298d71671c"}, + {file = "llvmlite-0.40.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:84ce9b1c7a59936382ffde7871978cddcda14098e5a76d961e204523e5c372fb"}, + {file = "llvmlite-0.40.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3673c53cb21c65d2ff3704962b5958e967c6fc0bd0cff772998face199e8d87b"}, + {file = "llvmlite-0.40.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bba2747cf5b4954e945c287fe310b3fcc484e2a9d1b0c273e99eb17d103bb0e6"}, + {file = "llvmlite-0.40.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbd5e82cc990e5a3e343a3bf855c26fdfe3bfae55225f00efd01c05bbda79918"}, + {file = "llvmlite-0.40.1-cp310-cp310-win32.whl", hash = "sha256:09f83ea7a54509c285f905d968184bba00fc31ebf12f2b6b1494d677bb7dde9b"}, + {file = "llvmlite-0.40.1-cp310-cp310-win_amd64.whl", hash = "sha256:7b37297f3cbd68d14a97223a30620589d98ad1890e5040c9e5fc181063f4ed49"}, + {file = "llvmlite-0.40.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a66a5bd580951751b4268f4c3bddcef92682814d6bc72f3cd3bb67f335dd7097"}, + {file = "llvmlite-0.40.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:467b43836b388eaedc5a106d76761e388dbc4674b2f2237bc477c6895b15a634"}, + {file = "llvmlite-0.40.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c23edd196bd797dc3a7860799054ea3488d2824ecabc03f9135110c2e39fcbc"}, + {file = "llvmlite-0.40.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a36d9f244b6680cb90bbca66b146dabb2972f4180c64415c96f7c8a2d8b60a36"}, + {file = "llvmlite-0.40.1-cp311-cp311-win_amd64.whl", hash = "sha256:5b3076dc4e9c107d16dc15ecb7f2faf94f7736cd2d5e9f4dc06287fd672452c1"}, + {file = "llvmlite-0.40.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4a7525db121f2e699809b539b5308228854ccab6693ecb01b52c44a2f5647e20"}, + {file = "llvmlite-0.40.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:84747289775d0874e506f907a4513db889471607db19b04de97d144047fec885"}, + {file = "llvmlite-0.40.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e35766e42acef0fe7d1c43169a8ffc327a47808fae6a067b049fe0e9bbf84dd5"}, + {file = "llvmlite-0.40.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cda71de10a1f48416309e408ea83dab5bf36058f83e13b86a2961defed265568"}, + {file = "llvmlite-0.40.1-cp38-cp38-win32.whl", hash = "sha256:96707ebad8b051bbb4fc40c65ef93b7eeee16643bd4d579a14d11578e4b7a647"}, + {file = "llvmlite-0.40.1-cp38-cp38-win_amd64.whl", hash = "sha256:e44f854dc11559795bcdeaf12303759e56213d42dabbf91a5897aa2d8b033810"}, + {file = "llvmlite-0.40.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f643d15aacd0b0b0dc8b74b693822ba3f9a53fa63bc6a178c2dba7cc88f42144"}, + {file = "llvmlite-0.40.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:39a0b4d0088c01a469a5860d2e2d7a9b4e6a93c0f07eb26e71a9a872a8cadf8d"}, + {file = "llvmlite-0.40.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9329b930d699699846623054121ed105fd0823ed2180906d3b3235d361645490"}, + {file = "llvmlite-0.40.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2dbbb8424037ca287983b115a29adf37d806baf7e1bf4a67bd2cffb74e085ed"}, + {file = "llvmlite-0.40.1-cp39-cp39-win32.whl", hash = "sha256:e74e7bec3235a1e1c9ad97d897a620c5007d0ed80c32c84c1d787e7daa17e4ec"}, + {file = "llvmlite-0.40.1-cp39-cp39-win_amd64.whl", hash = "sha256:ff8f31111bb99d135ff296757dc81ab36c2dee54ed4bd429158a96da9807c316"}, + {file = "llvmlite-0.40.1.tar.gz", hash = "sha256:5cdb0d45df602099d833d50bd9e81353a5e036242d3c003c5b294fc61d1986b4"}, ] [[package]] @@ -2006,52 +2047,52 @@ files = [ [[package]] name = "matplotlib" -version = "3.7.1" +version = "3.7.2" description = "Python plotting package" optional = false python-versions = ">=3.8" files = [ - {file = "matplotlib-3.7.1-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:95cbc13c1fc6844ab8812a525bbc237fa1470863ff3dace7352e910519e194b1"}, - {file = "matplotlib-3.7.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:08308bae9e91aca1ec6fd6dda66237eef9f6294ddb17f0d0b3c863169bf82353"}, - {file = "matplotlib-3.7.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:544764ba51900da4639c0f983b323d288f94f65f4024dc40ecb1542d74dc0500"}, - {file = "matplotlib-3.7.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56d94989191de3fcc4e002f93f7f1be5da476385dde410ddafbb70686acf00ea"}, - {file = "matplotlib-3.7.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e99bc9e65901bb9a7ce5e7bb24af03675cbd7c70b30ac670aa263240635999a4"}, - {file = "matplotlib-3.7.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb7d248c34a341cd4c31a06fd34d64306624c8cd8d0def7abb08792a5abfd556"}, - {file = "matplotlib-3.7.1-cp310-cp310-win32.whl", hash = "sha256:ce463ce590f3825b52e9fe5c19a3c6a69fd7675a39d589e8b5fbe772272b3a24"}, - {file = "matplotlib-3.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:3d7bc90727351fb841e4d8ae620d2d86d8ed92b50473cd2b42ce9186104ecbba"}, - {file = "matplotlib-3.7.1-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:770a205966d641627fd5cf9d3cb4b6280a716522cd36b8b284a8eb1581310f61"}, - {file = "matplotlib-3.7.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f67bfdb83a8232cb7a92b869f9355d677bce24485c460b19d01970b64b2ed476"}, - {file = "matplotlib-3.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2bf092f9210e105f414a043b92af583c98f50050559616930d884387d0772aba"}, - {file = "matplotlib-3.7.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89768d84187f31717349c6bfadc0e0d8c321e8eb34522acec8a67b1236a66332"}, - {file = "matplotlib-3.7.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:83111e6388dec67822e2534e13b243cc644c7494a4bb60584edbff91585a83c6"}, - {file = "matplotlib-3.7.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a867bf73a7eb808ef2afbca03bcdb785dae09595fbe550e1bab0cd023eba3de0"}, - {file = "matplotlib-3.7.1-cp311-cp311-win32.whl", hash = "sha256:fbdeeb58c0cf0595efe89c05c224e0a502d1aa6a8696e68a73c3efc6bc354304"}, - {file = "matplotlib-3.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:c0bd19c72ae53e6ab979f0ac6a3fafceb02d2ecafa023c5cca47acd934d10be7"}, - {file = "matplotlib-3.7.1-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:6eb88d87cb2c49af00d3bbc33a003f89fd9f78d318848da029383bfc08ecfbfb"}, - {file = "matplotlib-3.7.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:cf0e4f727534b7b1457898c4f4ae838af1ef87c359b76dcd5330fa31893a3ac7"}, - {file = "matplotlib-3.7.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:46a561d23b91f30bccfd25429c3c706afe7d73a5cc64ef2dfaf2b2ac47c1a5dc"}, - {file = "matplotlib-3.7.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8704726d33e9aa8a6d5215044b8d00804561971163563e6e6591f9dcf64340cc"}, - {file = "matplotlib-3.7.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4cf327e98ecf08fcbb82685acaf1939d3338548620ab8dfa02828706402c34de"}, - {file = "matplotlib-3.7.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:617f14ae9d53292ece33f45cba8503494ee199a75b44de7717964f70637a36aa"}, - {file = "matplotlib-3.7.1-cp38-cp38-win32.whl", hash = "sha256:7c9a4b2da6fac77bcc41b1ea95fadb314e92508bf5493ceff058e727e7ecf5b0"}, - {file = "matplotlib-3.7.1-cp38-cp38-win_amd64.whl", hash = "sha256:14645aad967684e92fc349493fa10c08a6da514b3d03a5931a1bac26e6792bd1"}, - {file = "matplotlib-3.7.1-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:81a6b377ea444336538638d31fdb39af6be1a043ca5e343fe18d0f17e098770b"}, - {file = "matplotlib-3.7.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:28506a03bd7f3fe59cd3cd4ceb2a8d8a2b1db41afede01f66c42561b9be7b4b7"}, - {file = "matplotlib-3.7.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8c587963b85ce41e0a8af53b9b2de8dddbf5ece4c34553f7bd9d066148dc719c"}, - {file = "matplotlib-3.7.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8bf26ade3ff0f27668989d98c8435ce9327d24cffb7f07d24ef609e33d582439"}, - {file = "matplotlib-3.7.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:def58098f96a05f90af7e92fd127d21a287068202aa43b2a93476170ebd99e87"}, - {file = "matplotlib-3.7.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f883a22a56a84dba3b588696a2b8a1ab0d2c3d41be53264115c71b0a942d8fdb"}, - {file = "matplotlib-3.7.1-cp39-cp39-win32.whl", hash = "sha256:4f99e1b234c30c1e9714610eb0c6d2f11809c9c78c984a613ae539ea2ad2eb4b"}, - {file = "matplotlib-3.7.1-cp39-cp39-win_amd64.whl", hash = "sha256:3ba2af245e36990facf67fde840a760128ddd71210b2ab6406e640188d69d136"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3032884084f541163f295db8a6536e0abb0db464008fadca6c98aaf84ccf4717"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a2cb34336110e0ed8bb4f650e817eed61fa064acbefeb3591f1b33e3a84fd96"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b867e2f952ed592237a1828f027d332d8ee219ad722345b79a001f49df0936eb"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:57bfb8c8ea253be947ccb2bc2d1bb3862c2bccc662ad1b4626e1f5e004557042"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:438196cdf5dc8d39b50a45cb6e3f6274edbcf2254f85fa9b895bf85851c3a613"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:21e9cff1a58d42e74d01153360de92b326708fb205250150018a52c70f43c290"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75d4725d70b7c03e082bbb8a34639ede17f333d7247f56caceb3801cb6ff703d"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:97cc368a7268141afb5690760921765ed34867ffb9655dd325ed207af85c7529"}, - {file = "matplotlib-3.7.1.tar.gz", hash = "sha256:7b73305f25eab4541bd7ee0b96d87e53ae9c9f1823be5659b806cd85786fe882"}, + {file = "matplotlib-3.7.2-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:2699f7e73a76d4c110f4f25be9d2496d6ab4f17345307738557d345f099e07de"}, + {file = "matplotlib-3.7.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a8035ba590658bae7562786c9cc6ea1a84aa49d3afab157e414c9e2ea74f496d"}, + {file = "matplotlib-3.7.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2f8e4a49493add46ad4a8c92f63e19d548b2b6ebbed75c6b4c7f46f57d36cdd1"}, + {file = "matplotlib-3.7.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71667eb2ccca4c3537d9414b1bc00554cb7f91527c17ee4ec38027201f8f1603"}, + {file = "matplotlib-3.7.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:152ee0b569a37630d8628534c628456b28686e085d51394da6b71ef84c4da201"}, + {file = "matplotlib-3.7.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:070f8dddd1f5939e60aacb8fa08f19551f4b0140fab16a3669d5cd6e9cb28fc8"}, + {file = "matplotlib-3.7.2-cp310-cp310-win32.whl", hash = "sha256:fdbb46fad4fb47443b5b8ac76904b2e7a66556844f33370861b4788db0f8816a"}, + {file = "matplotlib-3.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:23fb1750934e5f0128f9423db27c474aa32534cec21f7b2153262b066a581fd1"}, + {file = "matplotlib-3.7.2-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:30e1409b857aa8a747c5d4f85f63a79e479835f8dffc52992ac1f3f25837b544"}, + {file = "matplotlib-3.7.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:50e0a55ec74bf2d7a0ebf50ac580a209582c2dd0f7ab51bc270f1b4a0027454e"}, + {file = "matplotlib-3.7.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ac60daa1dc83e8821eed155796b0f7888b6b916cf61d620a4ddd8200ac70cd64"}, + {file = "matplotlib-3.7.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:305e3da477dc8607336ba10bac96986d6308d614706cae2efe7d3ffa60465b24"}, + {file = "matplotlib-3.7.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c308b255efb9b06b23874236ec0f10f026673ad6515f602027cc8ac7805352d"}, + {file = "matplotlib-3.7.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60c521e21031632aa0d87ca5ba0c1c05f3daacadb34c093585a0be6780f698e4"}, + {file = "matplotlib-3.7.2-cp311-cp311-win32.whl", hash = "sha256:26bede320d77e469fdf1bde212de0ec889169b04f7f1179b8930d66f82b30cbc"}, + {file = "matplotlib-3.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:af4860132c8c05261a5f5f8467f1b269bf1c7c23902d75f2be57c4a7f2394b3e"}, + {file = "matplotlib-3.7.2-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:a1733b8e84e7e40a9853e505fe68cc54339f97273bdfe6f3ed980095f769ddc7"}, + {file = "matplotlib-3.7.2-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d9881356dc48e58910c53af82b57183879129fa30492be69058c5b0d9fddf391"}, + {file = "matplotlib-3.7.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f081c03f413f59390a80b3e351cc2b2ea0205839714dbc364519bcf51f4b56ca"}, + {file = "matplotlib-3.7.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1cd120fca3407a225168238b790bd5c528f0fafde6172b140a2f3ab7a4ea63e9"}, + {file = "matplotlib-3.7.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a2c1590b90aa7bd741b54c62b78de05d4186271e34e2377e0289d943b3522273"}, + {file = "matplotlib-3.7.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d2ff3c984b8a569bc1383cd468fc06b70d7b59d5c2854ca39f1436ae8394117"}, + {file = "matplotlib-3.7.2-cp38-cp38-win32.whl", hash = "sha256:5dea00b62d28654b71ca92463656d80646675628d0828e08a5f3b57e12869e13"}, + {file = "matplotlib-3.7.2-cp38-cp38-win_amd64.whl", hash = "sha256:0f506a1776ee94f9e131af1ac6efa6e5bc7cb606a3e389b0ccb6e657f60bb676"}, + {file = "matplotlib-3.7.2-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:6515e878f91894c2e4340d81f0911857998ccaf04dbc1bba781e3d89cbf70608"}, + {file = "matplotlib-3.7.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:71f7a8c6b124e904db550f5b9fe483d28b896d4135e45c4ea381ad3b8a0e3256"}, + {file = "matplotlib-3.7.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:12f01b92ecd518e0697da4d97d163b2b3aa55eb3eb4e2c98235b3396d7dad55f"}, + {file = "matplotlib-3.7.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7e28d6396563955f7af437894a36bf2b279462239a41028323e04b85179058b"}, + {file = "matplotlib-3.7.2-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbcf59334ff645e6a67cd5f78b4b2cdb76384cdf587fa0d2dc85f634a72e1a3e"}, + {file = "matplotlib-3.7.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:318c89edde72ff95d8df67d82aca03861240512994a597a435a1011ba18dbc7f"}, + {file = "matplotlib-3.7.2-cp39-cp39-win32.whl", hash = "sha256:ce55289d5659b5b12b3db4dc9b7075b70cef5631e56530f14b2945e8836f2d20"}, + {file = "matplotlib-3.7.2-cp39-cp39-win_amd64.whl", hash = "sha256:2ecb5be2b2815431c81dc115667e33da0f5a1bcf6143980d180d09a717c4a12e"}, + {file = "matplotlib-3.7.2-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:fdcd28360dbb6203fb5219b1a5658df226ac9bebc2542a9e8f457de959d713d0"}, + {file = "matplotlib-3.7.2-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c3cca3e842b11b55b52c6fb8bd6a4088693829acbfcdb3e815fa9b7d5c92c1b"}, + {file = "matplotlib-3.7.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebf577c7a6744e9e1bd3fee45fc74a02710b214f94e2bde344912d85e0c9af7c"}, + {file = "matplotlib-3.7.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:936bba394682049919dda062d33435b3be211dc3dcaa011e09634f060ec878b2"}, + {file = "matplotlib-3.7.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:bc221ffbc2150458b1cd71cdd9ddd5bb37962b036e41b8be258280b5b01da1dd"}, + {file = "matplotlib-3.7.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:35d74ebdb3f71f112b36c2629cf32323adfbf42679e2751252acd468f5001c07"}, + {file = "matplotlib-3.7.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:717157e61b3a71d3d26ad4e1770dc85156c9af435659a25ee6407dc866cb258d"}, + {file = "matplotlib-3.7.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:20f844d6be031948148ba49605c8b96dfe7d3711d1b63592830d650622458c11"}, + {file = "matplotlib-3.7.2.tar.gz", hash = "sha256:a8cdb91dddb04436bd2f098b8fdf4b81352e68cf4d2c6756fcc414791076569b"}, ] [package.dependencies] @@ -2063,7 +2104,7 @@ kiwisolver = ">=1.0.1" numpy = ">=1.20" packaging = ">=20.0" pillow = ">=6.2.0" -pyparsing = ">=2.3.1" +pyparsing = ">=2.3.1,<3.1" python-dateutil = ">=2.7" [[package]] @@ -2139,8 +2180,8 @@ files = [ [package.dependencies] numpy = [ {version = ">1.20", markers = "python_version <= \"3.9\""}, - {version = ">=1.21.2", markers = "python_version > \"3.9\""}, {version = ">=1.23.3", markers = "python_version > \"3.10\""}, + {version = ">=1.21.2", markers = "python_version > \"3.9\""}, ] [package.extras] @@ -2307,13 +2348,13 @@ test = ["flaky", "ipykernel", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "p [[package]] name = "nbformat" -version = "5.9.0" +version = "5.9.1" description = "The Jupyter Notebook format" optional = false python-versions = ">=3.8" files = [ - {file = "nbformat-5.9.0-py3-none-any.whl", hash = "sha256:8c8fa16d6d05062c26177754bfbfac22de644888e2ef69d27ad2a334cf2576e5"}, - {file = "nbformat-5.9.0.tar.gz", hash = "sha256:e98ebb6120c3efbafdee2a40af2a140cadee90bb06dd69a2a63d9551fcc7f976"}, + {file = "nbformat-5.9.1-py3-none-any.whl", hash = "sha256:b7968ebf4811178a4108ee837eae1442e3f054132100f0359219e9ed1ce3ca45"}, + {file = "nbformat-5.9.1.tar.gz", hash = "sha256:3a7f52d040639cbd8a3890218c8b0ffb93211588c57446c90095e32ba5881b5d"}, ] [package.dependencies] @@ -2414,35 +2455,35 @@ setuptools = "*" [[package]] name = "numba" -version = "0.57.0" +version = "0.57.1" description = "compiling Python code using LLVM" optional = false python-versions = ">=3.8" files = [ - {file = "numba-0.57.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2e2c14c411545e80bf0f1a33232fb0bd6aa3368f86e56eeffc7f6d3ac16ea3fd"}, - {file = "numba-0.57.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6b3382c56d805ffcdc7b46eb69a906be733dd35b84be14abba8e5fd27d7916b2"}, - {file = "numba-0.57.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:133cba9b5002bf67f6f73d9b3050d919c1be91326bbdcccfdf3259bcfb1cec0e"}, - {file = "numba-0.57.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d92a17ee849574665c5d94e9c9b862e469e1231d3dbb9e58e58b30b4bb0cbce9"}, - {file = "numba-0.57.0-cp310-cp310-win32.whl", hash = "sha256:abc90c3d303a67ae5194770a6f0d0a83edf076683b8a426349a27b91d98e00d1"}, - {file = "numba-0.57.0-cp310-cp310-win_amd64.whl", hash = "sha256:430f43c96f866ca4fe6008d8aa28bb608911d908ff94f879e0dbad7768ef9869"}, - {file = "numba-0.57.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:069f7d8fddad4c0eb1d7534c2a18098fe50473dc77832b409176002e9011b96f"}, - {file = "numba-0.57.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:79daa130fc9e4ebd1eea0a594d1de86d8a4366989f5fab93c482246b502520db"}, - {file = "numba-0.57.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:274f4db4814ebd5ec81697acfc36df04a865b86610d7714905185b753f3f9baf"}, - {file = "numba-0.57.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0106ee441e3f69cc6f17cb470c4fcccd592e0606567d43245635d72b071ab88e"}, - {file = "numba-0.57.0-cp311-cp311-win_amd64.whl", hash = "sha256:a5d31b4d95000d86ffa9652ab5bcfa0ea30e6c3fc40e610147d4f2f00116703d"}, - {file = "numba-0.57.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3e0b8de39bf17519435937b53276dfb02e2eb8bc27cd211c8eeb01ffed1cab6b"}, - {file = "numba-0.57.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:18d90fa6fcd5b796999392a8ea67f2fbccecf8dabcea726e2e721c79f40566a6"}, - {file = "numba-0.57.0-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4f62528c7c8c5f97e9689fd788e420b68c67ee0a1a9a7715a57fd584b7aef1e"}, - {file = "numba-0.57.0-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fd12cf0b431676c08057685e229ea5daaa1ec8efba2506c38671734ace49c2d7"}, - {file = "numba-0.57.0-cp38-cp38-win32.whl", hash = "sha256:e5f11b1d435fb4d1d1b68fa68ff456d632dc4bfd40b18825ff80d6081d1afb26"}, - {file = "numba-0.57.0-cp38-cp38-win_amd64.whl", hash = "sha256:5810ed2d6d22eb3c48bedfac2187fc44bb90e05f02d47fd31059e69207ae4106"}, - {file = "numba-0.57.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:eddba74493d4003a42cd61ff7feca4928a94a45553d1fddac77a5cc339f6f4f9"}, - {file = "numba-0.57.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:110be5e1213d0a3d5fc691e921a000779500620196d99cee9908fce83d1e48df"}, - {file = "numba-0.57.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f949018ab9c467d38f14fe17db4df0d4a1c664be802189e2d6c5a434d9ffd4f6"}, - {file = "numba-0.57.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9fc0cd4ec93a1e3877985e10ed5837ed2991c83aa4b7ca574caae5c8b448cc4b"}, - {file = "numba-0.57.0-cp39-cp39-win32.whl", hash = "sha256:83d4f21c98eed3001e9896a43a1ce9c825999c03f7eb39ddd1c2d07a76708392"}, - {file = "numba-0.57.0-cp39-cp39-win_amd64.whl", hash = "sha256:9173d00c6753212b68e4fd319cfa96c21b2263949452c97b034e78ce09539dee"}, - {file = "numba-0.57.0.tar.gz", hash = "sha256:2af6d81067a5bdc13960c6d2519dbabbf4d5d597cf75d640c5aeaefd48c6420a"}, + {file = "numba-0.57.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:db8268eb5093cae2288942a8cbd69c9352f6fe6e0bfa0a9a27679436f92e4248"}, + {file = "numba-0.57.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:643cb09a9ba9e1bd8b060e910aeca455e9442361e80fce97690795ff9840e681"}, + {file = "numba-0.57.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:53e9fab973d9e82c9f8449f75994a898daaaf821d84f06fbb0b9de2293dd9306"}, + {file = "numba-0.57.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c0602e4f896e6a6d844517c3ab434bc978e7698a22a733cc8124465898c28fa8"}, + {file = "numba-0.57.1-cp310-cp310-win32.whl", hash = "sha256:3d6483c27520d16cf5d122868b79cad79e48056ecb721b52d70c126bed65431e"}, + {file = "numba-0.57.1-cp310-cp310-win_amd64.whl", hash = "sha256:a32ee263649aa3c3587b833d6311305379529570e6c20deb0c6f4fb5bc7020db"}, + {file = "numba-0.57.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c078f84b5529a7fdb8413bb33d5100f11ec7b44aa705857d9eb4e54a54ff505"}, + {file = "numba-0.57.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e447c4634d1cc99ab50d4faa68f680f1d88b06a2a05acf134aa6fcc0342adeca"}, + {file = "numba-0.57.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4838edef2df5f056cb8974670f3d66562e751040c448eb0b67c7e2fec1726649"}, + {file = "numba-0.57.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9b17fbe4a69dcd9a7cd49916b6463cd9a82af5f84911feeb40793b8bce00dfa7"}, + {file = "numba-0.57.1-cp311-cp311-win_amd64.whl", hash = "sha256:93df62304ada9b351818ba19b1cfbddaf72cd89348e81474326ca0b23bf0bae1"}, + {file = "numba-0.57.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8e00ca63c5d0ad2beeb78d77f087b3a88c45ea9b97e7622ab2ec411a868420ee"}, + {file = "numba-0.57.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ff66d5b022af6c7d81ddbefa87768e78ed4f834ab2da6ca2fd0d60a9e69b94f5"}, + {file = "numba-0.57.1-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:60ec56386076e9eed106a87c96626d5686fbb16293b9834f0849cf78c9491779"}, + {file = "numba-0.57.1-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c057ccedca95df23802b6ccad86bb318be624af45b5a38bb8412882be57a681"}, + {file = "numba-0.57.1-cp38-cp38-win32.whl", hash = "sha256:5a82bf37444039c732485c072fda21a361790ed990f88db57fd6941cd5e5d307"}, + {file = "numba-0.57.1-cp38-cp38-win_amd64.whl", hash = "sha256:9bcc36478773ce838f38afd9a4dfafc328d4ffb1915381353d657da7f6473282"}, + {file = "numba-0.57.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ae50c8c90c2ce8057f9618b589223e13faa8cbc037d8f15b4aad95a2c33a0582"}, + {file = "numba-0.57.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9a1b2b69448e510d672ff9a6b18d2db9355241d93c6a77677baa14bec67dc2a0"}, + {file = "numba-0.57.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3cf78d74ad9d289fbc1e5b1c9f2680fca7a788311eb620581893ab347ec37a7e"}, + {file = "numba-0.57.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f47dd214adc5dcd040fe9ad2adbd2192133c9075d2189ce1b3d5f9d72863ef05"}, + {file = "numba-0.57.1-cp39-cp39-win32.whl", hash = "sha256:a3eac19529956185677acb7f01864919761bfffbb9ae04bbbe5e84bbc06cfc2b"}, + {file = "numba-0.57.1-cp39-cp39-win_amd64.whl", hash = "sha256:9587ba1bf5f3035575e45562ada17737535c6d612df751e811d702693a72d95e"}, + {file = "numba-0.57.1.tar.gz", hash = "sha256:33c0500170d213e66d90558ad6aca57d3e03e97bb11da82e6d87ab793648cb17"}, ] [package.dependencies] @@ -2483,39 +2524,39 @@ zfpy = ["zfpy (>=1.0.0)"] [[package]] name = "numpy" -version = "1.24.3" +version = "1.24.4" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.8" files = [ - {file = "numpy-1.24.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3c1104d3c036fb81ab923f507536daedc718d0ad5a8707c6061cdfd6d184e570"}, - {file = "numpy-1.24.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:202de8f38fc4a45a3eea4b63e2f376e5f2dc64ef0fa692838e31a808520efaf7"}, - {file = "numpy-1.24.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8535303847b89aa6b0f00aa1dc62867b5a32923e4d1681a35b5eef2d9591a463"}, - {file = "numpy-1.24.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d926b52ba1367f9acb76b0df6ed21f0b16a1ad87c6720a1121674e5cf63e2b6"}, - {file = "numpy-1.24.3-cp310-cp310-win32.whl", hash = "sha256:f21c442fdd2805e91799fbe044a7b999b8571bb0ab0f7850d0cb9641a687092b"}, - {file = "numpy-1.24.3-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f23af8c16022663a652d3b25dcdc272ac3f83c3af4c02eb8b824e6b3ab9d7"}, - {file = "numpy-1.24.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9a7721ec204d3a237225db3e194c25268faf92e19338a35f3a224469cb6039a3"}, - {file = "numpy-1.24.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d6cc757de514c00b24ae8cf5c876af2a7c3df189028d68c0cb4eaa9cd5afc2bf"}, - {file = "numpy-1.24.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76e3f4e85fc5d4fd311f6e9b794d0c00e7002ec122be271f2019d63376f1d385"}, - {file = "numpy-1.24.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1d3c026f57ceaad42f8231305d4653d5f05dc6332a730ae5c0bea3513de0950"}, - {file = "numpy-1.24.3-cp311-cp311-win32.whl", hash = "sha256:c91c4afd8abc3908e00a44b2672718905b8611503f7ff87390cc0ac3423fb096"}, - {file = "numpy-1.24.3-cp311-cp311-win_amd64.whl", hash = "sha256:5342cf6aad47943286afa6f1609cad9b4266a05e7f2ec408e2cf7aea7ff69d80"}, - {file = "numpy-1.24.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7776ea65423ca6a15255ba1872d82d207bd1e09f6d0894ee4a64678dd2204078"}, - {file = "numpy-1.24.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ae8d0be48d1b6ed82588934aaaa179875e7dc4f3d84da18d7eae6eb3f06c242c"}, - {file = "numpy-1.24.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ecde0f8adef7dfdec993fd54b0f78183051b6580f606111a6d789cd14c61ea0c"}, - {file = "numpy-1.24.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4749e053a29364d3452c034827102ee100986903263e89884922ef01a0a6fd2f"}, - {file = "numpy-1.24.3-cp38-cp38-win32.whl", hash = "sha256:d933fabd8f6a319e8530d0de4fcc2e6a61917e0b0c271fded460032db42a0fe4"}, - {file = "numpy-1.24.3-cp38-cp38-win_amd64.whl", hash = "sha256:56e48aec79ae238f6e4395886b5eaed058abb7231fb3361ddd7bfdf4eed54289"}, - {file = "numpy-1.24.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4719d5aefb5189f50887773699eaf94e7d1e02bf36c1a9d353d9f46703758ca4"}, - {file = "numpy-1.24.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0ec87a7084caa559c36e0a2309e4ecb1baa03b687201d0a847c8b0ed476a7187"}, - {file = "numpy-1.24.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea8282b9bcfe2b5e7d491d0bf7f3e2da29700cec05b49e64d6246923329f2b02"}, - {file = "numpy-1.24.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210461d87fb02a84ef243cac5e814aad2b7f4be953b32cb53327bb49fd77fbb4"}, - {file = "numpy-1.24.3-cp39-cp39-win32.whl", hash = "sha256:784c6da1a07818491b0ffd63c6bbe5a33deaa0e25a20e1b3ea20cf0e43f8046c"}, - {file = "numpy-1.24.3-cp39-cp39-win_amd64.whl", hash = "sha256:d5036197ecae68d7f491fcdb4df90082b0d4960ca6599ba2659957aafced7c17"}, - {file = "numpy-1.24.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:352ee00c7f8387b44d19f4cada524586f07379c0d49270f87233983bc5087ca0"}, - {file = "numpy-1.24.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7d6acc2e7524c9955e5c903160aa4ea083736fde7e91276b0e5d98e6332812"}, - {file = "numpy-1.24.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:35400e6a8d102fd07c71ed7dcadd9eb62ee9a6e84ec159bd48c28235bbb0f8e4"}, - {file = "numpy-1.24.3.tar.gz", hash = "sha256:ab344f1bf21f140adab8e47fdbc7c35a477dc01408791f8ba00d018dd0bc5155"}, + {file = "numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64"}, + {file = "numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1"}, + {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4"}, + {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6"}, + {file = "numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc"}, + {file = "numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e"}, + {file = "numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810"}, + {file = "numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254"}, + {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7"}, + {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5"}, + {file = "numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d"}, + {file = "numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694"}, + {file = "numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61"}, + {file = "numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f"}, + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e"}, + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc"}, + {file = "numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2"}, + {file = "numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706"}, + {file = "numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400"}, + {file = "numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f"}, + {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9"}, + {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d"}, + {file = "numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835"}, + {file = "numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2"}, + {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, ] [[package]] @@ -2582,36 +2623,36 @@ files = [ [[package]] name = "pandas" -version = "2.0.2" +version = "2.0.3" description = "Powerful data structures for data analysis, time series, and statistics" optional = false python-versions = ">=3.8" files = [ - {file = "pandas-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ebb9f1c22ddb828e7fd017ea265a59d80461d5a79154b49a4207bd17514d122"}, - {file = "pandas-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1eb09a242184092f424b2edd06eb2b99d06dc07eeddff9929e8667d4ed44e181"}, - {file = "pandas-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7319b6e68de14e6209460f72a8d1ef13c09fb3d3ef6c37c1e65b35d50b5c145"}, - {file = "pandas-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd46bde7309088481b1cf9c58e3f0e204b9ff9e3244f441accd220dd3365ce7c"}, - {file = "pandas-2.0.2-cp310-cp310-win32.whl", hash = "sha256:51a93d422fbb1bd04b67639ba4b5368dffc26923f3ea32a275d2cc450f1d1c86"}, - {file = "pandas-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:66d00300f188fa5de73f92d5725ced162488f6dc6ad4cecfe4144ca29debe3b8"}, - {file = "pandas-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:02755de164da6827764ceb3bbc5f64b35cb12394b1024fdf88704d0fa06e0e2f"}, - {file = "pandas-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0a1e0576611641acde15c2322228d138258f236d14b749ad9af498ab69089e2d"}, - {file = "pandas-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6b5f14cd24a2ed06e14255ff40fe2ea0cfaef79a8dd68069b7ace74bd6acbba"}, - {file = "pandas-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50e451932b3011b61d2961b4185382c92cc8c6ee4658dcd4f320687bb2d000ee"}, - {file = "pandas-2.0.2-cp311-cp311-win32.whl", hash = "sha256:7b21cb72958fc49ad757685db1919021d99650d7aaba676576c9e88d3889d456"}, - {file = "pandas-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:c4af689352c4fe3d75b2834933ee9d0ccdbf5d7a8a7264f0ce9524e877820c08"}, - {file = "pandas-2.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:69167693cb8f9b3fc060956a5d0a0a8dbfed5f980d9fd2c306fb5b9c855c814c"}, - {file = "pandas-2.0.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:30a89d0fec4263ccbf96f68592fd668939481854d2ff9da709d32a047689393b"}, - {file = "pandas-2.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a18e5c72b989ff0f7197707ceddc99828320d0ca22ab50dd1b9e37db45b010c0"}, - {file = "pandas-2.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7376e13d28eb16752c398ca1d36ccfe52bf7e887067af9a0474de6331dd948d2"}, - {file = "pandas-2.0.2-cp38-cp38-win32.whl", hash = "sha256:6d6d10c2142d11d40d6e6c0a190b1f89f525bcf85564707e31b0a39e3b398e08"}, - {file = "pandas-2.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:e69140bc2d29a8556f55445c15f5794490852af3de0f609a24003ef174528b79"}, - {file = "pandas-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b42b120458636a981077cfcfa8568c031b3e8709701315e2bfa866324a83efa8"}, - {file = "pandas-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f908a77cbeef9bbd646bd4b81214cbef9ac3dda4181d5092a4aa9797d1bc7774"}, - {file = "pandas-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:713f2f70abcdade1ddd68fc91577cb090b3544b07ceba78a12f799355a13ee44"}, - {file = "pandas-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf3f0c361a4270185baa89ec7ab92ecaa355fe783791457077473f974f654df5"}, - {file = "pandas-2.0.2-cp39-cp39-win32.whl", hash = "sha256:598e9020d85a8cdbaa1815eb325a91cfff2bb2b23c1442549b8a3668e36f0f77"}, - {file = "pandas-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:77550c8909ebc23e56a89f91b40ad01b50c42cfbfab49b3393694a50549295ea"}, - {file = "pandas-2.0.2.tar.gz", hash = "sha256:dd5476b6c3fe410ee95926873f377b856dbc4e81a9c605a0dc05aaccc6a7c6c6"}, + {file = "pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8"}, + {file = "pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0"}, + {file = "pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210"}, + {file = "pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df"}, + {file = "pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd"}, + {file = "pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0"}, + {file = "pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02"}, + {file = "pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641"}, + {file = "pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682"}, + {file = "pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, ] [package.dependencies] @@ -2625,7 +2666,7 @@ pytz = ">=2020.1" tzdata = ">=2022.1" [package.extras] -all = ["PyQt5 (>=5.15.1)", "SQLAlchemy (>=1.4.16)", "beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.2)", "pytest (>=7.0.0)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "s3fs (>=2021.08.0)", "scipy (>=1.7.1)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] +all = ["PyQt5 (>=5.15.1)", "SQLAlchemy (>=1.4.16)", "beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "s3fs (>=2021.08.0)", "scipy (>=1.7.1)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] aws = ["s3fs (>=2021.08.0)"] clipboard = ["PyQt5 (>=5.15.1)", "qtpy (>=2.2.0)"] compression = ["brotlipy (>=0.7.0)", "python-snappy (>=0.6.0)", "zstandard (>=0.15.2)"] @@ -2644,7 +2685,7 @@ plot = ["matplotlib (>=3.6.1)"] postgresql = ["SQLAlchemy (>=1.4.16)", "psycopg2 (>=2.8.6)"] spss = ["pyreadstat (>=1.1.2)"] sql-other = ["SQLAlchemy (>=1.4.16)"] -test = ["hypothesis (>=6.34.2)", "pytest (>=7.0.0)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"] +test = ["hypothesis (>=6.34.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"] xml = ["lxml (>=4.6.3)"] [[package]] @@ -2728,77 +2769,67 @@ files = [ [[package]] name = "pillow" -version = "9.5.0" +version = "10.0.0" description = "Python Imaging Library (Fork)" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "Pillow-9.5.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:ace6ca218308447b9077c14ea4ef381ba0b67ee78d64046b3f19cf4e1139ad16"}, - {file = "Pillow-9.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3d403753c9d5adc04d4694d35cf0391f0f3d57c8e0030aac09d7678fa8030aa"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ba1b81ee69573fe7124881762bb4cd2e4b6ed9dd28c9c60a632902fe8db8b38"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fe7e1c262d3392afcf5071df9afa574544f28eac825284596ac6db56e6d11062"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f36397bf3f7d7c6a3abdea815ecf6fd14e7fcd4418ab24bae01008d8d8ca15e"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:252a03f1bdddce077eff2354c3861bf437c892fb1832f75ce813ee94347aa9b5"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:85ec677246533e27770b0de5cf0f9d6e4ec0c212a1f89dfc941b64b21226009d"}, - {file = "Pillow-9.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b416f03d37d27290cb93597335a2f85ed446731200705b22bb927405320de903"}, - {file = "Pillow-9.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1781a624c229cb35a2ac31cc4a77e28cafc8900733a864870c49bfeedacd106a"}, - {file = "Pillow-9.5.0-cp310-cp310-win32.whl", hash = "sha256:8507eda3cd0608a1f94f58c64817e83ec12fa93a9436938b191b80d9e4c0fc44"}, - {file = "Pillow-9.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:d3c6b54e304c60c4181da1c9dadf83e4a54fd266a99c70ba646a9baa626819eb"}, - {file = "Pillow-9.5.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:7ec6f6ce99dab90b52da21cf0dc519e21095e332ff3b399a357c187b1a5eee32"}, - {file = "Pillow-9.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:560737e70cb9c6255d6dcba3de6578a9e2ec4b573659943a5e7e4af13f298f5c"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96e88745a55b88a7c64fa49bceff363a1a27d9a64e04019c2281049444a571e3"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d9c206c29b46cfd343ea7cdfe1232443072bbb270d6a46f59c259460db76779a"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfcc2c53c06f2ccb8976fb5c71d448bdd0a07d26d8e07e321c103416444c7ad1"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a0f9bb6c80e6efcde93ffc51256d5cfb2155ff8f78292f074f60f9e70b942d99"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8d935f924bbab8f0a9a28404422da8af4904e36d5c33fc6f677e4c4485515625"}, - {file = "Pillow-9.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fed1e1cf6a42577953abbe8e6cf2fe2f566daebde7c34724ec8803c4c0cda579"}, - {file = "Pillow-9.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c1170d6b195555644f0616fd6ed929dfcf6333b8675fcca044ae5ab110ded296"}, - {file = "Pillow-9.5.0-cp311-cp311-win32.whl", hash = "sha256:54f7102ad31a3de5666827526e248c3530b3a33539dbda27c6843d19d72644ec"}, - {file = "Pillow-9.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:cfa4561277f677ecf651e2b22dc43e8f5368b74a25a8f7d1d4a3a243e573f2d4"}, - {file = "Pillow-9.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:965e4a05ef364e7b973dd17fc765f42233415974d773e82144c9bbaaaea5d089"}, - {file = "Pillow-9.5.0-cp312-cp312-win32.whl", hash = "sha256:22baf0c3cf0c7f26e82d6e1adf118027afb325e703922c8dfc1d5d0156bb2eeb"}, - {file = "Pillow-9.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:432b975c009cf649420615388561c0ce7cc31ce9b2e374db659ee4f7d57a1f8b"}, - {file = "Pillow-9.5.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:5d4ebf8e1db4441a55c509c4baa7a0587a0210f7cd25fcfe74dbbce7a4bd1906"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:375f6e5ee9620a271acb6820b3d1e94ffa8e741c0601db4c0c4d3cb0a9c224bf"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99eb6cafb6ba90e436684e08dad8be1637efb71c4f2180ee6b8f940739406e78"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dfaaf10b6172697b9bceb9a3bd7b951819d1ca339a5ef294d1f1ac6d7f63270"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:763782b2e03e45e2c77d7779875f4432e25121ef002a41829d8868700d119392"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:35f6e77122a0c0762268216315bf239cf52b88865bba522999dc38f1c52b9b47"}, - {file = "Pillow-9.5.0-cp37-cp37m-win32.whl", hash = "sha256:aca1c196f407ec7cf04dcbb15d19a43c507a81f7ffc45b690899d6a76ac9fda7"}, - {file = "Pillow-9.5.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322724c0032af6692456cd6ed554bb85f8149214d97398bb80613b04e33769f6"}, - {file = "Pillow-9.5.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:a0aa9417994d91301056f3d0038af1199eb7adc86e646a36b9e050b06f526597"}, - {file = "Pillow-9.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f8286396b351785801a976b1e85ea88e937712ee2c3ac653710a4a57a8da5d9c"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c830a02caeb789633863b466b9de10c015bded434deb3ec87c768e53752ad22a"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fbd359831c1657d69bb81f0db962905ee05e5e9451913b18b831febfe0519082"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8fc330c3370a81bbf3f88557097d1ea26cd8b019d6433aa59f71195f5ddebbf"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:7002d0797a3e4193c7cdee3198d7c14f92c0836d6b4a3f3046a64bd1ce8df2bf"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:229e2c79c00e85989a34b5981a2b67aa079fd08c903f0aaead522a1d68d79e51"}, - {file = "Pillow-9.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9adf58f5d64e474bed00d69bcd86ec4bcaa4123bfa70a65ce72e424bfb88ed96"}, - {file = "Pillow-9.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:662da1f3f89a302cc22faa9f14a262c2e3951f9dbc9617609a47521c69dd9f8f"}, - {file = "Pillow-9.5.0-cp38-cp38-win32.whl", hash = "sha256:6608ff3bf781eee0cd14d0901a2b9cc3d3834516532e3bd673a0a204dc8615fc"}, - {file = "Pillow-9.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:e49eb4e95ff6fd7c0c402508894b1ef0e01b99a44320ba7d8ecbabefddcc5569"}, - {file = "Pillow-9.5.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:482877592e927fd263028c105b36272398e3e1be3269efda09f6ba21fd83ec66"}, - {file = "Pillow-9.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3ded42b9ad70e5f1754fb7c2e2d6465a9c842e41d178f262e08b8c85ed8a1d8e"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c446d2245ba29820d405315083d55299a796695d747efceb5717a8b450324115"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aca1152d93dcc27dc55395604dcfc55bed5f25ef4c98716a928bacba90d33a3"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:608488bdcbdb4ba7837461442b90ea6f3079397ddc968c31265c1e056964f1ef"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:60037a8db8750e474af7ffc9faa9b5859e6c6d0a50e55c45576bf28be7419705"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:07999f5834bdc404c442146942a2ecadd1cb6292f5229f4ed3b31e0a108746b1"}, - {file = "Pillow-9.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a127ae76092974abfbfa38ca2d12cbeddcdeac0fb71f9627cc1135bedaf9d51a"}, - {file = "Pillow-9.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:489f8389261e5ed43ac8ff7b453162af39c3e8abd730af8363587ba64bb2e865"}, - {file = "Pillow-9.5.0-cp39-cp39-win32.whl", hash = "sha256:9b1af95c3a967bf1da94f253e56b6286b50af23392a886720f563c547e48e964"}, - {file = "Pillow-9.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:77165c4a5e7d5a284f10a6efaa39a0ae8ba839da344f20b111d62cc932fa4e5d"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:833b86a98e0ede388fa29363159c9b1a294b0905b5128baf01db683672f230f5"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aaf305d6d40bd9632198c766fb64f0c1a83ca5b667f16c1e79e1661ab5060140"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0852ddb76d85f127c135b6dd1f0bb88dbb9ee990d2cd9aa9e28526c93e794fba"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:91ec6fe47b5eb5a9968c79ad9ed78c342b1f97a091677ba0e012701add857829"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:cb841572862f629b99725ebaec3287fc6d275be9b14443ea746c1dd325053cbd"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c380b27d041209b849ed246b111b7c166ba36d7933ec6e41175fd15ab9eb1572"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c9af5a3b406a50e313467e3565fc99929717f780164fe6fbb7704edba0cebbe"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5671583eab84af046a397d6d0ba25343c00cd50bce03787948e0fff01d4fd9b1"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:84a6f19ce086c1bf894644b43cd129702f781ba5751ca8572f08aa40ef0ab7b7"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1e7723bd90ef94eda669a3c2c19d549874dd5badaeefabefd26053304abe5799"}, - {file = "Pillow-9.5.0.tar.gz", hash = "sha256:bf548479d336726d7a0eceb6e767e179fbde37833ae42794602631a070d630f1"}, + {file = "Pillow-10.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1f62406a884ae75fb2f818694469519fb685cc7eaff05d3451a9ebe55c646891"}, + {file = "Pillow-10.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d5db32e2a6ccbb3d34d87c87b432959e0db29755727afb37290e10f6e8e62614"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edf4392b77bdc81f36e92d3a07a5cd072f90253197f4a52a55a8cec48a12483b"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:520f2a520dc040512699f20fa1c363eed506e94248d71f85412b625026f6142c"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:8c11160913e3dd06c8ffdb5f233a4f254cb449f4dfc0f8f4549eda9e542c93d1"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a74ba0c356aaa3bb8e3eb79606a87669e7ec6444be352870623025d75a14a2bf"}, + {file = "Pillow-10.0.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d5d0dae4cfd56969d23d94dc8e89fb6a217be461c69090768227beb8ed28c0a3"}, + {file = "Pillow-10.0.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22c10cc517668d44b211717fd9775799ccec4124b9a7f7b3635fc5386e584992"}, + {file = "Pillow-10.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:dffe31a7f47b603318c609f378ebcd57f1554a3a6a8effbc59c3c69f804296de"}, + {file = "Pillow-10.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:9fb218c8a12e51d7ead2a7c9e101a04982237d4855716af2e9499306728fb485"}, + {file = "Pillow-10.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d35e3c8d9b1268cbf5d3670285feb3528f6680420eafe35cccc686b73c1e330f"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ed64f9ca2f0a95411e88a4efbd7a29e5ce2cea36072c53dd9d26d9c76f753b3"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b6eb5502f45a60a3f411c63187db83a3d3107887ad0d036c13ce836f8a36f1d"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:c1fbe7621c167ecaa38ad29643d77a9ce7311583761abf7836e1510c580bf3dd"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:cd25d2a9d2b36fcb318882481367956d2cf91329f6892fe5d385c346c0649629"}, + {file = "Pillow-10.0.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:3b08d4cc24f471b2c8ca24ec060abf4bebc6b144cb89cba638c720546b1cf538"}, + {file = "Pillow-10.0.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d737a602fbd82afd892ca746392401b634e278cb65d55c4b7a8f48e9ef8d008d"}, + {file = "Pillow-10.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:3a82c40d706d9aa9734289740ce26460a11aeec2d9c79b7af87bb35f0073c12f"}, + {file = "Pillow-10.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:bc2ec7c7b5d66b8ec9ce9f720dbb5fa4bace0f545acd34870eff4a369b44bf37"}, + {file = "Pillow-10.0.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:d80cf684b541685fccdd84c485b31ce73fc5c9b5d7523bf1394ce134a60c6883"}, + {file = "Pillow-10.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76de421f9c326da8f43d690110f0e79fe3ad1e54be811545d7d91898b4c8493e"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81ff539a12457809666fef6624684c008e00ff6bf455b4b89fd00a140eecd640"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce543ed15570eedbb85df19b0a1a7314a9c8141a36ce089c0a894adbfccb4568"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:685ac03cc4ed5ebc15ad5c23bc555d68a87777586d970c2c3e216619a5476223"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d72e2ecc68a942e8cf9739619b7f408cc7b272b279b56b2c83c6123fcfa5cdff"}, + {file = "Pillow-10.0.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d50b6aec14bc737742ca96e85d6d0a5f9bfbded018264b3b70ff9d8c33485551"}, + {file = "Pillow-10.0.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:00e65f5e822decd501e374b0650146063fbb30a7264b4d2744bdd7b913e0cab5"}, + {file = "Pillow-10.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:f31f9fdbfecb042d046f9d91270a0ba28368a723302786c0009ee9b9f1f60199"}, + {file = "Pillow-10.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:1ce91b6ec08d866b14413d3f0bbdea7e24dfdc8e59f562bb77bc3fe60b6144ca"}, + {file = "Pillow-10.0.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:349930d6e9c685c089284b013478d6f76e3a534e36ddfa912cde493f235372f3"}, + {file = "Pillow-10.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3a684105f7c32488f7153905a4e3015a3b6c7182e106fe3c37fbb5ef3e6994c3"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4f69b3700201b80bb82c3a97d5e9254084f6dd5fb5b16fc1a7b974260f89f43"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f07ea8d2f827d7d2a49ecf1639ec02d75ffd1b88dcc5b3a61bbb37a8759ad8d"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:040586f7d37b34547153fa383f7f9aed68b738992380ac911447bb78f2abe530"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:f88a0b92277de8e3ca715a0d79d68dc82807457dae3ab8699c758f07c20b3c51"}, + {file = "Pillow-10.0.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c7cf14a27b0d6adfaebb3ae4153f1e516df54e47e42dcc073d7b3d76111a8d86"}, + {file = "Pillow-10.0.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:3400aae60685b06bb96f99a21e1ada7bc7a413d5f49bce739828ecd9391bb8f7"}, + {file = "Pillow-10.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:dbc02381779d412145331789b40cc7b11fdf449e5d94f6bc0b080db0a56ea3f0"}, + {file = "Pillow-10.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:9211e7ad69d7c9401cfc0e23d49b69ca65ddd898976d660a2fa5904e3d7a9baa"}, + {file = "Pillow-10.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:faaf07ea35355b01a35cb442dd950d8f1bb5b040a7787791a535de13db15ed90"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9f72a021fbb792ce98306ffb0c348b3c9cb967dce0f12a49aa4c3d3fdefa967"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f7c16705f44e0504a3a2a14197c1f0b32a95731d251777dcb060aa83022cb2d"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:76edb0a1fa2b4745fb0c99fb9fb98f8b180a1bbceb8be49b087e0b21867e77d3"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:368ab3dfb5f49e312231b6f27b8820c823652b7cd29cfbd34090565a015e99ba"}, + {file = "Pillow-10.0.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:608bfdee0d57cf297d32bcbb3c728dc1da0907519d1784962c5f0c68bb93e5a3"}, + {file = "Pillow-10.0.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5c6e3df6bdd396749bafd45314871b3d0af81ff935b2d188385e970052091017"}, + {file = "Pillow-10.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:7be600823e4c8631b74e4a0d38384c73f680e6105a7d3c6824fcf226c178c7e6"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:92be919bbc9f7d09f7ae343c38f5bb21c973d2576c1d45600fce4b74bafa7ac0"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8182b523b2289f7c415f589118228d30ac8c355baa2f3194ced084dac2dbba"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:38250a349b6b390ee6047a62c086d3817ac69022c127f8a5dc058c31ccef17f3"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:88af2003543cc40c80f6fca01411892ec52b11021b3dc22ec3bc9d5afd1c5334"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c189af0545965fa8d3b9613cfdb0cd37f9d71349e0f7750e1fd704648d475ed2"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce7b031a6fc11365970e6a5686d7ba8c63e4c1cf1ea143811acbb524295eabed"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:db24668940f82321e746773a4bc617bfac06ec831e5c88b643f91f122a785684"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:efe8c0681042536e0d06c11f48cebe759707c9e9abf880ee213541c5b46c5bf3"}, + {file = "Pillow-10.0.0.tar.gz", hash = "sha256:9c82b5b3e043c7af0d95792d0d20ccf68f61a1fec6b3530e718b688422727396"}, ] [package.extras] @@ -2807,13 +2838,13 @@ tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "pa [[package]] name = "platformdirs" -version = "3.5.3" +version = "3.8.1" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." optional = false python-versions = ">=3.7" files = [ - {file = "platformdirs-3.5.3-py3-none-any.whl", hash = "sha256:0ade98a4895e87dc51d47151f7d2ec290365a585151d97b4d8d6312ed6132fed"}, - {file = "platformdirs-3.5.3.tar.gz", hash = "sha256:e48fabd87db8f3a7df7150a4a5ea22c546ee8bc39bc2473244730d4b56d2cc4e"}, + {file = "platformdirs-3.8.1-py3-none-any.whl", hash = "sha256:cec7b889196b9144d088e4c57d9ceef7374f6c39694ad1577a0aab50d27ea28c"}, + {file = "platformdirs-3.8.1.tar.gz", hash = "sha256:f87ca4fcff7d2b0f81c6a748a77973d7af0f4d526f98f308477c3c436c74d528"}, ] [package.extras] @@ -2822,13 +2853,13 @@ test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.3.1)", "pytest- [[package]] name = "pluggy" -version = "1.0.0" +version = "1.2.0" description = "plugin and hook calling mechanisms for python" optional = false -python-versions = ">=3.6" +python-versions = ">=3.7" files = [ - {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"}, - {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"}, + {file = "pluggy-1.2.0-py3-none-any.whl", hash = "sha256:c2fd55a7d7a3863cba1a013e4e2414658b1d07b6bc57b3919e0c63c9abb99849"}, + {file = "pluggy-1.2.0.tar.gz", hash = "sha256:d12f0c4b579b15f5e054301bb226ee85eeeba08ffec228092f8defbaa3a4c4b3"}, ] [package.extras] @@ -2887,13 +2918,13 @@ virtualenv = ">=20.10.0" [[package]] name = "prompt-toolkit" -version = "3.0.38" +version = "3.0.39" description = "Library for building powerful interactive command lines in Python" optional = false python-versions = ">=3.7.0" files = [ - {file = "prompt_toolkit-3.0.38-py3-none-any.whl", hash = "sha256:45ea77a2f7c60418850331366c81cf6b5b9cf4c7fd34616f733c5427e6abbb1f"}, - {file = "prompt_toolkit-3.0.38.tar.gz", hash = "sha256:23ac5d50538a9a38c8bde05fecb47d0b403ecd0662857a86f886f798563d5b9b"}, + {file = "prompt_toolkit-3.0.39-py3-none-any.whl", hash = "sha256:9dffbe1d8acf91e3de75f3b544e4842382fc06c6babe903ac9acb74dc6e08d88"}, + {file = "prompt_toolkit-3.0.39.tar.gz", hash = "sha256:04505ade687dc26dc4284b1ad19a83be2f2afe83e7a828ace0c72f3a1df72aac"}, ] [package.dependencies] @@ -2901,24 +2932,24 @@ wcwidth = "*" [[package]] name = "protobuf" -version = "4.23.3" +version = "4.23.4" description = "" optional = false python-versions = ">=3.7" files = [ - {file = "protobuf-4.23.3-cp310-abi3-win32.whl", hash = "sha256:514b6bbd54a41ca50c86dd5ad6488afe9505901b3557c5e0f7823a0cf67106fb"}, - {file = "protobuf-4.23.3-cp310-abi3-win_amd64.whl", hash = "sha256:cc14358a8742c4e06b1bfe4be1afbdf5c9f6bd094dff3e14edb78a1513893ff5"}, - {file = "protobuf-4.23.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:2991f5e7690dab569f8f81702e6700e7364cc3b5e572725098215d3da5ccc6ac"}, - {file = "protobuf-4.23.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:08fe19d267608d438aa37019236db02b306e33f6b9902c3163838b8e75970223"}, - {file = "protobuf-4.23.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:3b01a5274ac920feb75d0b372d901524f7e3ad39c63b1a2d55043f3887afe0c1"}, - {file = "protobuf-4.23.3-cp37-cp37m-win32.whl", hash = "sha256:aca6e86a08c5c5962f55eac9b5bd6fce6ed98645d77e8bfc2b952ecd4a8e4f6a"}, - {file = "protobuf-4.23.3-cp37-cp37m-win_amd64.whl", hash = "sha256:0149053336a466e3e0b040e54d0b615fc71de86da66791c592cc3c8d18150bf8"}, - {file = "protobuf-4.23.3-cp38-cp38-win32.whl", hash = "sha256:84ea0bd90c2fdd70ddd9f3d3fc0197cc24ecec1345856c2b5ba70e4d99815359"}, - {file = "protobuf-4.23.3-cp38-cp38-win_amd64.whl", hash = "sha256:3bcbeb2bf4bb61fe960dd6e005801a23a43578200ea8ceb726d1f6bd0e562ba1"}, - {file = "protobuf-4.23.3-cp39-cp39-win32.whl", hash = "sha256:5cb9e41188737f321f4fce9a4337bf40a5414b8d03227e1d9fbc59bc3a216e35"}, - {file = "protobuf-4.23.3-cp39-cp39-win_amd64.whl", hash = "sha256:29660574cd769f2324a57fb78127cda59327eb6664381ecfe1c69731b83e8288"}, - {file = "protobuf-4.23.3-py3-none-any.whl", hash = "sha256:447b9786ac8e50ae72cae7a2eec5c5df6a9dbf9aa6f908f1b8bda6032644ea62"}, - {file = "protobuf-4.23.3.tar.gz", hash = "sha256:7a92beb30600332a52cdadbedb40d33fd7c8a0d7f549c440347bc606fb3fe34b"}, + {file = "protobuf-4.23.4-cp310-abi3-win32.whl", hash = "sha256:5fea3c64d41ea5ecf5697b83e41d09b9589e6f20b677ab3c48e5f242d9b7897b"}, + {file = "protobuf-4.23.4-cp310-abi3-win_amd64.whl", hash = "sha256:7b19b6266d92ca6a2a87effa88ecc4af73ebc5cfde194dc737cf8ef23a9a3b12"}, + {file = "protobuf-4.23.4-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:8547bf44fe8cec3c69e3042f5c4fb3e36eb2a7a013bb0a44c018fc1e427aafbd"}, + {file = "protobuf-4.23.4-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:fee88269a090ada09ca63551bf2f573eb2424035bcf2cb1b121895b01a46594a"}, + {file = "protobuf-4.23.4-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:effeac51ab79332d44fba74660d40ae79985901ac21bca408f8dc335a81aa597"}, + {file = "protobuf-4.23.4-cp37-cp37m-win32.whl", hash = "sha256:c3e0939433c40796ca4cfc0fac08af50b00eb66a40bbbc5dee711998fb0bbc1e"}, + {file = "protobuf-4.23.4-cp37-cp37m-win_amd64.whl", hash = "sha256:9053df6df8e5a76c84339ee4a9f5a2661ceee4a0dab019e8663c50ba324208b0"}, + {file = "protobuf-4.23.4-cp38-cp38-win32.whl", hash = "sha256:e1c915778d8ced71e26fcf43c0866d7499891bca14c4368448a82edc61fdbc70"}, + {file = "protobuf-4.23.4-cp38-cp38-win_amd64.whl", hash = "sha256:351cc90f7d10839c480aeb9b870a211e322bf05f6ab3f55fcb2f51331f80a7d2"}, + {file = "protobuf-4.23.4-cp39-cp39-win32.whl", hash = "sha256:6dd9b9940e3f17077e820b75851126615ee38643c2c5332aa7a359988820c720"}, + {file = "protobuf-4.23.4-cp39-cp39-win_amd64.whl", hash = "sha256:0a5759f5696895de8cc913f084e27fd4125e8fb0914bb729a17816a33819f474"}, + {file = "protobuf-4.23.4-py3-none-any.whl", hash = "sha256:e9d0be5bf34b275b9f87ba7407796556abeeba635455d036c7351f7c183ef8ff"}, + {file = "protobuf-4.23.4.tar.gz", hash = "sha256:ccd9430c0719dce806b93f89c91de7977304729e55377f872a92465d548329a9"}, ] [[package]] @@ -3096,51 +3127,15 @@ files = [ [package.dependencies] python-dotenv = ">=0.20.0" -[[package]] -name = "pyrsistent" -version = "0.19.3" -description = "Persistent/Functional/Immutable data structures" -optional = false -python-versions = ">=3.7" -files = [ - {file = "pyrsistent-0.19.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:20460ac0ea439a3e79caa1dbd560344b64ed75e85d8703943e0b66c2a6150e4a"}, - {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c18264cb84b5e68e7085a43723f9e4c1fd1d935ab240ce02c0324a8e01ccb64"}, - {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b774f9288dda8d425adb6544e5903f1fb6c273ab3128a355c6b972b7df39dcf"}, - {file = "pyrsistent-0.19.3-cp310-cp310-win32.whl", hash = "sha256:5a474fb80f5e0d6c9394d8db0fc19e90fa540b82ee52dba7d246a7791712f74a"}, - {file = "pyrsistent-0.19.3-cp310-cp310-win_amd64.whl", hash = "sha256:49c32f216c17148695ca0e02a5c521e28a4ee6c5089f97e34fe24163113722da"}, - {file = "pyrsistent-0.19.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f0774bf48631f3a20471dd7c5989657b639fd2d285b861237ea9e82c36a415a9"}, - {file = "pyrsistent-0.19.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab2204234c0ecd8b9368dbd6a53e83c3d4f3cab10ecaf6d0e772f456c442393"}, - {file = "pyrsistent-0.19.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e42296a09e83028b3476f7073fcb69ffebac0e66dbbfd1bd847d61f74db30f19"}, - {file = "pyrsistent-0.19.3-cp311-cp311-win32.whl", hash = "sha256:64220c429e42a7150f4bfd280f6f4bb2850f95956bde93c6fda1b70507af6ef3"}, - {file = "pyrsistent-0.19.3-cp311-cp311-win_amd64.whl", hash = "sha256:016ad1afadf318eb7911baa24b049909f7f3bb2c5b1ed7b6a8f21db21ea3faa8"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c4db1bd596fefd66b296a3d5d943c94f4fac5bcd13e99bffe2ba6a759d959a28"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aeda827381f5e5d65cced3024126529ddc4289d944f75e090572c77ceb19adbf"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42ac0b2f44607eb92ae88609eda931a4f0dfa03038c44c772e07f43e738bcac9"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-win32.whl", hash = "sha256:e8f2b814a3dc6225964fa03d8582c6e0b6650d68a232df41e3cc1b66a5d2f8d1"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-win_amd64.whl", hash = "sha256:c9bb60a40a0ab9aba40a59f68214eed5a29c6274c83b2cc206a359c4a89fa41b"}, - {file = "pyrsistent-0.19.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a2471f3f8693101975b1ff85ffd19bb7ca7dd7c38f8a81701f67d6b4f97b87d8"}, - {file = "pyrsistent-0.19.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc5d149f31706762c1f8bda2e8c4f8fead6e80312e3692619a75301d3dbb819a"}, - {file = "pyrsistent-0.19.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3311cb4237a341aa52ab8448c27e3a9931e2ee09561ad150ba94e4cfd3fc888c"}, - {file = "pyrsistent-0.19.3-cp38-cp38-win32.whl", hash = "sha256:f0e7c4b2f77593871e918be000b96c8107da48444d57005b6a6bc61fb4331b2c"}, - {file = "pyrsistent-0.19.3-cp38-cp38-win_amd64.whl", hash = "sha256:c147257a92374fde8498491f53ffa8f4822cd70c0d85037e09028e478cababb7"}, - {file = "pyrsistent-0.19.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b735e538f74ec31378f5a1e3886a26d2ca6351106b4dfde376a26fc32a044edc"}, - {file = "pyrsistent-0.19.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99abb85579e2165bd8522f0c0138864da97847875ecbd45f3e7e2af569bfc6f2"}, - {file = "pyrsistent-0.19.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a8cb235fa6d3fd7aae6a4f1429bbb1fec1577d978098da1252f0489937786f3"}, - {file = "pyrsistent-0.19.3-cp39-cp39-win32.whl", hash = "sha256:c74bed51f9b41c48366a286395c67f4e894374306b197e62810e0fdaf2364da2"}, - {file = "pyrsistent-0.19.3-cp39-cp39-win_amd64.whl", hash = "sha256:878433581fc23e906d947a6814336eee031a00e6defba224234169ae3d3d6a98"}, - {file = "pyrsistent-0.19.3-py3-none-any.whl", hash = "sha256:ccf0d6bd208f8111179f0c26fdf84ed7c3891982f2edaeae7422575f47e66b64"}, - {file = "pyrsistent-0.19.3.tar.gz", hash = "sha256:1a2994773706bbb4995c31a97bc94f1418314923bd1048c6d964837040376440"}, -] - [[package]] name = "pytest" -version = "7.3.2" +version = "7.4.0" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.7" files = [ - {file = "pytest-7.3.2-py3-none-any.whl", hash = "sha256:cdcbd012c9312258922f8cd3f1b62a6580fdced17db6014896053d47cddf9295"}, - {file = "pytest-7.3.2.tar.gz", hash = "sha256:ee990a3cc55ba808b80795a79944756f315c67c12b56abd3ac993a7b8c17030b"}, + {file = "pytest-7.4.0-py3-none-any.whl", hash = "sha256:78bf16451a2eb8c7a2ea98e32dc119fd2aa758f1d5d66dbf0a59d69a3969df32"}, + {file = "pytest-7.4.0.tar.gz", hash = "sha256:b4bf8c45bd59934ed84001ad51e11b4ee40d40a1229d2c79f9c592b0a3f6bd8a"}, ] [package.dependencies] @@ -3372,6 +3367,21 @@ files = [ [package.dependencies] cffi = {version = "*", markers = "implementation_name == \"pypy\""} +[[package]] +name = "referencing" +version = "0.29.1" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.29.1-py3-none-any.whl", hash = "sha256:d3c8f323ee1480095da44d55917cfb8278d73d6b4d5f677e3e40eb21314ac67f"}, + {file = "referencing-0.29.1.tar.gz", hash = "sha256:90cb53782d550ba28d2166ef3f55731f38397def8832baac5d45235f1995e35e"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + [[package]] name = "requests" version = "2.31.0" @@ -3393,6 +3403,112 @@ urllib3 = ">=1.21.1,<3" socks = ["PySocks (>=1.5.6,!=1.5.7)"] use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] +[[package]] +name = "rpds-py" +version = "0.8.10" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.8.10-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:93d06cccae15b3836247319eee7b6f1fdcd6c10dabb4e6d350d27bd0bdca2711"}, + {file = "rpds_py-0.8.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3816a890a6a9e9f1de250afa12ca71c9a7a62f2b715a29af6aaee3aea112c181"}, + {file = "rpds_py-0.8.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7c6304b894546b5a6bdc0fe15761fa53fe87d28527a7142dae8de3c663853e1"}, + {file = "rpds_py-0.8.10-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ad3bfb44c8840fb4be719dc58e229f435e227fbfbe133dc33f34981ff622a8f8"}, + {file = "rpds_py-0.8.10-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:14f1c356712f66653b777ecd8819804781b23dbbac4eade4366b94944c9e78ad"}, + {file = "rpds_py-0.8.10-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82bb361cae4d0a627006dadd69dc2f36b7ad5dc1367af9d02e296ec565248b5b"}, + {file = "rpds_py-0.8.10-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2e3c4f2a8e3da47f850d7ea0d7d56720f0f091d66add889056098c4b2fd576c"}, + {file = "rpds_py-0.8.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:15a90d0ac11b4499171067ae40a220d1ca3cb685ec0acc356d8f3800e07e4cb8"}, + {file = "rpds_py-0.8.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:70bb9c8004b97b4ef7ae56a2aa56dfaa74734a0987c78e7e85f00004ab9bf2d0"}, + {file = "rpds_py-0.8.10-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:d64f9f88d5203274a002b54442cafc9c7a1abff2a238f3e767b70aadf919b451"}, + {file = "rpds_py-0.8.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ccbbd276642788c4376fbe8d4e6c50f0fb4972ce09ecb051509062915891cbf0"}, + {file = "rpds_py-0.8.10-cp310-none-win32.whl", hash = "sha256:fafc0049add8043ad07ab5382ee80d80ed7e3699847f26c9a5cf4d3714d96a84"}, + {file = "rpds_py-0.8.10-cp310-none-win_amd64.whl", hash = "sha256:915031002c86a5add7c6fd4beb601b2415e8a1c956590a5f91d825858e92fe6e"}, + {file = "rpds_py-0.8.10-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:84eb541a44f7a18f07a6bfc48b95240739e93defe1fdfb4f2a295f37837945d7"}, + {file = "rpds_py-0.8.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f59996d0550894affaad8743e97b9b9c98f638b221fac12909210ec3d9294786"}, + {file = "rpds_py-0.8.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f9adb5664b78fcfcd830000416c8cc69853ef43cb084d645b3f1f0296edd9bae"}, + {file = "rpds_py-0.8.10-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f96f3f98fbff7af29e9edf9a6584f3c1382e7788783d07ba3721790625caa43e"}, + {file = "rpds_py-0.8.10-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:376b8de737401050bd12810003d207e824380be58810c031f10ec563ff6aef3d"}, + {file = "rpds_py-0.8.10-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d1c2bc319428d50b3e0fa6b673ab8cc7fa2755a92898db3a594cbc4eeb6d1f7"}, + {file = "rpds_py-0.8.10-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73a1e48430f418f0ac3dfd87860e4cc0d33ad6c0f589099a298cb53724db1169"}, + {file = "rpds_py-0.8.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:134ec8f14ca7dbc6d9ae34dac632cdd60939fe3734b5d287a69683c037c51acb"}, + {file = "rpds_py-0.8.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4b519bac7c09444dd85280fd60f28c6dde4389c88dddf4279ba9b630aca3bbbe"}, + {file = "rpds_py-0.8.10-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9cd57981d9fab04fc74438d82460f057a2419974d69a96b06a440822d693b3c0"}, + {file = "rpds_py-0.8.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:69d089c026f6a8b9d64a06ff67dc3be196707b699d7f6ca930c25f00cf5e30d8"}, + {file = "rpds_py-0.8.10-cp311-none-win32.whl", hash = "sha256:220bdcad2d2936f674650d304e20ac480a3ce88a40fe56cd084b5780f1d104d9"}, + {file = "rpds_py-0.8.10-cp311-none-win_amd64.whl", hash = "sha256:6c6a0225b8501d881b32ebf3f5807a08ad3685b5eb5f0a6bfffd3a6e039b2055"}, + {file = "rpds_py-0.8.10-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:e3d0cd3dff0e7638a7b5390f3a53057c4e347f4ef122ee84ed93fc2fb7ea4aa2"}, + {file = "rpds_py-0.8.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d77dff3a5aa5eedcc3da0ebd10ff8e4969bc9541aa3333a8d41715b429e99f47"}, + {file = "rpds_py-0.8.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41c89a366eae49ad9e65ed443a8f94aee762931a1e3723749d72aeac80f5ef2f"}, + {file = "rpds_py-0.8.10-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3793c21494bad1373da517001d0849eea322e9a049a0e4789e50d8d1329df8e7"}, + {file = "rpds_py-0.8.10-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:805a5f3f05d186c5d50de2e26f765ba7896d0cc1ac5b14ffc36fae36df5d2f10"}, + {file = "rpds_py-0.8.10-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b01b39ad5411563031ea3977bbbc7324d82b088e802339e6296f082f78f6115c"}, + {file = "rpds_py-0.8.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3f1e860be21f3e83011116a65e7310486300e08d9a3028e73e8d13bb6c77292"}, + {file = "rpds_py-0.8.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a13c8e56c46474cd5958d525ce6a9996727a83d9335684e41f5192c83deb6c58"}, + {file = "rpds_py-0.8.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:93d99f957a300d7a4ced41615c45aeb0343bb8f067c42b770b505de67a132346"}, + {file = "rpds_py-0.8.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:148b0b38d719c0760e31ce9285a9872972bdd7774969a4154f40c980e5beaca7"}, + {file = "rpds_py-0.8.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3cc5e5b5514796f45f03a568981971b12a3570f3de2e76114f7dc18d4b60a3c4"}, + {file = "rpds_py-0.8.10-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:e8e24b210a4deb5a7744971f8f77393005bae7f873568e37dfd9effe808be7f7"}, + {file = "rpds_py-0.8.10-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b41941583adce4242af003d2a8337b066ba6148ca435f295f31ac6d9e4ea2722"}, + {file = "rpds_py-0.8.10-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c490204e16bca4f835dba8467869fe7295cdeaa096e4c5a7af97f3454a97991"}, + {file = "rpds_py-0.8.10-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ee45cd1d84beed6cbebc839fd85c2e70a3a1325c8cfd16b62c96e2ffb565eca"}, + {file = "rpds_py-0.8.10-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a8ca409f1252e1220bf09c57290b76cae2f14723746215a1e0506472ebd7bdf"}, + {file = "rpds_py-0.8.10-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96b293c0498c70162effb13100624c5863797d99df75f2f647438bd10cbf73e4"}, + {file = "rpds_py-0.8.10-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4627520a02fccbd324b33c7a83e5d7906ec746e1083a9ac93c41ac7d15548c7"}, + {file = "rpds_py-0.8.10-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e39d7ab0c18ac99955b36cd19f43926450baba21e3250f053e0704d6ffd76873"}, + {file = "rpds_py-0.8.10-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ba9f1d1ebe4b63801977cec7401f2d41e888128ae40b5441270d43140efcad52"}, + {file = "rpds_py-0.8.10-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:802f42200d8caf7f25bbb2a6464cbd83e69d600151b7e3b49f49a47fa56b0a38"}, + {file = "rpds_py-0.8.10-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:d19db6ba816e7f59fc806c690918da80a7d186f00247048cd833acdab9b4847b"}, + {file = "rpds_py-0.8.10-cp38-none-win32.whl", hash = "sha256:7947e6e2c2ad68b1c12ee797d15e5f8d0db36331200b0346871492784083b0c6"}, + {file = "rpds_py-0.8.10-cp38-none-win_amd64.whl", hash = "sha256:fa326b3505d5784436d9433b7980171ab2375535d93dd63fbcd20af2b5ca1bb6"}, + {file = "rpds_py-0.8.10-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:7b38a9ac96eeb6613e7f312cd0014de64c3f07000e8bf0004ad6ec153bac46f8"}, + {file = "rpds_py-0.8.10-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c4d42e83ddbf3445e6514f0aff96dca511421ed0392d9977d3990d9f1ba6753c"}, + {file = "rpds_py-0.8.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b21575031478609db6dbd1f0465e739fe0e7f424a8e7e87610a6c7f68b4eb16"}, + {file = "rpds_py-0.8.10-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:574868858a7ff6011192c023a5289158ed20e3f3b94b54f97210a773f2f22921"}, + {file = "rpds_py-0.8.10-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae40f4a70a1f40939d66ecbaf8e7edc144fded190c4a45898a8cfe19d8fc85ea"}, + {file = "rpds_py-0.8.10-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37f7ee4dc86db7af3bac6d2a2cedbecb8e57ce4ed081f6464510e537589f8b1e"}, + {file = "rpds_py-0.8.10-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:695f642a3a5dbd4ad2ffbbacf784716ecd87f1b7a460843b9ddf965ccaeafff4"}, + {file = "rpds_py-0.8.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f43ab4cb04bde6109eb2555528a64dfd8a265cc6a9920a67dcbde13ef53a46c8"}, + {file = "rpds_py-0.8.10-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a11ab0d97be374efd04f640c04fe5c2d3dabc6dfb998954ea946ee3aec97056d"}, + {file = "rpds_py-0.8.10-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:92cf5b3ee60eef41f41e1a2cabca466846fb22f37fc580ffbcb934d1bcab225a"}, + {file = "rpds_py-0.8.10-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:ceaac0c603bf5ac2f505a78b2dcab78d3e6b706be6596c8364b64cc613d208d2"}, + {file = "rpds_py-0.8.10-cp39-none-win32.whl", hash = "sha256:dd4f16e57c12c0ae17606c53d1b57d8d1c8792efe3f065a37cb3341340599d49"}, + {file = "rpds_py-0.8.10-cp39-none-win_amd64.whl", hash = "sha256:c03a435d26c3999c2a8642cecad5d1c4d10c961817536af52035f6f4ee2f5dd0"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-macosx_10_7_x86_64.whl", hash = "sha256:0da53292edafecba5e1d8c1218f99babf2ed0bf1c791d83c0ab5c29b57223068"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:7d20a8ed227683401cc508e7be58cba90cc97f784ea8b039c8cd01111e6043e0"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97cab733d303252f7c2f7052bf021a3469d764fc2b65e6dbef5af3cbf89d4892"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8c398fda6df361a30935ab4c4bccb7f7a3daef2964ca237f607c90e9f3fdf66f"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2eb4b08c45f8f8d8254cdbfacd3fc5d6b415d64487fb30d7380b0d0569837bf1"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e7dfb1cbb895810fa2b892b68153c17716c6abaa22c7dc2b2f6dcf3364932a1c"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89c92b74e8bf6f53a6f4995fd52f4bd510c12f103ee62c99e22bc9e05d45583c"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e9c0683cb35a9b5881b41bc01d5568ffc667910d9dbc632a1fba4e7d59e98773"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:0eeb2731708207d0fe2619afe6c4dc8cb9798f7de052da891de5f19c0006c315"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:7495010b658ec5b52835f21d8c8b1a7e52e194c50f095d4223c0b96c3da704b1"}, + {file = "rpds_py-0.8.10-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:c72ebc22e70e04126158c46ba56b85372bc4d54d00d296be060b0db1671638a4"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:2cd3045e7f6375dda64ed7db1c5136826facb0159ea982f77d9cf6125025bd34"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:2418cf17d653d24ffb8b75e81f9f60b7ba1b009a23298a433a4720b2a0a17017"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a2edf8173ac0c7a19da21bc68818be1321998528b5e3f748d6ee90c0ba2a1fd"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f29b8c55fd3a2bc48e485e37c4e2df3317f43b5cc6c4b6631c33726f52ffbb3"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a7d20c1cf8d7b3960c5072c265ec47b3f72a0c608a9a6ee0103189b4f28d531"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:521fc8861a86ae54359edf53a15a05fabc10593cea7b3357574132f8427a5e5a"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5c191713e98e7c28800233f039a32a42c1a4f9a001a8a0f2448b07391881036"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:083df0fafe199371206111583c686c985dddaf95ab3ee8e7b24f1fda54515d09"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:ed41f3f49507936a6fe7003985ea2574daccfef999775525d79eb67344e23767"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:2614c2732bf45de5c7f9e9e54e18bc78693fa2f635ae58d2895b7965e470378c"}, + {file = "rpds_py-0.8.10-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:c60528671d9d467009a6ec284582179f6b88651e83367d0ab54cb739021cd7de"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:ee744fca8d1ea822480a2a4e7c5f2e1950745477143668f0b523769426060f29"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a38b9f526d0d6cbdaa37808c400e3d9f9473ac4ff64d33d9163fd05d243dbd9b"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:60e0e86e870350e03b3e25f9b1dd2c6cc72d2b5f24e070249418320a6f9097b7"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f53f55a8852f0e49b0fc76f2412045d6ad9d5772251dea8f55ea45021616e7d5"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c493365d3fad241d52f096e4995475a60a80f4eba4d3ff89b713bc65c2ca9615"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:300eb606e6b94a7a26f11c8cc8ee59e295c6649bd927f91e1dbd37a4c89430b6"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a665f6f1a87614d1c3039baf44109094926dedf785e346d8b0a728e9cabd27a"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:927d784648211447201d4c6f1babddb7971abad922b32257ab74de2f2750fad0"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:c200b30dd573afa83847bed7e3041aa36a8145221bf0cfdfaa62d974d720805c"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:08166467258fd0240a1256fce272f689f2360227ee41c72aeea103e9e4f63d2b"}, + {file = "rpds_py-0.8.10-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:996cc95830de9bc22b183661d95559ec6b3cd900ad7bc9154c4cbf5be0c9b734"}, + {file = "rpds_py-0.8.10.tar.gz", hash = "sha256:13e643ce8ad502a0263397362fb887594b49cf84bf518d6038c16f235f2bcea4"}, +] + [[package]] name = "ruff" version = "0.0.270" @@ -3421,40 +3537,38 @@ files = [ [[package]] name = "scipy" -version = "1.10.1" +version = "1.11.1" description = "Fundamental algorithms for scientific computing in Python" optional = false -python-versions = "<3.12,>=3.8" -files = [ - {file = "scipy-1.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e7354fd7527a4b0377ce55f286805b34e8c54b91be865bac273f527e1b839019"}, - {file = "scipy-1.10.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:4b3f429188c66603a1a5c549fb414e4d3bdc2a24792e061ffbd607d3d75fd84e"}, - {file = "scipy-1.10.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1553b5dcddd64ba9a0d95355e63fe6c3fc303a8fd77c7bc91e77d61363f7433f"}, - {file = "scipy-1.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c0ff64b06b10e35215abce517252b375e580a6125fd5fdf6421b98efbefb2d2"}, - {file = "scipy-1.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:fae8a7b898c42dffe3f7361c40d5952b6bf32d10c4569098d276b4c547905ee1"}, - {file = "scipy-1.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0f1564ea217e82c1bbe75ddf7285ba0709ecd503f048cb1236ae9995f64217bd"}, - {file = "scipy-1.10.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:d925fa1c81b772882aa55bcc10bf88324dadb66ff85d548c71515f6689c6dac5"}, - {file = "scipy-1.10.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaea0a6be54462ec027de54fca511540980d1e9eea68b2d5c1dbfe084797be35"}, - {file = "scipy-1.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15a35c4242ec5f292c3dd364a7c71a61be87a3d4ddcc693372813c0b73c9af1d"}, - {file = "scipy-1.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:43b8e0bcb877faf0abfb613d51026cd5cc78918e9530e375727bf0625c82788f"}, - {file = "scipy-1.10.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5678f88c68ea866ed9ebe3a989091088553ba12c6090244fdae3e467b1139c35"}, - {file = "scipy-1.10.1-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:39becb03541f9e58243f4197584286e339029e8908c46f7221abeea4b749fa88"}, - {file = "scipy-1.10.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bce5869c8d68cf383ce240e44c1d9ae7c06078a9396df68ce88a1230f93a30c1"}, - {file = "scipy-1.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07c3457ce0b3ad5124f98a86533106b643dd811dd61b548e78cf4c8786652f6f"}, - {file = "scipy-1.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:049a8bbf0ad95277ffba9b3b7d23e5369cc39e66406d60422c8cfef40ccc8415"}, - {file = "scipy-1.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cd9f1027ff30d90618914a64ca9b1a77a431159df0e2a195d8a9e8a04c78abf9"}, - {file = "scipy-1.10.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:79c8e5a6c6ffaf3a2262ef1be1e108a035cf4f05c14df56057b64acc5bebffb6"}, - {file = "scipy-1.10.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51af417a000d2dbe1ec6c372dfe688e041a7084da4fdd350aeb139bd3fb55353"}, - {file = "scipy-1.10.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b4735d6c28aad3cdcf52117e0e91d6b39acd4272f3f5cd9907c24ee931ad601"}, - {file = "scipy-1.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:7ff7f37b1bf4417baca958d254e8e2875d0cc23aaadbe65b3d5b3077b0eb23ea"}, - {file = "scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5"}, +python-versions = "<3.13,>=3.9" +files = [ + {file = "scipy-1.11.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:aec8c62fbe52914f9cf28d846cf0401dd80ab80788bbab909434eb336ed07c04"}, + {file = "scipy-1.11.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:3b9963798df1d8a52db41a6fc0e6fa65b1c60e85d73da27ae8bb754de4792481"}, + {file = "scipy-1.11.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e8eb42db36526b130dfbc417609498a6192381abc1975b91e3eb238e0b41c1a"}, + {file = "scipy-1.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:366a6a937110d80dca4f63b3f5b00cc89d36f678b2d124a01067b154e692bab1"}, + {file = "scipy-1.11.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:08d957ca82d3535b3b9ba6c8ff355d78fe975271874e2af267cb5add5bd78625"}, + {file = "scipy-1.11.1-cp310-cp310-win_amd64.whl", hash = "sha256:e866514bc2d660608447b6ba95c8900d591f2865c07cca0aa4f7ff3c4ca70f30"}, + {file = "scipy-1.11.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ba94eeef3c9caa4cea7b402a35bb02a5714ee1ee77eb98aca1eed4543beb0f4c"}, + {file = "scipy-1.11.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:512fdc18c65f76dadaca139348e525646d440220d8d05f6d21965b8d4466bccd"}, + {file = "scipy-1.11.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cce154372f0ebe88556ed06d7b196e9c2e0c13080ecb58d0f35062dc7cc28b47"}, + {file = "scipy-1.11.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4bb943010203465ac81efa392e4645265077b4d9e99b66cf3ed33ae12254173"}, + {file = "scipy-1.11.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:249cfa465c379c9bb2c20123001e151ff5e29b351cbb7f9c91587260602c58d0"}, + {file = "scipy-1.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:ffb28e3fa31b9c376d0fb1f74c1f13911c8c154a760312fbee87a21eb21efe31"}, + {file = "scipy-1.11.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:39154437654260a52871dfde852adf1b93b1d1bc5dc0ffa70068f16ec0be2624"}, + {file = "scipy-1.11.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:b588311875c58d1acd4ef17c983b9f1ab5391755a47c3d70b6bd503a45bfaf71"}, + {file = "scipy-1.11.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d51565560565a0307ed06fa0ec4c6f21ff094947d4844d6068ed04400c72d0c3"}, + {file = "scipy-1.11.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b41a0f322b4eb51b078cb3441e950ad661ede490c3aca66edef66f4b37ab1877"}, + {file = "scipy-1.11.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:396fae3f8c12ad14c5f3eb40499fd06a6fef8393a6baa352a652ecd51e74e029"}, + {file = "scipy-1.11.1-cp39-cp39-win_amd64.whl", hash = "sha256:be8c962a821957fdde8c4044efdab7a140c13294997a407eaee777acf63cbf0c"}, + {file = "scipy-1.11.1.tar.gz", hash = "sha256:fb5b492fa035334fd249f0973cc79ecad8b09c604b42a127a677b45a9a3d4289"}, ] [package.dependencies] -numpy = ">=1.19.5,<1.27.0" +numpy = ">=1.21.6,<1.28.0" [package.extras] -dev = ["click", "doit (>=0.36.0)", "flake8", "mypy", "pycodestyle", "pydevtool", "rich-click", "typing_extensions"] -doc = ["matplotlib (>2)", "numpydoc", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] +dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] test = ["asv", "gmpy2", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] [[package]] @@ -3480,13 +3594,13 @@ stats = ["scipy (>=1.3)", "statsmodels (>=0.10)"] [[package]] name = "sentry-sdk" -version = "1.25.1" +version = "1.28.0" description = "Python client for Sentry (https://sentry.io)" optional = false python-versions = "*" files = [ - {file = "sentry-sdk-1.25.1.tar.gz", hash = "sha256:aa796423eb6a2f4a8cd7a5b02ba6558cb10aab4ccdc0537f63a47b038c520c38"}, - {file = "sentry_sdk-1.25.1-py2.py3-none-any.whl", hash = "sha256:79afb7c896014038e358401ad1d36889f97a129dfa8031c49b3f238cd1aa3935"}, + {file = "sentry-sdk-1.28.0.tar.gz", hash = "sha256:2281ba98011cfa9bc9bb15c1074b6dd9f7fdfce94033cd25b50f18f078ffed4c"}, + {file = "sentry_sdk-1.28.0-py2.py3-none-any.whl", hash = "sha256:b8b363aaa3f3d6a3acc1aa571efa4db29fb440339fed03560bb1276b8d2c2509"}, ] [package.dependencies] @@ -3606,13 +3720,13 @@ test = ["pytest"] [[package]] name = "setuptools" -version = "67.8.0" +version = "68.0.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = false python-versions = ">=3.7" files = [ - {file = "setuptools-67.8.0-py3-none-any.whl", hash = "sha256:5df61bf30bb10c6f756eb19e7c9f3b473051f48db77fddbe06ff2ca307df9a6f"}, - {file = "setuptools-67.8.0.tar.gz", hash = "sha256:62642358adc77ffa87233bc4d2354c4b2682d214048f500964dbe760ccedf102"}, + {file = "setuptools-68.0.0-py3-none-any.whl", hash = "sha256:11e52c67415a381d10d6b462ced9cfb97066179f0e871399e006c4ab101fc85f"}, + {file = "setuptools-68.0.0.tar.gz", hash = "sha256:baf1fdb41c6da4cd2eae722e135500da913332ab3f2f5c7d33af9b492acb5235"}, ] [package.extras] @@ -4008,52 +4122,52 @@ test = ["pytest"] [[package]] name = "sqlalchemy" -version = "2.0.16" +version = "2.0.18" description = "Database Abstraction Library" optional = false python-versions = ">=3.7" files = [ - {file = "SQLAlchemy-2.0.16-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7641f6ed2682de84d77c4894cf2e43700f3cf7a729361d7f9cac98febf3d8614"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8d3cbdb2f07fb0e4b897dc1df39166735e194fb946f28f26f4c9f9801c8b24f7"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08a791c75d6154d46914d1e23bd81d9455f2950ec1de81f2723848c593d2c8b"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:91eb8f89fcce8f709f8a4d65d265bc48a80264ee14c7c9e955f3222f19b4b39c"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:fc1dae11bd5167f9eb53b3ccad24a79813004612141e76de21cf4c028dc30b34"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b2801f85c5c0293aa710f8aa5262c707a83c1c203962ae5a22b4d9095e71aa9d"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-win32.whl", hash = "sha256:c5e333b81fe10d14efebd4e9429b7bb865ed9463ca8bef07a7136dfa1fd4a37b"}, - {file = "SQLAlchemy-2.0.16-cp310-cp310-win_amd64.whl", hash = "sha256:f387b496a4c9474d8580195bb2660264a3f295a04d3a9d00f4fa15e9e597427e"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7be04dbe3470fe8dd332fdb48c979887c381ef6c635eddf2dec43d2766111be4"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2938edc512dd1fa48653e14c1655ab46144d4450f0e6b33da7acd8ba77fbfd7"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5a2856e12cf5f54301ddf043bcbf0552561d61555e1bcf348b63f42b8e1eec2"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d320fde566b864adbc19abb40ecb80f4e25d6f084639969bb972d5cca16858"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6e85e315725807c127ad8ba3d628fdb861cf9ebfb0e10c39a97c01e257cdd71b"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:63ea36c08792a7a8a08958bc806ecff6b491386feeaf14607c3d9d2d9325e67f"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-win32.whl", hash = "sha256:bdaf89dd82f4a0e1b8b5ffc9cdc0c9551be6175f7eee5af6a838e92ba2e57100"}, - {file = "SQLAlchemy-2.0.16-cp311-cp311-win_amd64.whl", hash = "sha256:5a934eff1a2882137be3384826f997db8441d43b61fda3094923e69fffe474be"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:fbcc51fdbc89fafe4f4fe66f59372a8be88ded04de34ef438ab04f980beb12d4"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff6496ad5e9dc8baeb93a151cc2f599d01e5f8928a2aaf0b09a06428fdbaf553"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d6ef848e5afcd1bda3e9a843751f845c0ca888b61e669237680e913d84ec206"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:3ef876615ff4b53e2033022195830ec4941a6e21068611f8d77de60203b90a98"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8544c6e62eacb77d5106e2055ef10f2407fc0dbd547e879f8745b2032eefd2bc"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-win32.whl", hash = "sha256:2f3b6c31b915159b96b68372212fa77f69230b0a32acab40cf539d2823954f5a"}, - {file = "SQLAlchemy-2.0.16-cp37-cp37m-win_amd64.whl", hash = "sha256:d0c96592f54edd571e00ba6b1ed5df8263328ca1da9e78088c0ebc93c2e6562c"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a2e9f50a906d0b81292576a9fb458f8cace904c81a67088f4a2ca9ff2856f55d"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:dc97238fa44be86971270943a0c21c19ce18b8d1596919048e57912e8abc02cc"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0db6734cb5644c55d0262a813b764c6e2cda1e66e939a488b3d6298cdc7344c2"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:131f0c894c6572cb1bdcf97c92d999d3128c4ff1ca13061296057072f61afe13"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f662cf69484c59f8a3435902c40dfc34d86050bdb15e23d437074ce9f153306b"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b72f4e4def50414164a1d899f2ce4e782a029fad0ed5585981d1611e8ae29a74"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-win32.whl", hash = "sha256:0e4645b260cfe375a0603aa117f0a47680864cf37833129da870919e88b08d8f"}, - {file = "SQLAlchemy-2.0.16-cp38-cp38-win_amd64.whl", hash = "sha256:f409f35a0330ab0cb18ece736b86d8b8233c64f4461fcb10993f67afc0ac7e5a"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e19546924f0cf2ec930d1faf318b7365e5827276410a513340f31a2b423e96a4"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ce1fc3f64fd42d5f763d6b83651471f32920338a1ba107a3186211474861af57"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e2569dac4e3cb85365b91ab569d06a221e0e17e65ce59949d00c3958946282b"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61f2035dea56ff1a429077e481496f813378beb02b823d2e3e7eb05bc1a7a8ca"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:81d867c1be5abd49f7e547c108391f371a9d980ba7ec34666c50d683f782b754"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:2de1477af7f48c633b8ecb88245aedd811dca88e88aee9e9d787b388abe74c44"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-win32.whl", hash = "sha256:5e8522b49e0e640287308b68f71cc338446bbe1c226c8f81743baa91b0246e92"}, - {file = "SQLAlchemy-2.0.16-cp39-cp39-win_amd64.whl", hash = "sha256:43e69c8c1cea0188b7094e22fb93ae1a1890aac748628b7e925024a206f75368"}, - {file = "SQLAlchemy-2.0.16-py3-none-any.whl", hash = "sha256:53081c6fce0d49bb36d05f12dc87e008c9b0df58a163b792c5fc4ac638925f98"}, - {file = "SQLAlchemy-2.0.16.tar.gz", hash = "sha256:1e2caba78e7d1f5003e88817b7a1754d4e58f4a8f956dc423bf8e304c568ab09"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7ddd6d35c598af872f9a0a5bce7f7c4a1841684a72dab3302e3df7f17d1b5249"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:00aa050faf24ce5f2af643e2b86822fa1d7149649995f11bc1e769bbfbf9010b"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b52c6741073de5a744d27329f9803938dcad5c9fee7e61690c705f72973f4175"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7db97eabd440327c35b751d5ebf78a107f505586485159bcc87660da8bb1fdca"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:589aba9a35869695b319ed76c6f673d896cd01a7ff78054be1596df7ad9b096f"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:9da4ee8f711e077633730955c8f3cd2485c9abf5ea0f80aac23221a3224b9a8c"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-win32.whl", hash = "sha256:5dd574a37be388512c72fe0d7318cb8e31743a9b2699847a025e0c08c5bf579d"}, + {file = "SQLAlchemy-2.0.18-cp310-cp310-win_amd64.whl", hash = "sha256:6852cd34d96835e4c9091c1e6087325efb5b607b75fd9f7075616197d1c4688a"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:10e001a84f820fea2640e4500e12322b03afc31d8f4f6b813b44813b2a7c7e0d"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bffd6cd47c2e68970039c0d3e355c9ed761d3ca727b204e63cd294cad0e3df90"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b7b3ebfa9416c8eafaffa65216e229480c495e305a06ba176dcac32710744e6"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79228a7b90d95957354f37b9d46f2cc8926262ae17b0d3ed8f36c892f2a37e06"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ba633b51835036ff0f402c21f3ff567c565a22ff0a5732b060a68f4660e2a38f"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8da677135eff43502b7afab5a1e641edfb2dc734ba7fc146e9b1b86817a728e2"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-win32.whl", hash = "sha256:82edf3a6090554a83942cec79151d6b5eb96e63d143e80e4cf6671e5d772f6be"}, + {file = "SQLAlchemy-2.0.18-cp311-cp311-win_amd64.whl", hash = "sha256:69ae0e9509c43474e33152abe1385b8954922544616426bf793481e1a37e094f"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:09397a18733fa2a4c7680b746094f980060666ee549deafdb5e102a99ce4619b"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45b07470571bda5ee7f5ec471271bbde97267cc8403fce05e280c36ea73f4754"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1aac42a21a7fa6c9665392c840b295962992ddf40aecf0a88073bc5c76728117"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:da46beef0ce882546d92b7b2e8deb9e04dbb8fec72945a8eb28b347ca46bc15a"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:a6f1d8256d06f58e6ece150fbe05c63c7f9510df99ee8ac37423f5476a2cebb4"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-win32.whl", hash = "sha256:67fbb40db3985c0cfb942fe8853ad94a5e9702d2987dec03abadc2f3b6a24afb"}, + {file = "SQLAlchemy-2.0.18-cp37-cp37m-win_amd64.whl", hash = "sha256:afb322ca05e2603deedbcd2e9910f11a3fd2f42bdeafe63018e5641945c7491c"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:908c850b98cac1e203ababd4ba76868d19ae0d7172cdc75d3f1b7829b16837d2"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:10514adc41fc8f5922728fbac13d401a1aefcf037f009e64ca3b92464e33bf0e"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b791577c546b6bbd7b43953565fcb0a2fec63643ad605353dd48afbc3c48317"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:420bc6d06d4ae7fb6921524334689eebcbea7bf2005efef070a8562cc9527a37"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:ebdd2418ab4e2e26d572d9a1c03877f8514a9b7436729525aa571862507b3fea"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:556dc18e39b6edb76239acfd1c010e37395a54c7fde8c57481c15819a3ffb13e"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-win32.whl", hash = "sha256:7b8cba5a25e95041e3413d91f9e50616bcfaec95afa038ce7dc02efefe576745"}, + {file = "SQLAlchemy-2.0.18-cp38-cp38-win_amd64.whl", hash = "sha256:0f7fdcce52cd882b559a57b484efc92e108efeeee89fab6b623aba1ac68aad2e"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d7a2c1e711ce59ac9d0bba780318bcd102d2958bb423209f24c6354d8c4da930"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5c95e3e7cc6285bf7ff263eabb0d3bfe3def9a1ff98124083d45e5ece72f4579"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc44e50f9d5e96af1a561faa36863f9191f27364a4df3eb70bca66e9370480b6"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfa1a0f83bdf8061db8d17c2029454722043f1e4dd1b3d3d3120d1b54e75825a"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:194f2d5a7cb3739875c4d25b3fe288ab0b3dc33f7c857ba2845830c8c51170a0"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4ebc542d2289c0b016d6945fd07a7e2e23f4abc41e731ac8ad18a9e0c2fd0ec2"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-win32.whl", hash = "sha256:774bd401e7993452ba0596e741c0c4d6d22f882dd2a798993859181dbffadc62"}, + {file = "SQLAlchemy-2.0.18-cp39-cp39-win_amd64.whl", hash = "sha256:2756485f49e7df5c2208bdc64263d19d23eba70666f14ad12d6d8278a2fff65f"}, + {file = "SQLAlchemy-2.0.18-py3-none-any.whl", hash = "sha256:6c5bae4c288bda92a7550fe8de9e068c0a7cd56b1c5d888aae5b40f0e13b40bd"}, + {file = "SQLAlchemy-2.0.18.tar.gz", hash = "sha256:1fb792051db66e09c200e7bc3bda3b1eb18a5b8eb153d2cedb2b14b56a68b8cb"}, ] [package.dependencies] @@ -4237,13 +4351,13 @@ test = ["mypy (>=1.2.0)", "pytest (>=7)"] [[package]] name = "typing-extensions" -version = "4.6.3" +version = "4.7.1" description = "Backported and Experimental Type Hints for Python 3.7+" optional = false python-versions = ">=3.7" files = [ - {file = "typing_extensions-4.6.3-py3-none-any.whl", hash = "sha256:88a4153d8505aabbb4e13aacb7c486c2b4a33ca3b3f807914a9b4c844c471c26"}, - {file = "typing_extensions-4.6.3.tar.gz", hash = "sha256:d91d5919357fe7f681a9f2b5b4cb2a5f1ef0a1e9f59c4d8ff0d3491e05c0ffd5"}, + {file = "typing_extensions-4.7.1-py3-none-any.whl", hash = "sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36"}, + {file = "typing_extensions-4.7.1.tar.gz", hash = "sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2"}, ] [[package]] @@ -4289,38 +4403,38 @@ socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] [[package]] name = "virtualenv" -version = "20.23.0" +version = "20.23.1" description = "Virtual Python Environment builder" optional = false python-versions = ">=3.7" files = [ - {file = "virtualenv-20.23.0-py3-none-any.whl", hash = "sha256:6abec7670e5802a528357fdc75b26b9f57d5d92f29c5462ba0fbe45feacc685e"}, - {file = "virtualenv-20.23.0.tar.gz", hash = "sha256:a85caa554ced0c0afbd0d638e7e2d7b5f92d23478d05d17a76daeac8f279f924"}, + {file = "virtualenv-20.23.1-py3-none-any.whl", hash = "sha256:34da10f14fea9be20e0fd7f04aba9732f84e593dac291b757ce42e3368a39419"}, + {file = "virtualenv-20.23.1.tar.gz", hash = "sha256:8ff19a38c1021c742148edc4f81cb43d7f8c6816d2ede2ab72af5b84c749ade1"}, ] [package.dependencies] distlib = ">=0.3.6,<1" -filelock = ">=3.11,<4" -platformdirs = ">=3.2,<4" +filelock = ">=3.12,<4" +platformdirs = ">=3.5.1,<4" [package.extras] -docs = ["furo (>=2023.3.27)", "proselint (>=0.13)", "sphinx (>=6.1.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=22.12)"] -test = ["covdefaults (>=2.3)", "coverage (>=7.2.3)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.3.1)", "pytest-env (>=0.8.1)", "pytest-freezegun (>=0.4.2)", "pytest-mock (>=3.10)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=67.7.1)", "time-machine (>=2.9)"] +docs = ["furo (>=2023.5.20)", "proselint (>=0.13)", "sphinx (>=7.0.1)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.3.1)", "pytest-env (>=0.8.1)", "pytest-freezer (>=0.4.6)", "pytest-mock (>=3.10)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=67.8)", "time-machine (>=2.9)"] [[package]] name = "wandb" -version = "0.15.4" +version = "0.15.5" description = "A CLI and library for interacting with the Weights and Biases API." optional = false python-versions = ">=3.6" files = [ - {file = "wandb-0.15.4-py3-none-any.whl", hash = "sha256:9018565177e1be14d7d0dd470c583206031c6027c32a98c57fa3bb83955143d7"}, - {file = "wandb-0.15.4.tar.gz", hash = "sha256:472daaaa1a4e29a46407a85fd77aadb724c91d87dfe2c37cd82ef77be2257011"}, + {file = "wandb-0.15.5-py3-none-any.whl", hash = "sha256:8cfb8fdaaf0a35b636d0ca2c2c1262b0e3d835ac37f70fc3094b618f55f63f01"}, + {file = "wandb-0.15.5.tar.gz", hash = "sha256:40c1d9ae501194bff408bc9c555865ffcccf08d2d65dd413547df0c17ed20cb5"}, ] [package.dependencies] appdirs = ">=1.4.3" -Click = ">=7.0,<8.0.0 || >8.0.0" +Click = ">=7.1,<8.0.0 || >8.0.0" docker-pycreds = ">=0.4.0" GitPython = ">=1.0.0,<3.1.29 || >3.1.29" pathtools = "*" @@ -4343,7 +4457,7 @@ azure = ["azure-identity", "azure-storage-blob"] gcp = ["google-cloud-storage"] grpc = ["grpcio (>=1.27.2)"] kubeflow = ["google-cloud-storage", "kubernetes", "minio", "sh"] -launch = ["awscli", "boto3", "botocore", "chardet", "google-auth", "google-cloud-artifact-registry", "google-cloud-compute", "google-cloud-storage", "iso8601", "kubernetes", "nbconvert", "nbformat", "optuna", "typing-extensions"] +launch = ["awscli", "azure-containerregistry", "azure-identity", "azure-storage-blob", "boto3", "botocore", "chardet", "google-auth", "google-cloud-artifact-registry", "google-cloud-compute", "google-cloud-storage", "iso8601", "kubernetes", "nbconvert", "nbformat", "optuna", "typing-extensions"] media = ["bokeh", "moviepy", "numpy", "pillow", "plotly", "rdkit-pypi", "soundfile"] models = ["cloudpickle"] sweeps = ["sweeps (>=0.2.0)"] @@ -4373,6 +4487,17 @@ files = [ [package.extras] test = ["pytest (>=6.0.0)"] +[[package]] +name = "widgetsnbextension" +version = "4.0.8" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.8-py3-none-any.whl", hash = "sha256:2e37f0ce9da11651056280c7efe96f2db052fe8fc269508e3724f5cbd6c93018"}, + {file = "widgetsnbextension-4.0.8.tar.gz", hash = "sha256:9ec291ba87c2dfad42c3d5b6f68713fa18be1acd7476569516b2431682315c17"}, +] + [[package]] name = "win32-setctime" version = "1.1.0" @@ -4389,13 +4514,13 @@ dev = ["black (>=19.3b0)", "pytest (>=4.6.2)"] [[package]] name = "xarray" -version = "2023.5.0" +version = "2023.6.0" description = "N-D labeled arrays and datasets in Python" optional = false python-versions = ">=3.9" files = [ - {file = "xarray-2023.5.0-py3-none-any.whl", hash = "sha256:b62f19bb04e68f684a92a8a458c63c91cf76e6fabe54cf4438f7e2ca56348854"}, - {file = "xarray-2023.5.0.tar.gz", hash = "sha256:318a651f4182b9cecb7d1c57ad0ed9bdaed5f49c43dbb638c0a845b8faf405e8"}, + {file = "xarray-2023.6.0-py3-none-any.whl", hash = "sha256:bdd4c45511ab4e84f4249ea1030336db59b750968f25369d8e132d6d7ead7cc9"}, + {file = "xarray-2023.6.0.tar.gz", hash = "sha256:267a231ee4efc0341ebbffc6d4ec60e4a66e4849c16e0305c03fcefeca77698c"}, ] [package.dependencies] @@ -4449,20 +4574,20 @@ jupyter = ["ipytree (>=0.2.2)", "ipywidgets (>=8.0.0)", "notebook"] [[package]] name = "zipp" -version = "3.15.0" +version = "3.16.0" description = "Backport of pathlib-compatible object wrapper for zip files" optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "zipp-3.15.0-py3-none-any.whl", hash = "sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556"}, - {file = "zipp-3.15.0.tar.gz", hash = "sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b"}, + {file = "zipp-3.16.0-py3-none-any.whl", hash = "sha256:5dadc3ad0a1f825fe42ce1bce0f2fc5a13af2e6b2d386af5b0ff295bc0a287d3"}, + {file = "zipp-3.16.0.tar.gz", hash = "sha256:1876cb065531855bbe83b6c489dcf69ecc28f1068d8e95959fe8bbc77774c941"}, ] [package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["big-O", "flake8 (<5)", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff"] [metadata] lock-version = "2.0" python-versions = ">=3.9,<3.12" -content-hash = "bcef7cad8defb1db5914e5485fa06a16676922f13c1eeaf0a7bbc0205259dcda" +content-hash = "c95caf85f49fa63819df616cfe5768575e916762130f562600b36430d4684af9" diff --git a/pyproject.toml b/pyproject.toml index 9a8cc96..ce1ef4d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -48,6 +48,7 @@ ruff = "^0.0.270" nbqa = "^1.7.0" intake-xarray = "^0.7.0" numba = "^0.57.0" +ipywidgets = "^8.0.7" [tool.poetry.group.exp.dependencies] @@ -92,7 +93,7 @@ requires = ["poetry-core>=1.0.0"] build-backend = "poetry.core.masonry.api" [tool.pytest.ini_options] -testpaths = ["jaxsw"] +testpaths = ["jaxsw/"] [tool.nbqa.ignore] ruff = ["I001", "F821", "F541"]