Skip to content

Spectral Filters

SpectralFilter1D

Bases: Module

1D Spectral filter for smoothing and numerical stabilization.

Mathematical Formulation:

Filters are applied as a multiplicative mask in Fourier space: u_hat_filtered(k) = F(k) * u_hat(k)

where F(k) is the filter kernel.

grid : FourierGrid1D
    The 1D Fourier grid object containing wavenumbers k [N].
Source code in spectraldiffx/_src/fourier/filters.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
class SpectralFilter1D(eqx.Module):
    """
    1D Spectral filter for smoothing and numerical stabilization.

    Mathematical Formulation:
    -------------------------
    Filters are applied as a multiplicative mask in Fourier space:
        u_hat_filtered(k) = F(k) * u_hat(k)

    where F(k) is the filter kernel.

    Attributes:
    -----------
        grid : FourierGrid1D
            The 1D Fourier grid object containing wavenumbers k [N].
    """

    grid: FourierGrid1D

    def exponential_filter(
        self, u: Array, alpha: float = 36.0, power: int = 16, spectral: bool = False
    ) -> Array:
        """
        Apply 1D exponential filter: F(k) = exp(-alpha * (abs(k) / k_max)^power)

        This filter is near unity for low wavenumbers and falls off sharply
        near the grid scale (k_max), removing poorly resolved high frequencies.

        Parameters:
        -----------
        u : Array [N]
            Physical space field or spectral coefficients of the field.
        alpha : float, optional
            Damping coefficient. Default is 36.0.
        power : int, optional
            Sharpening order (even integer). Default is 16.
        spectral : bool, optional
            If True, u is treated as spectral coefficients (u_hat). Default is False.

        Returns:
        --------
        Array [N]
            Filtered field or spectral coefficients.
        """
        u_hat = u if spectral else self.grid.transform(u)
        k = self.grid.k
        k_max = jnp.abs(k).max()
        k_max_safe = jnp.where(k_max == 0, 1.0, k_max)

        filter_mask = jnp.exp(-alpha * (jnp.abs(k) / k_max_safe) ** power)
        u_hat_f = u_hat * filter_mask
        return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

    def hyperviscosity(
        self,
        u: Array,
        nu_hyper: float,
        dt: float,
        power: int = 4,
        spectral: bool = False,
    ) -> Array:
        """
        Apply 1D hyperviscous damping: F(k) = exp(-nu_h * abs(k)^power * dt)

        Simulates the effect of high-order diffusion: du/dt = -nu_h * (-1)^(p/2) * d^p u / dx^p.

        Parameters:
        -----------
        u : Array [N]
            Physical space field or spectral coefficients of the field.
        nu_hyper : float
            Hyperviscosity coefficient.
        dt : float
            Effective time step for the damping.
        power : int, optional
            Order of the Laplacian power (e.g., 4 for biharmonic). Default is 4.
        spectral : bool, optional
            If True, u is treated as spectral coefficients (u_hat). Default is False.
        """
        u_hat = u if spectral else self.grid.transform(u)
        k = self.grid.k
        filter_mask = jnp.exp(-nu_hyper * jnp.abs(k) ** power * dt)
        u_hat_f = u_hat * filter_mask
        return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

Functions

exponential_filter(u, alpha=36.0, power=16, spectral=False)

Apply 1D exponential filter: F(k) = exp(-alpha * (abs(k) / k_max)^power)

This filter is near unity for low wavenumbers and falls off sharply near the grid scale (k_max), removing poorly resolved high frequencies.

Parameters:

u : Array [N] Physical space field or spectral coefficients of the field. alpha : float, optional Damping coefficient. Default is 36.0. power : int, optional Sharpening order (even integer). Default is 16. spectral : bool, optional If True, u is treated as spectral coefficients (u_hat). Default is False.

Returns:

Array [N] Filtered field or spectral coefficients.

