# Spectral Methods for SPDEs with codes
Spectral methods are a class of techniques used to numerically solve differential equations. They are based on expanding the solution of a differential equation in terms of a series of basis functions, often trigonometric functions (Fourier series) or orthogonal polynomials (Chebyshev, Legendre, etc.).

- [Stochastic partial differential equations in surface growth models](https://viadean.notion.site/Stochastic-partial-differential-equations-in-surface-growth-models-13b1ae7b9a328085a848da3e02e8f498)

---
config:
 sankey:
  showValues: false
---
sankey-beta
Code snippets,MATLAB,7
MATLAB,KPZ Model,1
MATLAB,EW Model,1
MATLAB,MH Model,1
MATLAB,noise in SPDEs,1
MATLAB,Finite Difference methods for SPDEs,1
MATLAB,Monte Carlo Simulations,1
MATLAB,Spectral Methods,1

Code snippets,Python,6
Python,KPZ Model,1
Python,EW Model,1
Python,MH Model,1
Python,noise in SPDEs,1
Python,Finite Difference methods for SPDEs,1
Python,Monte Carlo Simulations,1
Python,Spectral Methods,1


Code snippets,Julia,5
Julia,EW Model,1
Julia,MH Model,1
Julia,noise in SPDEs,1
Julia,Finite Difference methods for SPDEs,1
Julia,Monte Carlo Simulations,1

Code snippets,R,1
R,KPZ Model,1

Code snippets,C++,1
C++,KPZ Model,1

### :cactus:Python snippet

Spectral methods are a powerful approach for solving **Stochastic Partial Differential Equations (SPDEs)**, leveraging the efficiency of spectral decomposition to solve differential equations with high accuracy. Python provides robust tools and libraries to implement spectral methods for SPDEs.

### Overview of Spectral Methods

- **Spectral Decomposition**: Expands the solution of the SPDE in terms of basis functions (e.g., Fourier, Chebyshev, or Legendre polynomials).
- **Stochastic Galerkin Projection**: Projects the SPDE onto a reduced space using basis functions, reducing it to a system of ordinary differential equations (ODEs) or deterministic PDEs.
- **Efficiency**: Spectral methods achieve exponential convergence rates for smooth problems.

### Libraries for Spectral Methods in Python

1. **NumPy**: Provides efficient array operations and Fourier transforms.
2. **SciPy**: Includes solvers for deterministic PDEs, useful in conjunction with spectral methods.
3. **SymPy**: Useful for symbolic computation, including the generation of basis functions.
4. **Dedalus**: A Python framework specifically designed for solving PDEs and SPDEs using spectral methods.

---

### Example Workflow: Solving an SPDE using Spectral Methods

#### Problem Setup

We consider a 1D stochastic heat equation:
$$
\frac{\partial u(x, t, \omega)}{\partial t} = \nu \frac{\partial^2 u(x, t, \omega)}{\partial x^2} + f(x, \omega),
$$
where \( $\omega$ \) represents the stochastic component (random variable), and \( $f(x, \omega)$ \) is a random forcing term.

#### Steps

1. **Discretize the Spatial Domain**:
Use a spectral basis, such as Fourier or Chebyshev polynomials, to approximate \( $u(x, t, \omega)$ \).

2. **Expand Stochastic Term**:
Represent the stochastic term \( $f(x, \omega)$ \) using a series expansion, such as Karhunen-Loève expansion.

3. **Galerkin Projection**:
Apply stochastic Galerkin projection to reduce the SPDE into a deterministic PDE system.

4. **Time Integration**:
Use ODE solvers for temporal evolution.

---

#### Python Implementation

import numpy as np
from scipy.fftpack import fft, ifft
from scipy.integrate import solve_ivp

# Problem Parameters
L = 1.0            # Length of domain
N = 64             # Number of spectral modes
nu = 0.1           # Diffusivity
t_max = 1.0        # Simulation time
dt = 0.01          # Time step

# Spatial Grid
x = np.linspace(0, L, N, endpoint=False)
k = 2 * np.pi * np.fft.fftfreq(N, d=L / N)  # Wavenumbers

# Initial Condition (example: random perturbation)
u0 = np.random.normal(0, 1, N)

# Random Forcing (stochastic term, e.g., white noise)
np.random.seed(42)
f = lambda: np.random.normal(0, 1, N)

# RHS of the SPDE in Fourier Space
def rhs(t, u_hat):
    u = np.real(ifft(u_hat))
    forcing = f()
    forcing_hat = fft(forcing)
    return -nu * (k**2) * u_hat + forcing_hat

# Time Integration
u_hat0 = fft(u0)
t_eval = np.arange(0, t_max, dt)
solution = solve_ivp(rhs, [0, t_max], u_hat0, t_eval=t_eval, method="RK45")

# Transform Back to Physical Space
u_t = np.real(ifft(solution.y.T, axis=1))

# Visualization
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

fig, ax = plt.subplots()
line, = ax.plot(x, u_t[0])

def update(frame):
    line.set_ydata(u_t[frame])
    return line,

ani = FuncAnimation(fig, update, frames=len(t_eval), interval=50)
plt.show()

---

### Key Concepts in the Code

1. **Fourier Transform**:
- The spatial domain is represented in Fourier space.
- `fft` and `ifft` are used to switch between physical and spectral spaces.

2. **Stochastic Forcing**:
- The function `f` generates random forcing terms at each time step.

3. **Spectral Derivatives**:
- Derivatives are efficiently computed in Fourier space using the wavenumber \( k \).

4. **Integration**:
- `solve_ivp` integrates the time evolution of the spectral coefficients.

---

### Extensions

1. **Higher Dimensions**:
- Extend the approach to 2D or 3D using multidimensional FFTs (`np.fft.fftn` and `np.fft.ifftn`).

2. **Other Basis Functions**:
- Replace Fourier with Chebyshev or Legendre polynomials for non-periodic domains.

3. **Karhunen-Loève Expansion**:
- Use KL expansion to represent complex stochastic processes.

4. **Frameworks**:
- Use **Dedalus** for more complex SPDEs with built-in spectral capabilities.

---

### References

1. **Dedalus Documentation**: [Dedalus Project](https://dedalus-project.readthedocs.io/)
2. **Numerical Recipes in Python**: Excellent resource for spectral methods.
3. **Scientific Papers**: Explore SPDE-related publications for more advanced models.

### :cactus:MATLAB snippet

Spectral methods are powerful tools for solving **stochastic partial differential equations (SPDEs)** because they exploit the smoothness of solutions and allow for efficient computations. In MATLAB, implementing spectral methods for SPDEs typically involves:

1. **Spatial Discretization Using Spectral Methods**
- Expanding the solution in terms of orthogonal basis functions, such as Fourier or Chebyshev polynomials.
- Transforming the SPDE into a system of ordinary differential equations (ODEs) or algebraic equations for the coefficients of the expansion.

2. **Handling Stochastic Components**
- Incorporating randomness into the system via techniques like Karhunen-Loève expansions or Monte Carlo simulations.
- Using numerical schemes to solve the stochastic terms (e.g., Ito or Stratonovich integrals).

---

### General Steps to Solve SPDEs Using Spectral Methods

1. **Define the SPDE**

For example, consider the stochastic heat equation:
$$
\frac{\partial u(x,t)}{\partial t} = \kappa \frac{\partial^2 u(x,t)}{\partial x^2} + f(x,t) + g(x,t) \dot{W}(x,t),
$$
where:

- \( $\kappa$ \) is the diffusion coefficient,
- \( $f(x,t)$ \) is a deterministic source,
- \( $g(x,t) \dot{W}(x,t)$ \) represents stochastic forcing, with \( $\dot{W}(x,t)$ \) being space-time white noise.

2. **Discretize the Domain Using Spectral Basis**

- Choose an orthogonal basis (e.g., Fourier basis for periodic domains or Chebyshev polynomials for bounded domains).

- Expand \( u(x,t) \) as:
$$
u(x,t) \approx \sum_{n=0}^N c_n(t) \phi_n(x),
$$

where \( $\phi_n(x)$ \) are the basis functions, and \( $c_n(t)$ \) are the time-dependent coefficients.

3. **Project the SPDE onto the Basis**

- Substitute the expansion into the SPDE.
- Use orthogonality to derive equations for the coefficients \( c_n(t) \).

4. **Solve the Resulting System of Equations**

- For the deterministic terms, solve ODEs for \( $c_n(t)$ \) using MATLAB’s ODE solvers (e.g., `ode45` or `ode15s`).
- For stochastic terms, use stochastic solvers (e.g., Euler-Maruyama for SDEs).

5. **Post-Processing**

- Reconstruct the solution \( $u(x,t)$ \) using the computed coefficients \( $c_n(t)$ \).
- Visualize the results.

---

### MATLAB Implementation Outline

#### Example: Stochastic Heat Equation with Periodic Boundary Conditions

1. **Setup the Domain and Basis**

   L = 2 * pi;        % Domain length
   N = 64;            % Number of modes
   x = linspace(0, L, N+1); 
   x = x(1:end-1);    % Remove duplicate endpoint
   k = [0:N/2-1 -N/2:-1]'; % Wavenumbers for Fourier basis

2. **Initial Conditions**

   u0 = sin(x);   % Initial condition
   U = fft(u0);   % Fourier transform of the initial condition

3. **Define the SPDE Components**

   kappa = 0.1;          % Diffusion coefficient
   dt = 0.01;            % Time step
   T = 2;                % Total simulation time
   nSteps = T / dt;      % Number of time steps

4. **Time-Stepping with Stochastic Forcing**

   % Preallocate
   U_t = zeros(N, nSteps);
   U_t(:,1) = U;
   
   % Stochastic term
   rng(1);  % Fix random seed for reproducibility
   G = randn(N, nSteps); % Random forcing
   
   for n = 1:nSteps-1
       % Compute diffusion term
       LapU = -(k.^2) .* U_t(:,n);
       
       % Stochastic term (Fourier coefficients)
       noise = G(:,n);
       
       % Update using Euler-Maruyama
       U_t(:,n+1) = U_t(:,n) + dt * (kappa * LapU) + sqrt(dt) * noise;
   end
   
   % Transform back to spatial domain
   U_final = real(ifft(U_t(:,end)));

5. **Visualization**

   plot(x, U_final);
   title('Solution of Stochastic Heat Equation');
   xlabel('x');
   ylabel('u(x,T)');

---

### Advanced Considerations

1. **Higher-Order Methods**
- Use higher-order stochastic solvers like Milstein methods for improved accuracy.

2. **Handling Non-Periodic Domains**
- Use Chebyshev polynomials for bounded domains, requiring a discrete cosine transform (DCT) instead of FFT.

3. **Karhunen-Loève Expansion**
- For structured noise, use the Karhunen-Loève expansion to represent the stochastic term as a finite sum of eigenfunctions weighted by random variables.

4. **Parallel Simulations**
- For Monte Carlo simulations, use MATLAB’s `parfor` to accelerate sampling.

5. **Stochastic Galerkin Method**
- Project the stochastic part into a functional basis (e.g., Hermite polynomials) for reduced-order modeling.

---

### References and Tools

1. **MATLAB Functions**
- `fft`, `ifft` for spectral transforms.
- `ode45`, `ode15s` for deterministic ODE solving.
- Custom libraries like Chebfun for Chebyshev polynomials.

2. **Further Reading**
- Lord, Powell, and Shardlow, *An Introduction to Computational Stochastic PDEs*.
- Trefethen, *Spectral Methods in MATLAB*.

By following this outline, you can efficiently implement spectral methods for solving SPDEs in MATLAB.