NumPy in Physics: Simulating Physical Systems

NumPy, the cornerstone of scientific computing in Python, empowers physicists to efficiently model and analyze complex physical systems. Its powerful array manipulation capabilities, combined with its tight integration with other scientific libraries like SciPy and Matplotlib, make it an indispensable tool for simulating a wide range of phenomena. This article delves into the application of NumPy in simulating physical systems, showcasing its versatility and effectiveness.

Table of Contents

Simulating Simple Harmonic Motion

Simple harmonic motion (SHM) is a fundamental concept in physics that describes the oscillatory motion of a system under a restoring force proportional to the displacement from its equilibrium position. Let’s use NumPy to simulate the motion of a mass attached to a spring, governed by the equation:

x(t) = A * sin(ωt + φ)

where:

x(t) is the displacement of the mass at time t
A is the amplitude of oscillation
ω is the angular frequency
φ is the phase constant

Python Code Example:

import numpy as np
import matplotlib.pyplot as plt

# Define parameters
A = 1.0  # Amplitude
ω = 2.0 * np.pi  # Angular frequency
φ = 0.0  # Phase constant

# Time points
t = np.linspace(0, 2, 100)

# Calculate displacement
x = A * np.sin(ω * t + φ)

# Plot the displacement
plt.plot(t, x)
plt.xlabel("Time (s)")
plt.ylabel("Displacement (m)")
plt.title("Simple Harmonic Motion")
plt.show()

Output:

The code generates a sinusoidal wave representing the displacement of the mass over time.

Explanation:

The np.linspace function creates an array of evenly spaced time points.
The np.sin function calculates the sine of the argument, representing the displacement.
The matplotlib.pyplot library is used for plotting the displacement as a function of time.

Key Takeaways:

NumPy’s mathematical functions like np.sin simplify the simulation of physical phenomena.
Vectorized operations like applying np.sin to the entire array of time points make computations efficient.
Matplotlib allows for visualizing the simulation results.

Simulating Projectile Motion

Projectile motion is another fundamental concept in physics, describing the trajectory of an object launched into the air. The motion is governed by the equations of motion under constant gravitational acceleration.

Python Code Example:

import numpy as np
import matplotlib.pyplot as plt

# Initial conditions
v0 = 10  # Initial velocity (m/s)
θ = 45  # Launch angle (degrees)
g = 9.81  # Acceleration due to gravity (m/s²)

# Convert angle to radians
θ = np.radians(θ)

# Time points
t = np.linspace(0, 2, 100)

# Calculate horizontal and vertical displacement
x = v0 * np.cos(θ) * t
y = v0 * np.sin(θ) * t - 0.5 * g * t**2

# Plot the trajectory
plt.plot(x, y)
plt.xlabel("Horizontal Distance (m)")
plt.ylabel("Vertical Distance (m)")
plt.title("Projectile Motion")
plt.show()

Output:

The code generates a parabolic curve representing the trajectory of the projectile.

Explanation:

The np.radians function converts the launch angle from degrees to radians.
The equations for horizontal and vertical displacement are implemented using NumPy’s arithmetic operations.
The trajectory is plotted using matplotlib.pyplot.

Key Takeaways:

NumPy’s vectorized operations make it easy to calculate the displacement at multiple time points simultaneously.
The code demonstrates the application of fundamental physics equations in NumPy.

Simulating Wave Propagation

Wave propagation is a ubiquitous phenomenon in nature, ranging from sound waves to electromagnetic waves. NumPy can be used to simulate wave propagation in one dimension using the wave equation:

∂²u/∂t² = v² * ∂²u/∂x²

where:

u(x,t) is the displacement of the wave at position x and time t
v is the wave speed

Python Code Example:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Define parameters
v = 1.0  # Wave speed
x = np.linspace(0, 10, 100)  # Position points
t = np.linspace(0, 5, 100)  # Time points

# Create initial wave profile
u0 = np.exp(-(x - 5)**2)

# Define function for wave propagation
def wave_propagation(t):
    u = u0 * np.sin(2 * np.pi * (v * t - x))
    return u

# Animation
fig, ax = plt.subplots()
line, = ax.plot(x, wave_propagation(0))
ax.set_ylim(-1.5, 1.5)
ax.set_xlabel("Position (m)")
ax.set_ylabel("Displacement")
ax.set_title("Wave Propagation")

def animate(i):
    line.set_ydata(wave_propagation(t[i]))
    return line,

ani = FuncAnimation(fig, animate, frames=len(t), interval=20)
plt.show()

Output:

The code generates an animation of a wave propagating along the x-axis.

Explanation:

The code uses a sinusoidal function to model the initial wave profile.
The wave_propagation function calculates the displacement at each time point.
matplotlib.animation.FuncAnimation is used to create an animated plot of the wave.

Key Takeaways:

NumPy can simulate wave propagation by discretizing the wave equation.
Vectorized operations on NumPy arrays facilitate efficient computations.
Matplotlib provides tools for visualizing the wave propagation over time.

Simulating Random Walks

Random walks are stochastic processes that describe the movement of a particle with random steps. These processes find applications in various fields, including physics, finance, and biology.

Python Code Example:

import numpy as np
import matplotlib.pyplot as plt

# Define parameters
N = 1000  # Number of steps
dim = 2  # Dimensions of the walk

# Generate random steps
steps = np.random.randn(N, dim)

# Calculate positions
positions = np.cumsum(steps, axis=0)

# Plot the random walk
plt.plot(positions[:, 0], positions[:, 1])
plt.xlabel("X Position")
plt.ylabel("Y Position")
plt.title("Random Walk in 2D")
plt.show()

Output:

The code generates a plot of a random walk in two dimensions.

Explanation:

np.random.randn generates an array of random numbers with a standard normal distribution.
np.cumsum calculates the cumulative sum of the steps, representing the positions over time.

Key Takeaways:

NumPy’s random number generation capabilities are crucial for simulating stochastic processes.
Vectorized operations on NumPy arrays simplify the calculation of random walk positions.

Conclusion

NumPy’s power lies in its ability to perform efficient computations on arrays, which makes it ideal for simulating physical systems. From simple harmonic motion to complex wave propagation and random walks, NumPy provides the tools to model a wide range of phenomena. Its integration with other scientific libraries further enhances its versatility, making it an indispensable tool for physicists and other scientists alike. This article has merely touched upon the surface of NumPy’s capabilities in simulating physical systems. As you delve deeper into NumPy, you’ll uncover its vast potential for tackling increasingly complex and realistic simulations.