Program 1

Implicit Methods

Python 3.11 Ready

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import simps
from matplotlib.animation import FuncAnimation

# Parameters
L, x0, k, a, N = 30.0, 2.0, 0.0, 2.0, 1000
xs, h = np.linspace(-L/2, L/2, N, retstep=True)
us = np.exp(-(xs - x0)**2 / a + (0.0 + 1.j) * k * xs)
Vs = xs[1:-1]**2 / 2
dt = 0.1
mu = (0. + 1.j) * dt / (2 * h**2)
t, tf = 0, 8.0

# Set up the figure and axis
fig, ax = plt.subplots()
line, = ax.plot(xs, np.abs(us)**2)
ax.set_ylim(-0.5, 1.1)
ax.axhline(0, color='black', lw=0.5)
ax.axvline(0, color='black', lw=0.5)

# Construct matrix A and its inverse B
A = np.eye(N - 2) * (1.0 + 2.0 * mu) + np.diag(1.j * dt * Vs) - mu * np.eye(N - 2, k=1) - mu * np.eye(N - 2, k=-1)
B = np.linalg.inv(A)

print(max(np.abs(np.linalg.eig(B)[0])))

# Animation function
def update(frame):
    global us, t
    us[1:-1] = np.dot(B, us[1:-1])
    t += dt
    line.set_ydata(np.abs(us)**2)
    return line,

# Create animation
ani = FuncAnimation(fig, update, frames=int(tf/dt), blit=True)

# Save the animation as a GIF
ani.save('plot.gif')

Click "Run Code" to execute script and render figures.

Theoretical Background & Computational Mechanics

Implicit Method for TDSE

The implicit method uses backward differences for time derivatives, expressed as:

$$\frac{\psi^{n+1}_k - \psi^n_k}{\Delta t} = \frac{\partial \psi}{\partial t}\bigg|_{t=t_{n+1}}$$

Equation Formulation

Substituting into the TDSE gives:

$$\small i \frac{\psi^{n+1}_k - \psi^n_k}{\Delta t} = -\frac{1}{2} \frac{\psi^{n+1}_{k+1} - 2\psi^{n+1}_k + \psi^{n+1}_{k-1}}{(\Delta x)^2} + V \psi^{n+1}_k$$ we take $$m = \hbar = 1$$ and let $$\mu = \frac {i \Delta t}{2 \Delta x^2}$$;

Rearranging leads to:

$$\small \psi^n_k = \left({1 + 2\mu + i\Delta t V_k^{n+1}} \right) \psi^{n+1}_{k} - \mu \psi^{n+1}_{k+1} + - \mu \psi^{n+1}_{k-1} $$

Matrix Representation

This can be expressed in matrix form as:

$$\mathbf{\psi}^n = B \cdot \mathbf{\psi}^{n+1}$$

where:

$$\tiny B = \begin{bmatrix} 1 + 2\mu + i\Delta t V^{n+1}_1 & -\mu & 0 & \ldots & 0 \\ -\mu & 1 + 2\mu + i\Delta t V^{n+1}_2 & -\mu & \ldots & 0 \\ 0 & -\mu & 1 + 2\mu + i\Delta t V^{n+1}_3 & \ddots & 0 \\ \vdots & \vdots & \ddots & \ddots & -\mu \\ 0 & 0 & 0 & -\mu & 1 + 2\mu + i\Delta t V^{n+1}_{N-2} \end{bmatrix} $$

Inverting gives:

$$\mathbf{\psi}^{n+1} = B^{-1} \mathbf{\psi}^n$$

Pros and Cons of Implicit Method

Stability: More stable for small time steps; eigenvalues of $M$ approach 1.
Norm Conservation: Ensures stability in the wavefunction norm across steps.
Efficiency: More accurate for larger time steps, but requires solving a system of equations, making it computationally intensive.

Theoretical Principles & Computational Physics Guide

Implicit Methods: Computational Physics Modeling & Analysis

Dr. Alorika Chatterjee & Dr. Anirban Shaw Science & Physics Learners Python 3 / NumPy / SciPy

1. Core Principles & Theoretical Framework

Core Concept: Computational formulation and simulation of Implicit Methods within the study of TDSE Solution.

Algorithmic Translation: Translates theoretical governing equations into clean, discrete Python procedures and verified numerical solvers.

Numerical Verification: Evaluates numerical accuracy, parameter sensitivity, and error bounds for reliable computational results.

2. Mathematical Formulation & Algorithmic Pipeline

Governing computational formulation for Implicit Methods:

$$ \mathcal{F}_{\text{model}}(\mathbf{x}, t; \mathbf{p}) = 0 \implies \mathbf{y}_{n+1} = \mathcal{S}(\mathbf{y}_n, \Delta t, \mathbf{p}) $$

1. Define Physical Parameters & Boundaries → 2. Execute Numerical Simulation Steps → 3. Evaluate Observables & Plot Results

3. Numerical Mechanics & Implementation Logic

Parameter Initialization: Set physical constants, initial states, and coordinate boundary bounds for Implicit Methods.
Step Execution: Advance the computational state using optimized vector operations and scientific libraries.
Convergence Control: Monitor stability and ensure simulation metrics remain physically meaningful.

4. Relevant Computational Practice Exercises

Exercise 1

Implement Implicit Methods and observe how the output responds to variations in primary physical parameters.

Exercise 2

Refine the calculation grid or step size to observe convergence and reduction in numerical approximation error.

Exercise 3

Compare the simulated computational results against an analytical benchmark or limiting physical case.

Standard Literature & References:

Mark Newman, "Computational Physics", University of Michigan (2013).
Hans Petter Langtangen, "A Primer on Scientific Programming with Python", Springer (2016).

Ch. 20.2 Implicit Methods