Source code in spectraldiffx/_src/fourier/filters.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
def exponential_filter(
    self, u: Array, alpha: float = 36.0, power: int = 16, spectral: bool = False
) -> Array:
    """
    Apply 1D exponential filter: F(k) = exp(-alpha * (abs(k) / k_max)^power)

    This filter is near unity for low wavenumbers and falls off sharply
    near the grid scale (k_max), removing poorly resolved high frequencies.

    Parameters:
    -----------
    u : Array [N]
        Physical space field or spectral coefficients of the field.
    alpha : float, optional
        Damping coefficient. Default is 36.0.
    power : int, optional
        Sharpening order (even integer). Default is 16.
    spectral : bool, optional
        If True, u is treated as spectral coefficients (u_hat). Default is False.

    Returns:
    --------
    Array [N]
        Filtered field or spectral coefficients.
    """
    u_hat = u if spectral else self.grid.transform(u)
    k = self.grid.k
    k_max = jnp.abs(k).max()
    k_max_safe = jnp.where(k_max == 0, 1.0, k_max)

    filter_mask = jnp.exp(-alpha * (jnp.abs(k) / k_max_safe) ** power)
    u_hat_f = u_hat * filter_mask
    return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

hyperviscosity(u, nu_hyper, dt, power=4, spectral=False)

Apply 1D hyperviscous damping: F(k) = exp(-nu_h * abs(k)^power * dt)

Simulates the effect of high-order diffusion: du/dt = -nu_h * (-1)^(p/2) * d^p u / dx^p.

Parameters:

u : Array [N] Physical space field or spectral coefficients of the field. nu_hyper : float Hyperviscosity coefficient. dt : float Effective time step for the damping. power : int, optional Order of the Laplacian power (e.g., 4 for biharmonic). Default is 4. spectral : bool, optional If True, u is treated as spectral coefficients (u_hat). Default is False.

Source code in spectraldiffx/_src/fourier/filters.py 
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
def hyperviscosity(
    self,
    u: Array,
    nu_hyper: float,
    dt: float,
    power: int = 4,
    spectral: bool = False,
) -> Array:
    """
    Apply 1D hyperviscous damping: F(k) = exp(-nu_h * abs(k)^power * dt)

    Simulates the effect of high-order diffusion: du/dt = -nu_h * (-1)^(p/2) * d^p u / dx^p.

    Parameters:
    -----------
    u : Array [N]
        Physical space field or spectral coefficients of the field.
    nu_hyper : float
        Hyperviscosity coefficient.
    dt : float
        Effective time step for the damping.
    power : int, optional
        Order of the Laplacian power (e.g., 4 for biharmonic). Default is 4.
    spectral : bool, optional
        If True, u is treated as spectral coefficients (u_hat). Default is False.
    """
    u_hat = u if spectral else self.grid.transform(u)
    k = self.grid.k
    filter_mask = jnp.exp(-nu_hyper * jnp.abs(k) ** power * dt)
    u_hat_f = u_hat * filter_mask
    return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

SpectralFilter2D

Bases: Module

2D Spectral filter for doubly periodic domains.

grid : FourierGrid2D
    The 2D Fourier grid object [Ny, Nx].
Source code in spectraldiffx/_src/fourier/filters.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
class SpectralFilter2D(eqx.Module):
    """
    2D Spectral filter for doubly periodic domains.

    Attributes:
    -----------
        grid : FourierGrid2D
            The 2D Fourier grid object [Ny, Nx].
    """

    grid: FourierGrid2D

    def exponential_filter(
        self, u: Array, alpha: float = 36.0, power: int = 16, spectral: bool = False
    ) -> Array:
        """Apply 2D exponential filter based on isotropic wavenumber magnitude."""
        u_hat = u if spectral else self.grid.transform(u)
        K2 = self.grid.K2
        k_mag = jnp.sqrt(K2)
        k_max = k_mag.max()
        k_max_safe = jnp.where(k_max == 0, 1.0, k_max)

        filter_mask = jnp.exp(-alpha * (k_mag / k_max_safe) ** power)
        u_hat_f = u_hat * filter_mask
        return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

    def hyperviscosity(
        self,
        u: Array,
        nu_hyper: float,
        dt: float,
        power: int = 4,
        spectral: bool = False,
    ) -> Array:
        """Apply 2D hyperviscosity: F(k) = exp(-nu_h * |k|^power * dt)"""
        u_hat = u if spectral else self.grid.transform(u)
        K2 = self.grid.K2
        filter_mask = jnp.exp(-nu_hyper * K2 ** (power / 2) * dt)
        u_hat_f = u_hat * filter_mask
        return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

Functions

exponential_filter(u, alpha=36.0, power=16, spectral=False)

Apply 2D exponential filter based on isotropic wavenumber magnitude.

