Potentials and Fields in electrodynamics

Was messing around with the pycharge library in python for simulation elecrtromagnetic fields. Specifically in point charges. For the example I generated a field of point charges and then used some of the calculation methods in the library.

To start you can create a number of points in a grid which will represent our field at different points. We also want to define a limit

lim = 10e-9
npoints = 100
coordinates = np.linspace(-lim, lim, npoints)

linspace will return evenly spaced numbers from one point to the next. Where our upper and lowerbounds are lim and the number of intervals is npoints

We can then create a meshgrid using numpy. This is a coordinate matrix using coordinate vectors. Where our coordinate vectors are, x, y, and z. In this case we can simulate the point charge in 2 dimensions.

x, y, z = np.meshgrid(coordinates, coordinates, 0, indexing='ij')

Pycharge allows us to calculate the Electric field generated by a point charge. The points in our coordinate system represent the strength of the field from the point charge.

E_x, E_y, E_z = simulation.calculate_E(t=0, x=x, y=y, z=z)

This will calculate the field strength in the x, y, and z coordinates for all of the intervals.

Calculate_E

Under the hood the PyCharge package is calculating the strength of the field from the point charge. It begins by initialising a time array for each of the points. The time array is an n_dimensional array of values set to 0.

t_array = np.ones((x.shape))
t_array[:, :, :] = t

^ Example of t_array

We do a similar thing here with the Energy values of each point in the coordinate sytesms

E_x = np.zeros((x.shape))
E_y = np.zeros((x.shape))
E_z = np.zeros((x.shape))

Because we are dealing with a single point charge there is only one charge to consider and so we can deal with it in a single loop. We can start with a initial guess which is equally far from the real root of the function of the point charge. We can set that value to $-1\cdot10^{12}$.

initial_guess = -1e-12*np.ones((x.shape))

Again here we are setting up a matrix of guesses in the same shape as our coordinate system. Then we begin an optimization of the function.

Aproximate time retardation

We can use numpy to aproximate the function for time retardation. We are dealing specifically here with Liénard-Wiechert potentials. We can use the newton optimize function here from numpy to aproximate a solution for the array of time_retardation values. The actual numerical aproximation that gets used is the secant method. The solve time method is doing the following.

$\sqrt{(x_{ij}-t_r)^2 + (y_{ij}-t_r)^2+(z_{ij}-t_r)^2 } - c\cdot(t-t_r)$

In the more physics based language, the expression is showin in Griffiths 10.55

$|r-w(t_r)| = c(t-t_r)$

We might have something. like the following. This a 4x4 dimensional coordinate in the x coordinate. The same will be the case for the y and z values.

The solve time algorithm will take the random guesses we made below and use those values for the time retardation. t in this case will just be passed as 0. In the end we are multyplying the time retardation by the speed of light according to the formula above.