# 1.2: Getting Started

- Page ID
- 34817

## 1.2.1: Problem Statement: Computing Electric Potentials

Let's now walk through the steps of writing a program to perform a simple task: computing and plotting the electric potential of a set of point charges located in a one-dimensional (1D) space.

Suppose we have a set of \(N\) point charges distributed in 1D. Let us denote the positions of the particles by \(\{x_{0}, x_{1}, \cdots, x_{N-1}\}\), and their electric charges by \(\{q_{0},q_{1},\cdots, q_{N-1}\). Notice that we have chosen to start counting from zero, so that \(x_{0}\) is the first position and \(x_{N-1}\) is the last position. This practice is called "zero-based indexing"; more on it later.

Knowing \(\{x_{j}\}\) and \(\{q_{j}\}\), we can calculate \(\phi(x)\) at any arbitrary point \(x\), by using the formula

\[\phi (x)=\sum_{j=0}^{N-1}\frac{q_{j}}{4\pi\epsilon_{0}|x-x_{j}|}\]

The factor of \(4\pi\epsilon_{0}\) in the denominator is annoying to keep around, so we will adopt "computational units". This means that we'll rescale the potential, positions and/or the charges so that, in the new units of measurement, \(4\pi\epsilon_{0}=1\). Then the formula for the potential simplifies to

\[\phi(x)=\sum_{j=0}^{N-1}\frac{q_{j}}{|x-x_{j}|}\]

Our goal now is to write a computer program which takes a set of positions and charges as its input, and plots the resulting electric potential.

## 1.2.2: Writing into a Python Source Code File

Before writing any Python code, we should create a file to put the code in. On GNU/Linux, fire up your preferred text editor and open an empty file, naming it`potentials.py`

. On Windows, in the window that was opened up by the `IDLE (Python GUI)`

program, click on the menu-bar item `File`

→ `New File`

; then type `Ctrl-s`

(or click on `File`

→ `New File`

) and save the empty file as `potentials.py`

.

The file extension `.py`

denotes it as a Python source code file. You should save the file in an appropriate directory.

Now let's do a very crude "first pass" at the program. Instead of handling an arbitrary number of particles, let's assume there's a *single* particle with some position \(x_{0}\) and charge \(q_{0}\). Then we'll plot its potential. Type the following into the file:

from scipy import * import matplotlib.pyplot as plt x0 = 1.5 q0 = 1.0 X = linspace(-5, 5, 500) phi = q0 / abs(X - x0) plt.plot(X, phi) plt.show()

Save the file. Now we will run the program. On GNU/Linux, open a text terminal and `cd`

to the directory where you file is, then type `python -i potentials.py`

. On Windows, while in file-editing window type `F5`

(or click on `Run`

→ `Run Module`

). In either case, you should see a figure pop up:

That's pretty much what we expect: the potential is peaked at \(X=1.5\), which is the position of the particle we specified in the program (via the variable named `x0`

). The charge of the particle is given by the variable named `q0`

, and we have assigned that the value \(1.0\). Hence, the potential is positive.

Now close the figure, and return to the Python command prompt. Note that Python is still running, even though your program has finished. From the command line, you can also examine the values of the variables which have been created by your program, simply by typing their names into the command prompt:

>>>x0 1.5>>>phi array([ 0.15384615 0.15432194 0.15480068 0.1552824 .... .... 0.28902404 0.28735963 0.28571429 ])

The value of `x0`

is a number, \(1.5\), which was assigned to it when our program ran. The value of `phi`

is more complicated: it is an *array*, which is a special data structure containing a sequence of numbers. From the command line, you can inspect the individual elements of this array. For example, to see the value of the array's first element, type this:

>>>phi[0] 0.153846153846

As we've mentioned, *index 0 refers to the first element of the array*. This so-called **zero-based indexing** is a common practice in computing. Similarly, index 1 refers to the second element of the array, index 2 refers to the third element, etc.

You can also look at the length of the array, by calling the function`len`

. This function accepts an array input and returns its length, as an integer.

>>>len(phi) 500

You can exit the Python command line at any time by typing `Ctrl-d`

or `exit()`

.