Partial Differential Equations (PDEs)

13. Partial Differential Equations (PDEs)#

13.1. Introduction#

Partial Differential Equations (PDEs) are fundamental to mathematical modeling of physical phenomena. They express relationships involving rates of change with respect to more than one independent variable. PDEs are pivotal in fields such as physics, engineering, and finance, finding applications in areas ranging from fluid dynamics to options pricing.

This notebook will provide a comprehensive overview of PDEs, focusing on their classification, analytical approaches, and numerical methods such as finite difference and finite element methods. We will also explore various real-world applications of PDEs.

13.2. Classification of PDEs#

13.2.1. Theory#

PDEs can be classified according to their order, linearity, and the nature of their solutions. The most important classification, however, is based on the form of the PDE:

  1. Elliptic PDEs: These are typically time-independent and describe steady-state problems. An example is Laplace’s equation:
    [ \nabla^2 \phi = 0 ]

  2. Parabolic PDEs: These describe problems involving time evolution, such as diffusion processes. The heat equation is a classic example: [ u_t = \alpha \nabla^2 u ]

  3. Hyperbolic PDEs: These equations describe wave propagation and involve time derivatives, like the wave equation: [ u_{tt} = c^2 \nabla^2 u ]

13.2.2. Examples#

To illustrate these classifications, let’s consider simple Python implementations for solving:

import numpy as np
import matplotlib.pyplot as plt

# Example: Solving Laplace's Equation using finite difference method
def laplace_2d(f, nx, ny, tol):
    """A simple Laplace solver for a 2D grid"""
    u = np.zeros((ny, nx))
    diff = tol + 1

    while diff > tol:
        un = u.copy()
        u[1:-1, 1:-1] = 0.25 * (un[1:-1, :-2] + un[1:-1, 2:] + un[:-2, 1:-1] + un[2:, 1:-1])
        diff = np.linalg.norm(u - un)
    
    return u

# Example grid
nx, ny = 50, 50
tolerance = 1e-5
solution = laplace_2d(lambda x, y: x**2 - y**2, nx, ny, tolerance)

plt.imshow(solution, cmap='coolwarm')
plt.colorbar()
plt.title("Solution of Laplace's Equation")
plt.show()

13.3. Analytical Solutions#

13.3.1. Theory#

Analytical solutions to PDEs are exact and provide insights into the behavior of the system described. Common techniques include:

  • Separation of Variables: Applicable when the PDE can be split into simpler ODEs.

  • Transform Methods: Such as Laplace or Fourier transforms which convert PDEs into algebraic equations.

  • Green’s Functions: Used to solve inhomogeneous boundary value problems.

13.3.2. Examples#

Analytical solutions can be computationally complex, involving symbolic calculations. Below is an example using Python’s sympy library for the heat equation.

from sympy import symbols, Function, dsolve

# Example: Solving the heat equation using sympy
t, x = symbols('t x')
u = Function('u')(t, x)
alpha = symbols('alpha')

heat_eq = u.diff(t) - alpha * u.diff(x, 2)

solution = dsolve(heat_eq, u)
display(solution)

13.4. Finite Difference Methods#

13.4.1. Theory#

Finite Difference Methods (FDM) approximate the solutions to PDEs by replacing continuous derivatives with discrete differences using computational grids. It’s widely used for its simplicity and ease of implementation.

13.4.2. Examples#

Here is an example to solve the 1D heat equation using an explicit finite difference method:

def heat_fdm(alpha, L, T, nx, nt):
    """1D Heat equation solver using FDM"""
    dx = L / (nx - 1)
    dt = T / (nt - 1)
    u = np.zeros((nt, nx))
    u[:,0] = 100  # Boundary condition
    
    for n in range(0, nt - 1):
        for i in range(1, nx - 1):
            u[n+1, i] = u[n, i] + alpha * dt / dx**2 * (u[n, i+1] - 2*u[n, i] + u[n, i-1])
    
    return u

solver_output = heat_fdm(0.1, 1.0, 0.1, 50, 50)

plt.plot(np.linspace(0, 1, 50), solver_output[-1])
plt.title("1D Heat Equation at t=T")
plt.xlabel("x")
plt.ylabel("Temperature")
plt.show()

13.5. Finite Element Methods#

13.5.1. Theory#

Finite Element Methods (FEM) involve subdividing the domain into smaller elements and solving the problem locally. The method excels in handling complicated geometries and boundary conditions.

  • Mesh Generation: Divide the domain into finite elements.

  • Function Approximation: Represent the solution by a linear combination of basis functions.

  • Assembly: Compile a system of equations to solve.

13.5.2. Examples#

Python libraries like FEniCS facilitate FEM implementations. Consider a basic Laplace problem using FEniCS:

from fenics import *

# Define problem parameters
mesh = UnitSquareMesh(8, 8)
V = FunctionSpace(mesh, "P", 1)

# Define boundary conditions
u_D = Expression("1 + x[0]*x[0] + 2*x[1]*x[1]", degree=2)

def boundary(x, on_boundary):
    return on_boundary

bc = DirichletBC(V, u_D, boundary)

# Define the variational problem
u = TrialFunction(V)
v = TestFunction(V)
f = Constant(-6.0)
a = dot(grad(u), grad(v)) * dx
L = f * v * dx

# Solve
u = Function(V)
solve(a == L, u, bc)

# Plot
import matplotlib.pyplot as plt
plot(u)
plt.show()

13.6. Applications of PDEs#

13.6.1. Theory#

PDEs have significant applications in various scientific and engineering domains. Some critical areas include fluid dynamics, electromagnetics, heat transfer, and structural analysis.

13.6.2. Examples#

  1. Fluid Dynamics: Modeling air flow over a wing or simulation of ocean currents.

  2. Electromagnetics: Designing antenna patterns and analyzing electromagnetic wave propagation.

  3. Heat Transfer: Simulating cooling systems or analysis of heat dissipation in electronics.

  4. Finance: Black-Scholes equation in option pricing for stock markets.

The power and flexibility of PDEs have been shown in their ability to model and simulate physical and natural processes accurately. Leveraging both analytical and numerical methods allows for a deeper understanding and problem-solving capability in real-world scenarios.