In this workshop, we are often going to use Glowscript to create computational models, which will serve as a powerful tool to help us create visualizations and apply the ideas in this course to more real-world contexts. Below are some of the common Python commands that we will use and some coding tips compiled by previous students. (Note: we do not expect you to have any coding experience prior to this course, and we will not expect you to write a program from scratch. We will primarily be asking you to interpret chunks of code with your group members and adjust/modify pieces of code that you will be given).

• Creating Objects - in the code we often want to create an object as a visual for the model. For example, we might want to create a sphere to represent a cloud or an arrow to represent the electric field. Python has the objects built in, but you have to tell it the characteristics of the object you want to create. For example, in the following code, the command sphere tells Python to make a sphere, pos=vec(0,3500,0) says where the center of the sphere should be positioned, color=color.white says to make the sphere white, and radius=100 sets the radius of the sphere. The word cloud before the equals sign is simply a name that you will use to refer to this object. Look here for a list of useful 3D objects in Glowscript .

cloud = sphere(pos=vec(0,3500,0), color=color.white, radius=100)

• Creating a box object - the following code is another example for a box with side lengths of 2 on each side. opacity=0.1 will make the box mostly transparent.

MyBox = box(pos=vec(0,0,0), length=2, width=2, height=2, color=color.white, opacity=0.1)

• Object attributes - depending on what object you are creating there may be different attributes that you want to define (pos, length, width, radius, color, etc). You can also change the attributes of an object later in the code. This can be particularly useful for the updating the position of an object, which can let you simulating a moving object. In the example below, the first line of code creates a green, 2×2 box that is centered at the origin (0,0,0). In the second line of code, the box position is changed to (3,4,5) without changing the other characteristics of the box.

object1=box(pos=vec(0,0,0), length=2, width=2,color=color.green)
object1.pos=vec(3,4,5)

• Assigning new attributes - you can also give any object a new attribute that was not previously defined in the code. For example, after creating a spherical basketball, the code below assigns a velocity attribute of (5,0,0) to that object. This is useful because it allows us to easily recall values from an object by referring to a memorable object name like basketball.

basketball=sphere(pos=vec(0,0,0), color=color.white, radius=10)
basketball.velocity=vec(5,0,0)

• Printing values and text - The print() command will output any value called from within the parentheses. You can print variables and attributes from your code as a way of checking what numbers the simulation has calculated. The following code creates a conical object named IceCreamCone, and the print(IceCreamCone.size.x) command prints the x-component of the object's size attribute. If you want to print text, it must be transformed into a “string” of letters by using quotation marks within the print() command.

IceCreamCone=cone(pos=vec(0,0,0), axis=vec(0,-5,0), size=vec(3,1,1))
print("Ice cream cone length:", IceCreamCone.size.x)
print("Two scoops of butter pecan please!")

• Graphs - the most convenient graphs in Glowscript utilize the gcurve command which plots x-y data points as a scatterplot and connects the points with a line. In general, Three lines of code are needed to graph in Glowscript…

1. A line above the while loop which creates the axes and titles of the graph (line 3 in the picture below).
2. A line above the while loop which tells the program what you are about to graph (line 4 in the picture below).
3. A line inside of the while loop which plots the respective x-y data point for that iteration of the while loop (line 19 in the picture below).

• Another graphing example - In the following code, MyGraph1 is needed to set up the graphing window with its various axes titles, minimum and maximum boundaries, and other features. The line with HeightGraph names a particular data-set that will be represented on our scatterplot. Lastly, within the while loop, the HeightGraph.plot(t,Cart.pos.y) command is used to plot data points for our specified data-set (t will be on the x-axis and Cart.pos.y will be on the y-axis).

MyGraph1 = graph(title='Height vs Time', xtitle='Time (s)', ytitle='Height (m)', fast=False) #Name our graph and set some features
HeightGraph = gcurve(color=color.red, label='Height') # Specifies a name for the data-set that we will be plotting

Cart=box(pos=vec(0,0,0), size=vec(1,1,1),color=color.magenta)
t=0
dt=1
while True:
    rate(100)
    Cart.pos=Cart.pos+vec(0,1,0)*dt
        
    # This line plots data points as the program iterates
    HeightGraph.plot(t,Cart.pos.y) # t will be on the x-axis and Cart.pos.y will be on the y-axis
    
    t=t+dt

