TISE Solution: Finite Square Well - Computational Physics Formulation & Simulation

Program 1

Finite Square Well

Python 3.11 Ready

import numpy as np
from scipy.integrate import odeint, trapezoid
from scipy.optimize import bisect
import matplotlib.pyplot as plt

def V(x):
    if(x > -L/2 and x < L/2):
        V = -V0
    else:
        V = 0
    return V

V0 = 10    
L, m, hbar, w, E0, En = 4, 1, 1, 1, -V0, 0
Erange = np.arange(E0, En, 0.1)
x = np.linspace(-L, L, 1000)
u = [0, 0.1]
    
def f(u, x, E):
    y, z = u
    f1, f2 = z, ((2*m)/(hbar)**2)*(V(x) -E)*y
    return (f1, f2)

def psiboundval(E):
    sol = odeint(f, u, x, args = (E, ))
    return sol[:, 0][-1]

def shoot(Erange): 
    global E
    Y = np.array([psiboundval(E) for E in Erange])
    eigval = np.array([bisect(psiboundval, Erange[i], Erange[i + 1])
                       for i in np.where(np.diff(np.signbit(Y)))[0]])
    return eigval

def psinorm(E):
    sol = odeint(f, u, x, args = (eigen, ))
    psi = sol[:, 0]
    return psi/np.sqrt(trapezoid(psi*psi, x))

En = shoot(Erange)
print("Energy Eigen Values:", En)

P = np.array([V(i)for i in x])
plt.figure(figsize=(10,20))
st = 1
for eigen in En:
    psi = psinorm(eigen)
    normpsi = eigen + psi
    plt.subplot(len(En),2,st)
    plt.ylabel(f"$\Psi${st}(x)", fontsize=16)
    plt.xlabel(r'$x$', fontsize=16)
    plt.title(f'Energy level: n = {st}, Energy eigen value ={eigen: .4f}')
    plt.plot(x, normpsi)
    plt.plot(x, P)
    plt.axhline(y = eigen, color = 'g')
    plt.axvline(x = 0)
    st = st + 1
plt.savefig('psi.png')
plt.show()

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

Mathematical Problem Formulation

Particle in a Finite Potential Well

Consider a particle of mass $ m $ in a finite potential well $ V(x) $ defined by:

\[ V(x) = \begin{cases} -V_0 & \text{for } -\frac{L}{2} < x < \frac{L}{2} \\ 0 & \text{otherwise} \end{cases} \]

where $ V_0 $ is the depth of the potential well and $ L $ is the width of the well.

The SchrÃ¶dinger equation governing the particle's wavefunction $ \Psi(x) $ is given by:

\[ \frac{d^2 \Psi}{dx^2} = \frac{2m}{\hbar^2} \left( V(x) - E \right) \Psi \]

where $ E $ is the energy eigenvalue of the particle.

Solve for the Energy Eigenvalues:
Define a function that uses the shooting method to determine the energy eigenvalues of the particle in the potential well. The shooting method iteratively finds energy values $ E $ such that the boundary conditions at $ x = \pm \frac{L}{2} $ are satisfied.

The eigenvalues are obtained by searching within a specified energy range $ E_0 \leq E \leq E_n $.
For each energy eigenvalue $ E $, compute the corresponding wavefunction $ \Psi(x) $ using the differential equation.

Theoretical Principles & Computational Physics Guide

Finite Square Well: 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 Finite Square Well within the study of TISE 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 Finite Square Well:

$$ \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 Finite Square Well.
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 Finite Square Well 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. 19.3 Finite Square Well