Source code in spectraldiffx/_src/fourier/filters.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
def exponential_filter(
    self, u: Array, alpha: float = 36.0, power: int = 16, spectral: bool = False
) -> Array:
    """Apply 2D exponential filter based on isotropic wavenumber magnitude."""
    u_hat = u if spectral else self.grid.transform(u)
    K2 = self.grid.K2
    k_mag = jnp.sqrt(K2)
    k_max = k_mag.max()
    k_max_safe = jnp.where(k_max == 0, 1.0, k_max)

    filter_mask = jnp.exp(-alpha * (k_mag / k_max_safe) ** power)
    u_hat_f = u_hat * filter_mask
    return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

hyperviscosity(u, nu_hyper, dt, power=4, spectral=False)

Apply 2D hyperviscosity: F(k) = exp(-nu_h * |k|^power * dt)

Source code in spectraldiffx/_src/fourier/filters.py 
125
126
127
128
129
130
131
132
133
134
135
136
137
138
def hyperviscosity(
    self,
    u: Array,
    nu_hyper: float,
    dt: float,
    power: int = 4,
    spectral: bool = False,
) -> Array:
    """Apply 2D hyperviscosity: F(k) = exp(-nu_h * |k|^power * dt)"""
    u_hat = u if spectral else self.grid.transform(u)
    K2 = self.grid.K2
    filter_mask = jnp.exp(-nu_hyper * K2 ** (power / 2) * dt)
    u_hat_f = u_hat * filter_mask
    return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

SpectralFilter3D

Bases: Module

3D Spectral filter for triply periodic domains.

grid : FourierGrid3D
    The 3D Fourier grid object [Nz, Ny, Nx].
Source code in spectraldiffx/_src/fourier/filters.py 
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
class SpectralFilter3D(eqx.Module):
    """
    3D Spectral filter for triply periodic domains.

    Attributes:
    -----------
        grid : FourierGrid3D
            The 3D Fourier grid object [Nz, Ny, Nx].
    """

    grid: FourierGrid3D

    def exponential_filter(
        self, u: Array, alpha: float = 36.0, power: int = 16, spectral: bool = False
    ) -> Array:
        """Apply isotropic 3D exponential filter."""
        u_hat = u if spectral else self.grid.transform(u)
        K2 = self.grid.K2
        k_mag = jnp.sqrt(K2)
        k_max = k_mag.max()
        k_max_safe = jnp.where(k_max == 0, 1.0, k_max)

        filter_mask = jnp.exp(-alpha * (k_mag / k_max_safe) ** power)
        u_hat_f = u_hat * filter_mask
        return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

    def hyperviscosity(
        self,
        u: Array,
        nu_hyper: float,
        dt: float,
        power: int = 4,
        spectral: bool = False,
    ) -> Array:
        """Apply 3D hyperviscosity: exp(-nu_h * |k|^power * dt)"""
        u_hat = u if spectral else self.grid.transform(u)
        K2 = self.grid.K2
        filter_mask = jnp.exp(-nu_hyper * K2 ** (power / 2) * dt)
        u_hat_f = u_hat * filter_mask
        return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

Functions

exponential_filter(u, alpha=36.0, power=16, spectral=False)

Apply isotropic 3D exponential filter.

Source code in spectraldiffx/_src/fourier/filters.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def exponential_filter(
    self, u: Array, alpha: float = 36.0, power: int = 16, spectral: bool = False
) -> Array:
    """Apply isotropic 3D exponential filter."""
    u_hat = u if spectral else self.grid.transform(u)
    K2 = self.grid.K2
    k_mag = jnp.sqrt(K2)
    k_max = k_mag.max()
    k_max_safe = jnp.where(k_max == 0, 1.0, k_max)

    filter_mask = jnp.exp(-alpha * (k_mag / k_max_safe) ** power)
    u_hat_f = u_hat * filter_mask
    return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real

hyperviscosity(u, nu_hyper, dt, power=4, spectral=False)

Apply 3D hyperviscosity: exp(-nu_h * |k|^power * dt)

Source code in spectraldiffx/_src/fourier/filters.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
180
def hyperviscosity(
    self,
    u: Array,
    nu_hyper: float,
    dt: float,
    power: int = 4,
    spectral: bool = False,
) -> Array:
    """Apply 3D hyperviscosity: exp(-nu_h * |k|^power * dt)"""
    u_hat = u if spectral else self.grid.transform(u)
    K2 = self.grid.K2
    filter_mask = jnp.exp(-nu_hyper * K2 ** (power / 2) * dt)
    u_hat_f = u_hat * filter_mask
    return u_hat_f if spectral else self.grid.transform(u_hat_f, inverse=True).real