From 765a1da0b85fb19114a5c2013ee7ce4aa0eeaf1a Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 08:09:03 +0200 Subject: [PATCH 01/21] Add simple Fourier interpolator --- exponax/__init__.py | 2 + exponax/_interpolation.py | 77 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+) create mode 100644 exponax/_interpolation.py diff --git a/exponax/__init__.py b/exponax/__init__.py index 2366a33..bb65e9b 100644 --- a/exponax/__init__.py +++ b/exponax/__init__.py @@ -4,6 +4,7 @@ from . import etdrk, ic, nonlin_fun, stepper, viz from ._base_stepper import BaseStepper from ._forced_stepper import ForcedStepper +from ._interpolation import FourierInterpolator from ._repeated_stepper import RepeatedStepper from ._spectral import derivative, fft, ifft, make_incompressible from ._utils import ( @@ -39,4 +40,5 @@ "stepper", "viz", "spectral", + "FourierInterpolator", ] diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py new file mode 100644 index 0000000..ddb196d --- /dev/null +++ b/exponax/_interpolation.py @@ -0,0 +1,77 @@ +""" +Utilities to map Exponax states to different grids. +""" +from typing import TypeVar + +import equinox as eqx +import jax +import jax.numpy as jnp +from jaxtyping import Array, Complex, Float + +from ._spectral import build_scaled_wavenumbers, build_scaling_array, fft, space_indices + +C = TypeVar("C") # Channel axis +D = TypeVar( + "D" +) # Dimension axis - must have as many dimensions as the array has subsequent spatial axes + + +class FourierInterpolator(eqx.Module): + num_spatial_dims: int + domain_extent: float + num_points: int + state_hat_scaled: Complex[Array, "C ... (N//2)+1"] + wavenumbers: Float[Array, "D ... (N//2)+1"] + + def __init__( + self, + state: Float[Array, "C ... N"], + *, + domain_extent: float = 1.0, + ): + """ + Assumes that the indexing convention is "ij" + """ + self.num_spatial_dims = state.ndim - 1 + self.domain_extent = domain_extent + self.num_points = state.shape[-1] + + self.state_hat_scaled = fft( + state, num_spatial_dims=self.num_spatial_dims + ) / build_scaling_array(self.num_spatial_dims, self.num_points) + self.wavenumbers = build_scaled_wavenumbers( + self.num_spatial_dims, self.domain_extent, self.num_points + ) + + def __call__( + self, + x: Float[Array, "D"], + ) -> Float[Array, "C"]: + """ + use `jax.vmap(..., axis=(-1))` on this for batched operation + """ + # Adds singleton axes for each spatial dimension + x_bloated: Float[Array, "D ... 1"] = jnp.expand_dims( + x, axis=space_indices(self.num_spatial_dims) + ) + # Adds singleton axis for channels + x_bloated: Float[Array, "1 D ... 1"] = x_bloated[None] + + # Add singleton axis at position where `x_bloated` has its spatial axis + # D + state_hat_scaled_bloated: Complex[ + Array, "C 1 ... (N//2)+1" + ] = self.state_hat_scaled[:, None] + + # Add singleton axis for channels + wavenumbers_bloated: Float[Array, "1 D ... (N//2)+1"] = self.wavenumbers[None] + + interpolation_operation: Complex[ + Array, "C D ... (N//2)+1" + ] = state_hat_scaled_bloated * jnp.exp(1j * wavenumbers_bloated * x_bloated) + + interpolated_value: Float[Array, "C"] = jnp.real( + jax.vmap(jnp.sum)(interpolation_operation) + ) + + return interpolated_value From e205ed896f6a19b099bd25e3ab3fe8a74b9aaadb Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 08:18:59 +0200 Subject: [PATCH 02/21] Add 1D tests --- tests/test_interpolation.py | 40 +++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 tests/test_interpolation.py diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py new file mode 100644 index 0000000..703086c --- /dev/null +++ b/tests/test_interpolation.py @@ -0,0 +1,40 @@ +import jax.numpy as jnp +import pytest +from jaxtyping import Array, Float + +import exponax as ex + +FN_DICT_1D = { + "constant": lambda x: 3.0 * jnp.ones_like(x), + "simple_sine": lambda x: jnp.sin(2 * jnp.pi * x), + "simple_cosine": lambda x: jnp.cos(2 * jnp.pi * x), + "complicated_fn": lambda x: jnp.exp(-3 * (x - 5.0) ** 2), +} + + +@pytest.mark.parametrize( + "fn_name, domain_extent, num_points, query_location", + [ + ("constant", 1.0, 10, jnp.array([0.3])), + ("simple_sine", 1.0, 10, jnp.array([0.3])), + ("simple_cosine", 1.0, 10, jnp.array([0.3])), + ("complicated_fn", 10.0, 100, jnp.array([4.737])), + ], +) +def test_fourier_interpolator_1d( + fn_name: str, + domain_extent: float, + num_points: int, + query_location: Float[Array, "1"], +): + fn = FN_DICT_1D[fn_name] + grid = ex.make_grid(1, domain_extent, num_points) + + u = fn(grid) + + interpolator = ex.FourierInterpolator(u, domain_extent=domain_extent) + + interpolated_u = interpolator(query_location) + correct_val = fn(query_location) + + assert interpolated_u == pytest.approx(correct_val) From e0f4c0e4037418c4e04a1e2e48e811d9046c5c09 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:10:34 +0200 Subject: [PATCH 03/21] Add tests in 2d --- tests/test_interpolation.py | 51 +++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index 703086c..21568a0 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -38,3 +38,54 @@ def test_fourier_interpolator_1d( correct_val = fn(query_location) assert interpolated_u == pytest.approx(correct_val) + + +FN_DICT_2D = { + "constant": lambda x: 3.0 * jnp.ones_like(x[0:1]), + "simple_sine_x": lambda x: jnp.sin(2 * jnp.pi * x[0:1]), + "simple_cosine_x": lambda x: jnp.cos(2 * jnp.pi * x[0:1]), + "simple_sine_y": lambda x: jnp.sin(2 * jnp.pi * x[1:2]), + "simple_cosine_y": lambda x: jnp.cos(2 * jnp.pi * x[1:2]), + "mixed_sine": lambda x: jnp.sin(2 * jnp.pi * x[0:1]) * jnp.sin(6 * jnp.pi * x[1:2]), + "mixed_cosine": lambda x: jnp.cos(2 * jnp.pi * x[0:1]) + * jnp.cos(6 * jnp.pi * x[1:2]), + "complicated_fn_x": lambda x: jnp.exp(-3 * (x[0:1] - 5.0) ** 2), + "complicated_fn_y": lambda x: jnp.exp(-3 * (x[1:2] - 5.0) ** 2), + "complicated_fn_xy": lambda x: jnp.exp( + -3 * ((x[0:1] - 5.0) ** 2 + (x[1:2] - 5.0) ** 2) + ), +} + + +@pytest.mark.parametrize( + "fn_name, domain_extent, num_points, query_location", + [ + ("constant", 1.0, 20, jnp.array([0.3, 0.3])), + ("simple_sine_x", 1.0, 20, jnp.array([0.3, 0.3])), + ("simple_cosine_x", 1.0, 20, jnp.array([0.3, 0.3])), + ("simple_sine_y", 1.0, 20, jnp.array([0.3, 0.3])), + ("simple_cosine_y", 1.0, 20, jnp.array([0.3, 0.3])), + ("mixed_sine", 1.0, 20, jnp.array([0.3, 0.3])), + ("mixed_cosine", 1.0, 20, jnp.array([0.3, 0.3])), + ("complicated_fn_x", 10.0, 100, jnp.array([4.737, 0.3])), + ("complicated_fn_y", 10.0, 100, jnp.array([0.3, 4.737])), + ("complicated_fn_xy", 10.0, 100, jnp.array([4.737, 4.737])), + ], +) +def test_fourier_interpolator_2d( + fn_name: str, + domain_extent: float, + num_points: int, + query_location: Float[Array, "2"], +): + fn = FN_DICT_2D[fn_name] + grid = ex.make_grid(2, domain_extent, num_points) + + u = fn(grid) + + interpolator = ex.FourierInterpolator(u, domain_extent=domain_extent) + + interpolated_u = interpolator(query_location) + correct_val = fn(query_location) + + assert interpolated_u == pytest.approx(correct_val) From 4d3f634a5f88272a57e0f7d5ccba2dd68f8aac7e Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:11:20 +0200 Subject: [PATCH 04/21] Loosen tests --- tests/test_interpolation.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index 21568a0..2f3604f 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -88,4 +88,5 @@ def test_fourier_interpolator_2d( interpolated_u = interpolator(query_location) correct_val = fn(query_location) - assert interpolated_u == pytest.approx(correct_val) + # Looser rel and abs tol because JAX runs in single precision by default + assert interpolated_u == pytest.approx(correct_val, rel=1e-5, abs=1e-5) From ddfa0862c459124bd577f68537754ac71f6f01fb Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:15:54 +0200 Subject: [PATCH 05/21] Fix the generalization to 2d --- exponax/_interpolation.py | 35 +++++++++++++------------ exponax/_spectral.py | 55 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+), 16 deletions(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index ddb196d..0e835d2 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -8,12 +8,18 @@ import jax.numpy as jnp from jaxtyping import Array, Complex, Float -from ._spectral import build_scaled_wavenumbers, build_scaling_array, fft, space_indices +from ._spectral import ( + build_reconstructional_scaling_array, + build_scaled_wavenumbers, + fft, + space_indices, +) C = TypeVar("C") # Channel axis D = TypeVar( "D" ) # Dimension axis - must have as many dimensions as the array has subsequent spatial axes +N = TypeVar("N") # Spatial axis class FourierInterpolator(eqx.Module): @@ -36,9 +42,9 @@ def __init__( self.domain_extent = domain_extent self.num_points = state.shape[-1] - self.state_hat_scaled = fft( - state, num_spatial_dims=self.num_spatial_dims - ) / build_scaling_array(self.num_spatial_dims, self.num_points) + self.state_hat_scaled = fft(state, num_spatial_dims=self.num_spatial_dims) / ( + build_reconstructional_scaling_array(self.num_spatial_dims, self.num_points) + ) self.wavenumbers = build_scaled_wavenumbers( self.num_spatial_dims, self.domain_extent, self.num_points ) @@ -54,21 +60,18 @@ def __call__( x_bloated: Float[Array, "D ... 1"] = jnp.expand_dims( x, axis=space_indices(self.num_spatial_dims) ) - # Adds singleton axis for channels - x_bloated: Float[Array, "1 D ... 1"] = x_bloated[None] - # Add singleton axis at position where `x_bloated` has its spatial axis - # D - state_hat_scaled_bloated: Complex[ - Array, "C 1 ... (N//2)+1" - ] = self.state_hat_scaled[:, None] + # The exponential term sums over the wavenumber dimension axis (`"D"`) + exp_term: Complex[Array, "... (N//2)+1"] = jnp.exp( + jnp.sum(1j * self.wavenumbers * x_bloated, axis=0) + ) - # Add singleton axis for channels - wavenumbers_bloated: Float[Array, "1 D ... (N//2)+1"] = self.wavenumbers[None] + # Re-add a singleton channel axis to have broadcasting work correctly + exp_term: Complex[Array, "1 ... (N//2)+1"] = exp_term[None, :] - interpolation_operation: Complex[ - Array, "C D ... (N//2)+1" - ] = state_hat_scaled_bloated * jnp.exp(1j * wavenumbers_bloated * x_bloated) + interpolation_operation: Complex[Array, "C ... (N//2)+1"] = ( + self.state_hat_scaled * exp_term + ) interpolated_value: Float[Array, "C"] = jnp.real( jax.vmap(jnp.sum)(interpolation_operation) diff --git a/exponax/_spectral.py b/exponax/_spectral.py index c814646..9f46725 100644 --- a/exponax/_spectral.py +++ b/exponax/_spectral.py @@ -365,6 +365,61 @@ def build_scaling_array( return scaling +def build_reconstructional_scaling_array( + num_spatial_dims: int, + num_points: int, + *, + indexing: str = "ij", +) -> Float[Array, "1 ... (N//2)+1"]: + """ + Similar to `build_scaling_array`, but TODO + """ + right_most_wavenumbers = jnp.fft.rfftfreq(num_points, 1 / num_points) + other_wavenumbers = jnp.fft.fftfreq(num_points, 1 / num_points) + + right_most_scaling = jnp.where( + right_most_wavenumbers == 0, + num_points, + num_points / 2, + ) + other_scaling = jnp.where( + other_wavenumbers == 0, + num_points, + num_points, # This is the only difference to `build_scaling_array` + ) + + # If N is even, special treatment for the Nyquist mode + if num_points % 2 == 0: + # rfft has the Nyquist mode as positive wavenumber + right_most_scaling = jnp.where( + right_most_wavenumbers == num_points // 2, + num_points, + right_most_scaling, + ) + # standard fft has the Nyquist mode as negative wavenumber + other_scaling = jnp.where( + other_wavenumbers == -num_points // 2, + num_points, + other_scaling, + ) + + scaling_list = [ + other_scaling, + ] * (num_spatial_dims - 1) + [ + right_most_scaling, + ] + + scaling = jnp.prod( + jnp.stack( + jnp.meshgrid(*scaling_list, indexing=indexing), + ), + axis=0, + keepdims=True, + ) + + return scaling + + def fft( field: Float[Array, "C ... N"], *, From c96fe3e1193bc9b0062b75a16c49b1d7e9ce9507 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:17:41 +0200 Subject: [PATCH 06/21] Add tests in 3d --- tests/test_interpolation.py | 73 +++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index 2f3604f..996da20 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -90,3 +90,76 @@ def test_fourier_interpolator_2d( # Looser rel and abs tol because JAX runs in single precision by default assert interpolated_u == pytest.approx(correct_val, rel=1e-5, abs=1e-5) + + +FN_DICT_3D = { + "constant": lambda x: 3.0 * jnp.ones_like(x[0:1]), + "simple_sine_x": lambda x: jnp.sin(2 * jnp.pi * x[0:1]), + "simple_cosine_x": lambda x: jnp.cos(2 * jnp.pi * x[0:1]), + "simple_sine_y": lambda x: jnp.sin(2 * jnp.pi * x[1:2]), + "simple_cosine_y": lambda x: jnp.cos(2 * jnp.pi * x[1:2]), + "simple_sine_z": lambda x: jnp.sin(2 * jnp.pi * x[2:3]), + "simple_cosine_z": lambda x: jnp.cos(2 * jnp.pi * x[2:3]), + "mixed_sine": lambda x: jnp.sin(2 * jnp.pi * x[0:1]) + * jnp.sin(6 * jnp.pi * x[1:2]) + * jnp.sin(10 * jnp.pi * x[2:3]), + "mixed_cosine": lambda x: jnp.cos(2 * jnp.pi * x[0:1]) + * jnp.cos(6 * jnp.pi * x[1:2]) + * jnp.cos(10 * jnp.pi * x[2:3]), + "complicated_fn_x": lambda x: jnp.exp(-3 * (x[0:1] - 5.0) ** 2), + "complicated_fn_y": lambda x: jnp.exp(-3 * (x[1:2] - 5.0) ** 2), + "complicated_fn_z": lambda x: jnp.exp(-3 * (x[2:3] - 5.0) ** 2), + "complicated_fn_xy": lambda x: jnp.exp( + -3 * ((x[0:1] - 5.0) ** 2 + (x[1:2] - 5.0) ** 2) + ), + "complicated_fn_xz": lambda x: jnp.exp( + -3 * ((x[0:1] - 5.0) ** 2 + (x[2:3] - 5.0) ** 2) + ), + "complicated_fn_yz": lambda x: jnp.exp( + -3 * ((x[1:2] - 5.0) ** 2 + (x[2:3] - 5.0) ** 2) + ), + "complicated_fn_xyz": lambda x: jnp.exp( + -3 * ((x[0:1] - 5.0) ** 2 + (x[1:2] - 5.0) ** 2 + (x[2:3] - 5.0) ** 2) + ), +} + + +@pytest.mark.parametrize( + "fn_name, domain_extent, num_points, query_location", + [ + ("constant", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("simple_sine_x", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("simple_cosine_x", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("simple_sine_y", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("simple_cosine_y", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("simple_sine_z", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("simple_cosine_z", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("mixed_sine", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("mixed_cosine", 1.0, 30, jnp.array([0.3, 0.3, 0.3])), + ("complicated_fn_x", 10.0, 100, jnp.array([4.737, 0.3, 0.3])), + ("complicated_fn_y", 10.0, 100, jnp.array([0.3, 4.737, 0.3])), + ("complicated_fn_z", 10.0, 100, jnp.array([0.3, 0.3, 4.737])), + ("complicated_fn_xy", 10.0, 100, jnp.array([4.737, 4.737, 0.3])), + ("complicated_fn_xz", 10.0, 100, jnp.array([4.737, 0.3, 4.737])), + ("complicated_fn_yz", 10.0, 100, jnp.array([0.3, 4.737, 4.737])), + ("complicated_fn_xyz", 10.0, 100, jnp.array([4.737, 4.737, 4.737])), + ], +) +def test_fourier_interpolator_3d( + fn_name: str, + domain_extent: float, + num_points: int, + query_location: Float[Array, "3"], +): + fn = FN_DICT_3D[fn_name] + grid = ex.make_grid(3, domain_extent, num_points) + + u = fn(grid) + + interpolator = ex.FourierInterpolator(u, domain_extent=domain_extent) + + interpolated_u = interpolator(query_location) + correct_val = fn(query_location) + + # Looser rel and abs tol because JAX runs in single precision by default + assert interpolated_u == pytest.approx(correct_val, rel=1e-5, abs=1e-5) From b3ba3f1abd8985add0ff787e1f559c16393a181c Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:23:25 +0200 Subject: [PATCH 07/21] Forward indexing convention --- exponax/_interpolation.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index 0e835d2..bf121d2 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -34,6 +34,7 @@ def __init__( state: Float[Array, "C ... N"], *, domain_extent: float = 1.0, + indexing: str = "ij", ): """ Assumes that the indexing convention is "ij" @@ -43,10 +44,15 @@ def __init__( self.num_points = state.shape[-1] self.state_hat_scaled = fft(state, num_spatial_dims=self.num_spatial_dims) / ( - build_reconstructional_scaling_array(self.num_spatial_dims, self.num_points) + build_reconstructional_scaling_array( + self.num_spatial_dims, self.num_points, indexing=indexing + ) ) self.wavenumbers = build_scaled_wavenumbers( - self.num_spatial_dims, self.domain_extent, self.num_points + self.num_spatial_dims, + self.domain_extent, + self.num_points, + indexing=indexing, ) def __call__( From e70f15e82f066d85698b89f82859967c028393eb Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:24:20 +0200 Subject: [PATCH 08/21] Correctly use ellipsis --- exponax/_interpolation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index bf121d2..4bfb044 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -73,7 +73,7 @@ def __call__( ) # Re-add a singleton channel axis to have broadcasting work correctly - exp_term: Complex[Array, "1 ... (N//2)+1"] = exp_term[None, :] + exp_term: Complex[Array, "1 ... (N//2)+1"] = exp_term[None, ...] interpolation_operation: Complex[Array, "C ... (N//2)+1"] = ( self.state_hat_scaled * exp_term From 182faa952a45f5c9e7e9c78a75df705f19ca6474 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:43:58 +0200 Subject: [PATCH 09/21] Add documentation --- exponax/_interpolation.py | 106 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 102 insertions(+), 4 deletions(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index 4bfb044..a3b6c00 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -1,7 +1,7 @@ """ Utilities to map Exponax states to different grids. """ -from typing import TypeVar +from typing import Literal, TypeVar import equinox as eqx import jax @@ -34,10 +34,45 @@ def __init__( state: Float[Array, "C ... N"], *, domain_extent: float = 1.0, - indexing: str = "ij", + indexing: Literal["ij", "xy"] = "ij", ): """ - Assumes that the indexing convention is "ij" + Builds an interpolation function for an `Exponax` state using its + Fourier representation. + + After instantiation, the interpolant can be called with a query + coordinate `x ∈ ℝᴰ` (e.g., `x = jnp.array([0.3, 0.5])` in 2D) to obtain + the corresponding value. If the query coordinate is not within the + domain, i.e., `x ∉ Ω = [0, L]ᴰ`, the returned result is found in its + periodic extension. + + !!! info + If the state is band-limited, i.e., the highest wavenumber + containing non-zero energy is at max `(N//2)`, then the + interpolation will be exact (no interpolation error). + + !!! warning + This interpolation uses global basis functions. Hence its memory and + computation for evaluating one query location scales with `O(N^D)`. + Consequently, if multiple query locations are to be evaluated in + parallel (via `jax.vmap`), the memory and computation scales with + `O(N^D * M)` where `M` is the number of query locations. This can + easily exceed available resources. In such cases, either consider + evaluating the query locations in smaller batches or resort to local + basis interpolants like linear or cubic splines (see + `scipy.interpolate` or its JAX anologons). + + **Arguments:** + + - `state`: The state to interpolate. Must conform to the `Exponax` + standard with a leading channel axis (can be a singleton axis if + there is only one channel), and one, two, or three subsequent + spatial axes (depending on the number of spatial dimensions). These + latter spatial axes must have the same number of dimensions. + - `domain_extent`: The size of the domain `L`; in higher dimensions the + domain is assumed to be a scaled hypercube `Ω = (0, L)ᴰ`. + - `indexing`: The indexing convention of the spatial axes. The default + `"ij"` follows the `Exponax` convention. """ self.num_spatial_dims = state.ndim - 1 self.domain_extent = domain_extent @@ -60,7 +95,70 @@ def __call__( x: Float[Array, "D"], ) -> Float[Array, "C"]: """ - use `jax.vmap(..., axis=(-1))` on this for batched operation + Evaluate the interpolant at the query location `x`. + + **Arguments:** + + - `x`: The query location. Must be a vector of length `D` where `D` is + the number of spatial dimensions. This must match the number of + spatial dimensions of the state used to build the interpolant. + + **Returns:** + + - `interpolated_value`: The interpolated value at the query location + `x`. This will have as many channels as the state used to build the + interpolant. + + + !!! tip + To evaluate the interpolant at multiple query locations in parallel, + use `jax.vmap`. For example, in 1d: + + ```python + + print(state.shape) # (C, N) + + interpolator = FourierInterpolator(state, domain_extent=1.0) + + print(query_locations.shape) # (1, M) + + interpolated_values = jax.vmap( + interpolator, in_axes=-1, out_axes=-1, + )(query_locations) + + print(interpolated_values.shape) # (C, M) + + ``` + + If the query locations have multiple batch axes (e.g., to represent + another grid), consider using nested `jax.vmap` calls. For example, + in 2D + + ```python + + print(state.shape) # (C, N, N) + + interpolator = FourierInterpolator(state, domain_extent=1.0) + + print(query_locations.shape) # (2, M, P) + + interpolated_values = jax.vmap( + jax.vmap(interpolator, in_axes=-1, out_axes=-1), in_axes=-2, + out_axes=-2, + )(query_locations) + + print(interpolated_values.shape) # (C, M, P) + + ``` + + !!! warning + This interpolation uses global basis functions. Hence its memory and + computation for evaluating one query location scales with `O(N^D)`. + Consequently, if multiple query locations are to be evaluated in + parallel (via `jax.vmap`), the memory and computation scales with + `O(N^D * M)` where `M` is the number of query locations. This can + easily exceed available resources. In such cases, consider + evaluating the query locations in smaller batches. """ # Adds singleton axes for each spatial dimension x_bloated: Float[Array, "D ... 1"] = jnp.expand_dims( From 1bc0982c8d32add1a33beb3a0e675f76202566bd Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 09:44:58 +0200 Subject: [PATCH 10/21] Add documentation --- exponax/_spectral.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/exponax/_spectral.py b/exponax/_spectral.py index 9f46725..9df4d9b 100644 --- a/exponax/_spectral.py +++ b/exponax/_spectral.py @@ -372,7 +372,8 @@ def build_reconstructional_scaling_array( indexing: str = "ij", ) -> Float[Array, "1 ... (N//2)+1"]: """ - Similar to `build_scaling_array`, but TODO + Similar to `build_scaling_array`, but corresponds to the scaling observed + when reconstructing a signal from its Fourier transform. """ right_most_wavenumbers = jnp.fft.rfftfreq(num_points, 1 / num_points) other_wavenumbers = jnp.fft.fftfreq(num_points, 1 / num_points) From 8cb920a8c44ba08cf8e77bf8e03fd47b5ce3712c Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 10:21:41 +0200 Subject: [PATCH 11/21] Add utility to get modes slices --- exponax/_spectral.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/exponax/_spectral.py b/exponax/_spectral.py index 9df4d9b..14b533a 100644 --- a/exponax/_spectral.py +++ b/exponax/_spectral.py @@ -1,3 +1,4 @@ +from itertools import product from typing import Optional, TypeVar, Union import jax.numpy as jnp @@ -421,6 +422,35 @@ def build_reconstructional_scaling_array( return scaling +def get_modes_slices(num_spatial_dims: int, num_points: int) -> list[list[slice]]: + """ + Produces a list of list of slices corresponding to all positive and negative + wavenumber blocks found in the representation of a state in Fourier space. + """ + is_even = num_points % 2 == 0 + nyquist_mode = num_points // 2 + if is_even: + left_slice = slice(None, nyquist_mode) + right_slice = slice(-nyquist_mode, None) + else: + left_slice = slice(None, nyquist_mode + 1) + right_slice = slice(-nyquist_mode, None) + + # Starts with the right-most slice which is associated with the axis over + # which we apply the rfft + slices_ = [[slice(None, nyquist_mode + 1)]] + # All other axes have both positive and negative wavenumbers + slices_ += [[left_slice, right_slice] for _ in range(num_spatial_dims - 1)] + all_modes_slices = [ + [ + slice(None), + ] + + list(reversed(p)) + for p in product(*slices_) + ] + return all_modes_slices + + def fft( field: Float[Array, "C ... N"], *, From 4a7f731304a02a4233a2176d883acfb3bab41226 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 10:22:02 +0200 Subject: [PATCH 12/21] Add test for mode slice generation --- tests/test_mode_slices_generation.py | 75 ++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 tests/test_mode_slices_generation.py diff --git a/tests/test_mode_slices_generation.py b/tests/test_mode_slices_generation.py new file mode 100644 index 0000000..3e825c3 --- /dev/null +++ b/tests/test_mode_slices_generation.py @@ -0,0 +1,75 @@ +import exponax as ex + + +def test_mode_slices_generation(): + # 1D + assert ex.spectral.get_modes_slices(1, 10) == [ + [slice(None), slice(None, (10 // 2) + 1)] + ] + assert ex.spectral.get_modes_slices(1, 11) == [ + [slice(None), slice(None, (11 // 2) + 1)] + ] + + # 2D + assert ex.spectral.get_modes_slices(2, 10) == [ + [slice(None), slice(None, (10 // 2)), slice(None, (10 // 2) + 1)], + [slice(None), slice(-(10 // 2), None), slice(None, (10 // 2) + 1)], + ] + assert ex.spectral.get_modes_slices(2, 11) == [ + [slice(None), slice(None, (11 // 2) + 1), slice(None, (11 // 2) + 1)], + [slice(None), slice(-(11 // 2), None), slice(None, (11 // 2) + 1)], + ] + + # 3D + assert ex.spectral.get_modes_slices(3, 10) == [ + [ + slice(None), + slice(None, (10 // 2)), + slice(None, (10 // 2)), + slice(None, (10 // 2) + 1), + ], + [ + slice(None), + slice(-(10 // 2), None), + slice(None, (10 // 2)), + slice(None, (10 // 2) + 1), + ], + [ + slice(None), + slice(None, (10 // 2)), + slice(-(10 // 2), None), + slice(None, (10 // 2) + 1), + ], + [ + slice(None), + slice(-(10 // 2), None), + slice(-(10 // 2), None), + slice(None, (10 // 2) + 1), + ], + ] + assert ex.spectral.get_modes_slices(3, 11) == [ + [ + slice(None), + slice(None, (11 // 2) + 1), + slice(None, (11 // 2) + 1), + slice(None, (11 // 2) + 1), + ], + [ + slice(None), + slice(-(11 // 2), None), + slice(None, (11 // 2) + 1), + slice(None, (11 // 2) + 1), + ], + [ + slice(None), + slice(None, (11 // 2) + 1), + slice(-(11 // 2), None), + slice(None, (11 // 2) + 1), + ], + [ + slice(None), + slice(-(11 // 2), None), + slice(-(11 // 2), None), + slice(None, (11 // 2) + 1), + ], + ] From 999b571a1d9a22921d09483b659c22c80ce90883 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 10:42:37 +0200 Subject: [PATCH 13/21] Return tuples --- exponax/_spectral.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/exponax/_spectral.py b/exponax/_spectral.py index 14b533a..042362e 100644 --- a/exponax/_spectral.py +++ b/exponax/_spectral.py @@ -422,7 +422,9 @@ def build_reconstructional_scaling_array( return scaling -def get_modes_slices(num_spatial_dims: int, num_points: int) -> list[list[slice]]: +def get_modes_slices( + num_spatial_dims: int, num_points: int +) -> tuple[tuple[slice, ...], ...]: """ Produces a list of list of slices corresponding to all positive and negative wavenumber blocks found in the representation of a state in Fourier space. @@ -448,6 +450,7 @@ def get_modes_slices(num_spatial_dims: int, num_points: int) -> list[list[slice] + list(reversed(p)) for p in product(*slices_) ] + all_modes_slices = tuple([tuple(block_slices) for block_slices in all_modes_slices]) return all_modes_slices From a594ec9cd13f448fec5802444367e30442503c92 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 10:49:08 +0200 Subject: [PATCH 14/21] Utility to move between resolutions --- exponax/__init__.py | 3 +- exponax/_interpolation.py | 62 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+), 1 deletion(-) diff --git a/exponax/__init__.py b/exponax/__init__.py index bb65e9b..cf56e7d 100644 --- a/exponax/__init__.py +++ b/exponax/__init__.py @@ -4,7 +4,7 @@ from . import etdrk, ic, nonlin_fun, stepper, viz from ._base_stepper import BaseStepper from ._forced_stepper import ForcedStepper -from ._interpolation import FourierInterpolator +from ._interpolation import FourierInterpolator, map_between_resolutions from ._repeated_stepper import RepeatedStepper from ._spectral import derivative, fft, ifft, make_incompressible from ._utils import ( @@ -41,4 +41,5 @@ "viz", "spectral", "FourierInterpolator", + "map_between_resolutions", ] diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index a3b6c00..6182d74 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -11,8 +11,13 @@ from ._spectral import ( build_reconstructional_scaling_array, build_scaled_wavenumbers, + build_scaling_array, fft, + get_modes_slices, + ifft, + nyquist_filter_mask, space_indices, + wavenumber_shape, ) C = TypeVar("C") # Channel axis @@ -182,3 +187,60 @@ def __call__( ) return interpolated_value + + +def map_between_resolutions( + state: Float[Array, "C ... N"], + new_num_points: int, + *, + oddball_zero: bool = True, +): + """ """ + num_spatial_dims = state.ndim - 1 + old_num_points = state.shape[-1] + num_channels = state.shape[0] + + if old_num_points == new_num_points: + return state + if new_num_points > old_num_points: + # Upscaling + if old_num_points % 2 == 0 and oddball_zero: + state *= nyquist_filter_mask(num_spatial_dims, old_num_points) + + old_state_hat_scaled = fft( + state, num_spatial_dims=num_spatial_dims + ) / build_scaling_array( + num_spatial_dims, + old_num_points, + ) + new_state_hat_scaled = jnp.zeros( + (num_channels,) + wavenumber_shape(num_spatial_dims, new_num_points), + dtype=old_state_hat_scaled.dtype, + ) + + modes_slices: list[list[slice]] = get_modes_slices( + num_spatial_dims, + min(old_num_points, new_num_points), + ) + + for block_slice in modes_slices: + new_state_hat_scaled = new_state_hat_scaled.at[block_slice].set( + old_state_hat_scaled[block_slice] + ) + + new_state_hat = new_state_hat_scaled * build_scaling_array( + num_spatial_dims, + new_num_points, + ) + if old_num_points > new_num_points: + # Downscaling + if new_num_points % 2 == 0 and oddball_zero: + new_state_hat *= nyquist_filter_mask(num_spatial_dims, new_num_points) + + new_state = ifft( + new_state_hat, + num_spatial_dims=num_spatial_dims, + num_points=new_num_points, + ) + + return new_state From baa0511947a1d8de465425d818e06dfc66024aa9 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 11:07:39 +0200 Subject: [PATCH 15/21] Add tests for mapping between resolutions --- tests/test_interpolation.py | 138 ++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index 996da20..548a4f1 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -163,3 +163,141 @@ def test_fourier_interpolator_3d( # Looser rel and abs tol because JAX runs in single precision by default assert interpolated_u == pytest.approx(correct_val, rel=1e-5, abs=1e-5) + + +@pytest.mark.parametrize( + "fn_name, domain_extent, num_points_old, num_points_new,", + [ + ("constant", 1.0, 20, 30), + ("constant", 1.0, 20, 15), + ("simple_sine", 1.0, 20, 30), + ("simple_sine", 1.0, 20, 15), + ("simple_cosine", 1.0, 20, 30), + ("simple_cosine", 1.0, 20, 15), + ("complicated_fn", 10.0, 100, 200), + ("complicated_fn", 10.0, 100, 51), + ], +) +def test_map_between_resolutions_1d( + fn_name: str, + domain_extent: float, + num_points_old: int, + num_points_new: int, +): + fn = FN_DICT_1D[fn_name] + grid_old = ex.make_grid(1, domain_extent, num_points_old) + grid_new = ex.make_grid(1, domain_extent, num_points_new) + + u_old = fn(grid_old) + + u_new = ex.map_between_resolutions(u_old, num_points_new) + + u_new_correct = fn(grid_new) + + # Looser rel tol because JAX runs in single precision by default, and the + # FFT incorse some rounding errors + assert u_new == pytest.approx(u_new_correct, rel=10.0, abs=1e-6) + + +@pytest.mark.parametrize( + "fn_name, domain_extent, num_points_old, num_points_new,", + [ + ("constant", 1.0, 20, 30), + ("constant", 1.0, 20, 15), + ("simple_sine_x", 1.0, 20, 30), + ("simple_sine_x", 1.0, 20, 15), + ("simple_cosine_x", 1.0, 20, 30), + ("simple_cosine_x", 1.0, 20, 15), + ("simple_sine_y", 1.0, 20, 30), + ("simple_sine_y", 1.0, 20, 15), + ("simple_cosine_y", 1.0, 20, 30), + ("simple_cosine_y", 1.0, 20, 15), + ("mixed_sine", 1.0, 20, 30), + ("mixed_sine", 1.0, 20, 15), + ("mixed_cosine", 1.0, 20, 30), + ("mixed_cosine", 1.0, 20, 15), + ("complicated_fn_x", 10.0, 100, 200), + ("complicated_fn_x", 10.0, 100, 51), + ("complicated_fn_y", 10.0, 100, 200), + ("complicated_fn_y", 10.0, 100, 51), + ("complicated_fn_xy", 10.0, 100, 200), + ("complicated_fn_xy", 10.0, 100, 51), + ], +) +def test_map_between_resolutions_2d( + fn_name: str, + domain_extent: float, + num_points_old: int, + num_points_new: int, +): + fn = FN_DICT_2D[fn_name] + grid_old = ex.make_grid(2, domain_extent, num_points_old) + grid_new = ex.make_grid(2, domain_extent, num_points_new) + + u_old = fn(grid_old) + + u_new = ex.map_between_resolutions(u_old, num_points_new) + + u_new_correct = fn(grid_new) + + # Looser rel tol because JAX runs in single precision by default, and the + # FFT incorse some rounding errors + assert u_new == pytest.approx(u_new_correct, rel=10.0, abs=1e-6) + + +@pytest.mark.parametrize( + "fn_name, domain_extent, num_points_old, num_points_new,", + [ + ("constant", 1.0, 20, 30), + ("constant", 1.0, 20, 15), + ("simple_sine_x", 1.0, 20, 30), + ("simple_sine_x", 1.0, 20, 15), + ("simple_cosine_x", 1.0, 20, 30), + ("simple_cosine_x", 1.0, 20, 15), + ("simple_sine_y", 1.0, 20, 30), + ("simple_sine_y", 1.0, 20, 15), + ("simple_cosine_y", 1.0, 20, 30), + ("simple_cosine_y", 1.0, 20, 15), + ("simple_sine_z", 1.0, 20, 30), + ("simple_sine_z", 1.0, 20, 15), + ("simple_cosine_z", 1.0, 20, 30), + ("simple_cosine_z", 1.0, 20, 15), + ("mixed_sine", 1.0, 20, 30), + ("mixed_sine", 1.0, 20, 15), + ("mixed_cosine", 1.0, 20, 30), + ("mixed_cosine", 1.0, 20, 15), + ("complicated_fn_x", 10.0, 40, 50), + ("complicated_fn_x", 10.0, 40, 33), + ("complicated_fn_y", 10.0, 40, 50), + ("complicated_fn_y", 10.0, 40, 33), + ("complicated_fn_z", 10.0, 40, 50), + ("complicated_fn_z", 10.0, 40, 33), + ("complicated_fn_xy", 10.0, 40, 50), + ("complicated_fn_xy", 10.0, 40, 33), + ("complicated_fn_xz", 10.0, 40, 50), + ("complicated_fn_xz", 10.0, 40, 33), + ("complicated_fn_yz", 10.0, 40, 50), + ("complicated_fn_yz", 10.0, 40, 33), + ("complicated_fn_xyz", 10.0, 40, 50), + ("complicated_fn_xyz", 10.0, 40, 33), + ], +) +def test_map_between_resolutions_3d( + fn_name: str, + domain_extent: float, + num_points_old: int, + num_points_new: int, +): + fn = FN_DICT_3D[fn_name] + grid_old = ex.make_grid(3, domain_extent, num_points_old) + grid_new = ex.make_grid(3, domain_extent, num_points_new) + + u_old = fn(grid_old) + + u_new = ex.map_between_resolutions(u_old, num_points_new) + + u_new_correct = fn(grid_new) + + # Looser rel tol because JAX runs in single precision by default, and the + # FFT incorse some rounding errors + assert u_new == pytest.approx(u_new_correct, rel=10.0, abs=3e-4) From 8e1a21eb7fe8a3e9332fd41f8abe7147b4bda3eb Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 11:08:30 +0200 Subject: [PATCH 16/21] Fix issue with oddball sanity --- exponax/_interpolation.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index 6182d74..1c220b2 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -202,10 +202,6 @@ def map_between_resolutions( if old_num_points == new_num_points: return state - if new_num_points > old_num_points: - # Upscaling - if old_num_points % 2 == 0 and oddball_zero: - state *= nyquist_filter_mask(num_spatial_dims, old_num_points) old_state_hat_scaled = fft( state, num_spatial_dims=num_spatial_dims @@ -213,6 +209,14 @@ def map_between_resolutions( num_spatial_dims, old_num_points, ) + + if new_num_points > old_num_points: + # Upscaling + if old_num_points % 2 == 0 and oddball_zero: + old_state_hat_scaled *= nyquist_filter_mask( + num_spatial_dims, old_num_points + ) + new_state_hat_scaled = jnp.zeros( (num_channels,) + wavenumber_shape(num_spatial_dims, new_num_points), dtype=old_state_hat_scaled.dtype, From 860ced384030fc05d1602be9288a42a1b83bc56e Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 11:12:53 +0200 Subject: [PATCH 17/21] Add new utilities to documentation --- docs/api/utilities/interpolation.md | 13 +++++++++++++ mkdocs.yml | 1 + 2 files changed, 14 insertions(+) create mode 100644 docs/api/utilities/interpolation.md diff --git a/docs/api/utilities/interpolation.md b/docs/api/utilities/interpolation.md new file mode 100644 index 0000000..99bd14f --- /dev/null +++ b/docs/api/utilities/interpolation.md @@ -0,0 +1,13 @@ +# Interpolation + +... or utilities to move between different grid representations. + +::: exponax.map_between_resolutions + +--- + +::: exponax.FourierInterpolator + options: + members: + - __init__ + - __call__ \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml index d8be3c4..e7c4c0c 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -162,6 +162,7 @@ nav: - Grid Generation: 'api/utilities/grid_generation.md' - Derivatives: 'api/utilities/derivatives.md' - Spectral: 'api/utilities/spectral.md' + - Interpolation: 'api/utilities/interpolation.md' - Normalized & Difficulty: 'api/utilities/normalized_and_difficulty.md' - Metrics: - MSE-based: 'api/utilities/metrics/mse_based.md' From ac5030c089c2d3cd0b6197dc6f1701ef08f646bb Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 11:18:21 +0200 Subject: [PATCH 18/21] Add documentation --- exponax/_interpolation.py | 36 +++++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index 1c220b2..de6b3ce 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -195,7 +195,41 @@ def map_between_resolutions( *, oddball_zero: bool = True, ): - """ """ + """ + Upsamples or downsamples a state in `Exponax` convention to a new resolution + via manipulation of its Fourier representation. + + This approach is way more efficient that `exponax.FourierInterpolator` but + can only move the state between uniform Cartesian grids of different + resolutions. + + !!! info + If the new resolution is higher than the old resolution, the state is + upsampled. If the new resolution is lower than the old resolution, the + state is downsampled. If the given state is bandlimited, i.e., the + highest wavenumber containing non-zero energy is at max `(N//2)`, then + upsampling will be exact (no interpolation error). Also, in case of + downsampling: if the given state was bandlimited, and the it would be + still be bandlimited in the new resolution, this downsampling will also + be exact, i.e., no coarsening artifacts. If this is not the case, one + loses high-frequency (fine scale) information. + + **Arguments:** + + - `state`: The state to interpolate. Must conform to the `Exponax` + standard with a leading channel axis (can be a singleton axis if there + is only one channel), and one, two, or three subsequent spatial axes + (depending on the number of spatial dimensions). These latter spatial + axes must have the same number of dimensions. + - `new_num_points`: The new number of points in each spatial dimension. + - `oddball_zero`: Whether to zero out the Nyquist frequency in case of + even-sized grids. This is usually preferred. + + **Returns:** + + - `new_state`: The state interpolated to the new resolution. This will have + the same number of channels as the input state. + """ num_spatial_dims = state.ndim - 1 old_num_points = state.shape[-1] num_channels = state.shape[0] From ee22a9a91638572b998d757cb43d709b9af1abf7 Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 11:18:42 +0200 Subject: [PATCH 19/21] Add return type hint --- exponax/_interpolation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/exponax/_interpolation.py b/exponax/_interpolation.py index de6b3ce..412a46a 100644 --- a/exponax/_interpolation.py +++ b/exponax/_interpolation.py @@ -194,7 +194,7 @@ def map_between_resolutions( new_num_points: int, *, oddball_zero: bool = True, -): +) -> Float[Array, "C ... N_new"]: """ Upsamples or downsamples a state in `Exponax` convention to a new resolution via manipulation of its Fourier representation. From d5a702bab017782663a9304bfbafe57b45a4d00d Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 12:42:33 +0200 Subject: [PATCH 20/21] Simple showcase of new functions --- docs/examples/additional_features.ipynb | 269 +++++++++++++++++++++++- 1 file changed, 260 insertions(+), 9 deletions(-) diff --git a/docs/examples/additional_features.ipynb b/docs/examples/additional_features.ipynb index 6a055b0..3b38f63 100644 --- a/docs/examples/additional_features.ipynb +++ b/docs/examples/additional_features.ipynb @@ -45,7 +45,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-03-01 14:59:05.217187: W external/xla/xla/service/gpu/nvptx_compiler.cc:679] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.3.52). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + "2024-09-04 12:27:18.806334: W external/xla/xla/service/gpu/nvptx_compiler.cc:836] The NVIDIA driver's CUDA version is 12.2 which is older than the PTX compiler version (12.6.68). Because the driver is older than the PTX compiler version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" ] }, { @@ -57,7 +57,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -114,7 +114,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -123,7 +123,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -149,7 +149,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Adding a forcing term\n", + "## Adding a forcing term\n", "\n", "So far the steppers only consider \"transient PDEs\" that are not externally\n", "forded. `Exponax` has a quick hack to turn a stepper of the signature $\n", @@ -177,7 +177,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -222,7 +222,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Spectral derivatives\n", + "## Spectral derivatives\n", "\n", "Any field discretized can be derived spectrally." ] @@ -235,7 +235,7 @@ { "data": { "text/plain": [ - "Array(4.742706e-05, dtype=float32)" + "Array(4.3673816e-05, dtype=float32)" ] }, "execution_count": 6, @@ -259,6 +259,257 @@ "jnp.sqrt(jnp.mean(jnp.square(u_prime_exact - u_prime_spectrally)))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Moving between resolutions (Upsampling and Downsampling)\n", + "\n", + "Using its Fourier representation, `Exponax` can upsample (increase the\n", + "resolution) or downsample (decrease the resolution) of a state. With the\n", + "following nice benefits:\n", + "\n", + "* For upsampling: If the state on the initial (lower) resolution is bandlimited\n", + " the interpolation is exact.\n", + "* For downsampling: If the state on the initial (higher) resolution and on the new\n", + " (lower) resolution is bandlimited the decimation is exact." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "DOMAIN_EXTENT = 2 * jnp.pi\n", + "NUM_POINTS_LOW = 10\n", + "NUM_POINTS_HIGH = 100\n", + "grid_1d = ex.make_grid(1, DOMAIN_EXTENT, NUM_POINTS_LOW)\n", + "\n", + "u = jnp.sin(grid_1d)\n", + "\n", + "ex.viz.plot_state_1d(u, domain_extent=DOMAIN_EXTENT)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "u_upsampled = ex.map_between_resolutions(u, NUM_POINTS_HIGH)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ex.viz.plot_state_1d(u_upsampled, domain_extent=DOMAIN_EXTENT)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A usefull application for this is to compress states or entire trajectories if\n", + "they are highly bandlimited." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_1d_high = ex.make_grid(1, DOMAIN_EXTENT, NUM_POINTS_HIGH)\n", + "\n", + "u_complicated_high = jnp.exp(-((grid_1d_high - jnp.pi) ** 2))\n", + "\n", + "ex.viz.plot_state_1d(u_complicated_high, domain_extent=DOMAIN_EXTENT)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u_complicated_low = ex.map_between_resolutions(u_complicated_high, NUM_POINTS_LOW)\n", + "\n", + "ex.viz.plot_state_1d(u_complicated_low, domain_extent=DOMAIN_EXTENT)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Interpolation\n", + "\n", + "`Exponax` can use the Fourier representation to interpolate a state at any point\n", + "in space which can also be different from the original grid. For example, this\n", + "allows to represent a state on an unstructured grid.\n", + "\n", + "If the state is bandlimited, the interpolation is exact (but costly; check the\n", + "documentation of `exponax.FourierInterpolator` for more details)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "u = ex.ic.RandomTruncatedFourierSeries(2, cutoff=5, max_one=True)(\n", + " 50, key=jax.random.PRNGKey(0)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ex.viz.plot_state_2d(u)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "interpolator = ex.FourierInterpolator(u)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "unstructured_coordinates = jax.random.uniform(\n", + " jax.random.PRNGKey(0), (300, 2), minval=0.3, maxval=0.8\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "values = jax.vmap(interpolator)(unstructured_coordinates)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.tri as tri\n", + "\n", + "triang = tri.Triangulation(\n", + " unstructured_coordinates[:, 0], unstructured_coordinates[:, 1]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 1.0)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.tricontourf(triang, values[:, 0], cmap=\"RdBu_r\")\n", + "plt.scatter(unstructured_coordinates[:, 0], unstructured_coordinates[:, 1], c=\"black\")\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 1)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -283,7 +534,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.14" } }, "nbformat": 4, From 323cf581b1318df7aef4321c9d52d5d896a1cb1a Mon Sep 17 00:00:00 2001 From: Felix Koehler Date: Wed, 4 Sep 2024 12:43:08 +0200 Subject: [PATCH 21/21] Properly rerun notebook --- docs/examples/additional_features.ipynb | 26 ++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/docs/examples/additional_features.ipynb b/docs/examples/additional_features.ipynb index 3b38f63..71fb65e 100644 --- a/docs/examples/additional_features.ipynb +++ b/docs/examples/additional_features.ipynb @@ -45,7 +45,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-09-04 12:27:18.806334: W external/xla/xla/service/gpu/nvptx_compiler.cc:836] The NVIDIA driver's CUDA version is 12.2 which is older than the PTX compiler version (12.6.68). Because the driver is older than the PTX compiler version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" + "2024-09-04 12:42:44.276565: W external/xla/xla/service/gpu/nvptx_compiler.cc:836] The NVIDIA driver's CUDA version is 12.2 which is older than the PTX compiler version (12.6.68). Because the driver is older than the PTX compiler version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n" ] }, { @@ -114,7 +114,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -368,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -378,7 +378,7 @@ "
" ] }, - "execution_count": 13, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -405,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -416,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -426,7 +426,7 @@ "
" ] }, - "execution_count": 17, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -437,7 +437,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -446,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -457,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -466,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -479,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -488,7 +488,7 @@ "(0.0, 1.0)" ] }, - "execution_count": 44, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" },