* If-then statements - these act as triggers to start some new event once a condition in met. For example, it we have an object moving to the right with particle.velocity=vec(1,0,0) and we want it to move in the opposite direction after 10 seconds, then you might use the following code.

Particle = sphere(pos=vec(0,0,0))
Particle.velocity=vec(1,0,0)

t=0
dt=1
tf=20

while t >= tf:
  rate(100)
  Particle.pos=Particle.pos+Particle.velocity*dt

  if t >= 10:
    Particle.velocity=vec(-1,0,0)

  t=t+dt

• Arithmetic - arithmetic functions may be executed by a computer program, similar to how one would use a calculator. The following code will calculate this difficult math for us.

MyAnswer = 123 * 44 + 566 / 33 - 935
print(MyAnswer)

• Absolute Value - to take the absolute value, use the abs() command.

Number=5
AbsoluteNumber = abs(Number)

• Exponents - to write an exponent in Python you have to use a $**$ rather than ^. For example, to write $A=5.43*10^4$ in code you would write:

A=5.42*10**4

• Scientific Notation - the code below shows how to use scientific notation in Python.

A=5.24E4

• Square root - to write a square root in Python, use the sqrt() command.

qwer=sqrt(625)

• Vectors - In Python, you can define a variable as a vector using the vec() command. In this command, you simply have to define the three components of the vector (x, y, and z): vec($v_x$,$v_y$,$v_z$). Python will then automatically use vector subtraction/addition if you try to add two vectors. However, it will create an error if you try to add/subtract a scalar and a vector.

position1=vec(3,4,5)
position2=vec(2,1,0)
separation=position2-position1  #This will give separation=vec(-1,-3,-5)
testing=separation-4 #This will give an error

• Vector magnitude - the mag() command will calculate the magnitude of any vector.

vector1=vec(1,2,3)
mag1=mag(vector1) #This will calculate sqrt(1^2+2^2+3^2)

• Check your parentheses - the computer will very strictly follow the order of operations (PEMDAS - Parentheses Exponents Multiplication Division Addition Subtraction). When writing out equations, make sure you have parentheses in the correct places. For example in the code below, the computer would say A = 6 but B = 4 – so these are not the same thing! Parentheses errors can be especially tricky because the program will likely run perfectly fine. Also, make sure that each of your parentheses match up – in other words every bracket has to have a buddy.

A=4+4/2
B=(4+4)/2

• Watch upper/lower cases - coding is case sensitive - meaning that lowercase and uppercase letters mean something different in coding. If I had two different variables named Num_1 and num_1, Python would treat these as two distinct objects. If you initially set your variable name to be Num_1 but wrote num_1 throughout the rest of your code, Python would not know what num_1 was. Just be conscious that when you are naming or using different elements in your code, that you are writing it the same way every time.
• Comments - comments are informational statements that are not read or used by the program, but help you when analyzing the code. In Python, you can turn any line or part of a line in the code into a comment by putting a # or ## in that line (see the examples below). You can use comments in several different ways:
  • Notating units - especially in long equations or calculations, keeping track of the units can help you evaluate whether your solution or equation is right. After any variable, you can add the units of that variable with a comment (see the example below).
  • Denoting what specific lines of code do - before a chunk of code it's often helpful to write out what the purpose of those lines of code are in plain English. This is especially helpful when trying to use code that is quite long and complicated or if you’re trying to share code with a team member. This can also be helpful when working with others communicate any misunderstanding of the code or suggest potential changes.
  • Fixing errors in your code - if you are not sure which line is giving you trouble, instead of deleting the entire line, just comment it out. This way if you find that that line was not the problem later, you don’t have to rewrite it, you just have to uncomment it (uncommenting is done by deleting the #). A suggestion is to never delete lines of code unless you are 100% positive that either 1: you don’t need it or 2: it’s wrong. Basically, comments let you erase lines of code without actually erasing them.

## Set the radius (this line would be ignored by the program)
R=20 #cm (Everything in this line before the # would run in the program, everything after the # is ignored)

• Indentation errors - these can be tricky sometimes. The best way to fix these is to [BACKSPACE] the faulty code up to the line above it and then pressing [ENTER] again to separate the lines and reset the indentation. This is not the only way to fix indentation errors.

Check out this link for a useful math review.