Overview In chapter 16 you learned how to calculate the Electric field from continuous distributions of charge; you follow four basic steps.

Transcription

1 Materials: whiteboards, computers with VPython Objectives In this lab you will do the following: Computationally model the electric field of a uniformly charged rod Computationally model the electric field of a uniformly charged ring Computationally model the electric field of a uniformly charged plate Get practice with for in : loops and the linspace( ) function Overview In chapter 16 you learned how to calculate the Electric field from continuous distributions of charge; you follow four basic steps. General Procedure for calculating the electric field for a charge distribution 1. Divide the charged object into small (ideally, infinitesimal) segments and draw E, a representative segment s contribution to the field at an observation location. 2. Use the figure to guide your writing an expression for the electric field E due to the representative piece in terms of its location. 3. Add (integrate) up the contributions of all pieces to find the total field at an observation location 4. Check the results. Whether or not the sum can be rephrased as an integral with an analytical solution (one that can be done with pencil and paper), it can be approximated computationally. That is what you ll do in this lab. Feel free to refer to the VPython programs you wrote during Lab 1 and even cut and paste any useful code from those programs to the new ones. L Electric Field of a Uniformly Charged Rod I. One Observation Location You ll use VPython to model a uniformly, positively charged rod. The diagram to the left represents the first step in tackling this problem: illustrating the geometry of the charge distribution and observation L/2 location and a segment of that distribution s contribution to the field at the observation location. The next step is writing an expression for the field due to the segment s charge Q, approximating the segment as a point source. Q Q 1 1 E ro 4 ro s r o 2 4 o 3 o s r r o s o s -L/2 When the time comes, you ll want to translate this mathematical expression into VPython code. To get started on the program, open VPython from the desktop and then, from WebAssign, you can download a shell of the program that you ll wright - open it, copy and paste the text into the VPython window, and then save it as RodE1.py (remember, you need to type 1

2 the.py ). Please add your names in the first comment line of the code. The program is broken into the four basic sections: Constants, Objects, Initial Values, and Calculations. You ll need to complete a number of lines in each section. Some are pretty straightforward, given what you already know; here s the information pertaining to those lines of code: The rod has a total charge of 9e-8 Coulombs The rod is 2 meters long The point sources that approximate the continuous rod are 0.1m apart. The source is a cylinder lying along the y-axis and centered on the origin o A cylinder is defined much like an arrow: the pos locates one end (you ll want it at x=z=0, y = L/2), and the axis tells you how to get to the other end from there. The initial observation location is (0.1, 0.5, 0)m We ll return to the sourceys line in a moment. Represent the electric field at the observation location with an arrow positioned at the observation location and with length and direction (axis) that s proportional to the electric field. (You re creating this arrow before the loop, and you ll update its length in a moment, within the loop). The necessary calculations to determine the small electric field contribution, de, due to the small charge, dq, on a small segment of the rod (approximating it as a point charge) are performed. Update the length of the electric field vector according to the updated value of E. Now for the new bits; up in the Constants section, complete the sourceys line as sourceys = linspace(-l/2,l/2, Ns) This line creates a list of the y-components of the infinitesimal segments into which you break up the continuous source. More specifically, linspace is a function that creates a list of Ns (Number of source Segments) equally spaced numbers running from L/2 (bottom end of source rod) to L/2 (top end of source rod.) To see what I mean, temporarily add the following print line just beneath the sourceys = line: print(sourceys) and run your program. Aside from the pretty picture it creates in the display window (if there are no errors), in the other window, it should print out a list of values (Ns of them) running from -1 (which is -L/2) to 1 (which is L/2). This list gets used in controlling the for loop, for sourcey in sourceys: The code inside the loop is executed once for each of the Ns segments of the charge source. To make sure your program is functioning correctly, at the very end add a line (unindented) to print the final value of the electric field at your observation location and then check that value in WebAssign. The computational approximation small enough segments. In the programs that you wrote in Phys 231, you simulated the behavior of a system over some time interval, and you approximated the continuous flow of time as broken into discrete 2

3 steps, deltat. That begged the question are the time steps small enough for the positions, momenta, and forces to vary accurately? In this simulation (and many you ll write in this class), you re doing something similar and faced with a similar question. You re approximating a charge source that is smooth and continuous through a region of space (in this case, a rod along the y axis) as broken into discrete steps/point sources. That begs the question are the steps small enough to produce an accurate electric field? Depending on how accurate we need the model to be - whether we want the E field values to just be in the right ball park or, say, within 1% of the correct value we ll want to approximate the rod with fewer or more point charges. You generally want to approximate the object with point charges that are much closer to their neighbors than to your observation locations. Let s say we want to approximate the source as point charges that are 1/10 th as far apart as the observation location is from the source. Given the observation location s horizontal distance from the rod, how far apart should the point charges be? Then, given the total length of the source, approximately how many point charges should we use to approximate the source, that is, what should Ns be? Change Ns to that and re-run the program. You should notice that the E value it prints out is significantly different from what you got for dl =0.1. Let s say we want our field to be within about 5% of the correct value. To see whether you ve broken the source into closely-enough packed point charges, decrease dl by a factor of 10 and run the program again. o If the new E value is within 5% of the previous value, then you d probably approximated the source closely-enough packed point charges. Then, in the interest of not wasting time, I suggest you revert dl to its previous value. o But if the new E value is not within 5% of the previous value, then you ve certainly not broken the source into enough point charges. Then if that s the case, divide dl by 10 again and and check once more to see if your most recent two values of E are within 5% of each other. Repeat until the answer is yes, and, in the interest of not wasting time, return dl to its second-to-last value (10 times larger). You re done with the print(e) line, so you can comment it out. RodE1.py Save a new copy as RodE2.py. II. Ring of Observation Locations Rather than determining the electric field at just one observation location, you ll determine it at a number of locations along a circle about the rod (constant y coordinate, but varying x and z coordinates.) Rephrase the obsloc line in terms of radius and angle: obsloc = vector(ro*cos(obstheta), 0.5, Ro*sin(obstheta)) To make this work, you ll want to go back up to the Constants section and define the radius of your ring of observation locations to be Ro = 0.1 #m, radius of observation locations 3

4 Just to make sure things work, just before the obsloc line, define the observation angle to be pi ( ). Run the program to make sure it works. Of course, what you really want to do is step through observation angles. In preparation for that, move the obstheta = and the obsloc=. lines to just before the Earrow = line. Just before them, add a line, much like the sourcys= line, that uses the linspace(,, ) function to define the observation angles, obsthetas, running from 0 to 2*pi; I d suggest you ask for 6 angles over this range (since 2*pi is the same direction as 0, you ll really get 5 unique angles). Replace the obstheta = line with for obstheta in obsthetas: and indent all lines beneath it (highlight them all and then select Indent Region under the Format menu.) This will make the electric-field calculation get repeated for each observation location. Finally, you ll want to zero out the E field value before you move on to each new observation location. RodE2.py Save a new copy as RodE3.py. III. Multiple Rings of Observation Locations Finally, to get a more complete representation of the field all around the rod, you ll determine the electric field around a few rings along the length of the rod ; that is, you ll vary the observation locations y-coordinate. Follow similar steps to those in part II to Create a list of 8 y-component values for observation locations, obslocys. Replace the 0.5 in your obsloc = line with the variable obslocy. Loop over the calculations for each obslocy value in the list of obslocys. RodE3.py 4

5 Electric Field of a Uniformly Charged Ring You ll use VPython to model a uniformly, positively charged ring. You ll proceed much as you did for the rod first get your program to evaluate the field at just one observation location, and then evaluate at multiple observation locations. The ring you ll model has a radius of 0.3m and thickness of 0.01m; it is centered on the origin and lays in the y-z plane. It has uniform charge 50e-9 Coulombs. I. One Observation Location To help you visualize the relevant properties in the program that you ll write, on a whiteboard, draw a diagram similar to that at the beginning of this lab (but for a ring source rather than a rod source). It should have o axes, o the ring laying in the x-z plane and centered on the y axis, o a representative segment of the ring selected as an infinitesimal source, o three position vectors: one to the source segment ( r s ), one to a representative observation location ( r o ), and one getting from the source segment to the observation location ( r ). o s o and a vector at the observation location representing the segment s contribution to the field there ( Es r o ). Open a new VPython window and save as RingE1.py. Writing / Repurposing the Program. I suggest you also open your RodE1.py program (the version in which you d found the field of a rod at just one observation location) to reference as you build your new program. With that approach in mind, here are some important differences between the RingE1.py that you ll write and the RodE1.py that you ve already written. o Rather than having a set length, L, the ring has a set radius, R. o Rather than specifying a dl and later calculating Ns, it will be easier to just specify in the constants section an Ns, the number of segments into which you ll imagine breaking the source. Start with Ns = 20. o The source object will be a ring rather than a cylinder. A ring has the following attributes: pos, axis, radius, thickness and color. The last three are self-explanatory; for a ring, pos is the location of the ring s center, and axis is the direction that the ring faces (1,0,0). o Rather than defining sourceys which give the y components of the source segments, define sourcethetas which give the angle to each source segment. You ll use the linspace function to do this. While it would be tempting to use that to create a list of Ns angles that run from 0 to 2*pi, since 2*pi is the same direction as 0 and you don t want to give it double weight in determining the electric field, you ll instead run from 0 to 2*pi 2*pi/Ns. That will do what you really want. 5

6 o Your for in loop should now run for theta in sourcethetas. o You ll need to specify each source segment s location in terms of R and theta to create a ring in the x, z plane: vector(0, R*cos(theta), R*sin(theta)). o Finally, I d suggest temporarily slowing the rate down to rate(10), one cycle per second, so you can more easily visualize how the calculation is being performed one segment of the source at a time. o Use a print statement at the end of your program to output the value of the electric field at the observation location, and check that value in WebAssign. < , , e-014> The computational approximation small enough segments. As with the rod source, you want to make sure that you ve broken the ring source into enough / small-enough segments to give a good approximation to the electric field. Increase Ns (number of segments) until the electric field value printed doesn t change more than about 5%. You re done with the print(e) line, so you can comment it out. RingE1.py Save a new copy as RingE2.py. II. Plane of Observation Locations Rather than determining the electric field at just one observation location, you ll determine it at a number of equally-spaced observation locations in the x-y plane. Your observation locations will be a 21 by 21 grid of evenly-spaced points running over 1 m x 1m and 1 m y 1m. There are two ways you could structure your program to do this. One is to nest your E-field calculations in two while loops one over x coordinates and over y coordinates for the observation locations. The other is to first build a list of observation locations (much like you re using the linspace function to build a list of source angles) and then nest your E-field calculation in a single for loop. Feel free to take the former approach if you want, but I describe here how to do the latter since it s a demonstration of a good programming strategy divide a problem into little problems and tackle them individually. In the constants section of your program, define xmax and ymax to be 1 and define Nx and Ny to be 21. To create the list of observation locations, replace the line in which you define the observation location (obsloc = ) with the following obslocations=[] for obsx in linspace(-xmax,xmax,nx): for obsy in linspace(-ymax,ymax,ny): obslocations.append(vector(obsx,obsy,0)) Here s how it works. 6

7 o The first line prepares the program by creating an empty list of observation locations; that s like writing grocery list at the top of a piece of paper there s nothing listed yet, but now you re ready. o The last line takes the list you ve named obslocations and enters onto it the vector (obsx, obsy,0). o That this is nested within two for loops means it does that over and over again for different values of obsx and obsy. The end result is a list of the observation locations that you ll use. o To see this, temporarily add a print(obslocations) line right after this new code (and un-indented) and run the program. Note: you re not done modifying your code, so the program will crash, but not before it manages to print the list of observation locations. When done, comment out the print line. o Add the line for obsloc in obslocations: before your for theta in sourcethetas: line and indent all subsequent lines so they are within the for obsloc loop. o If they aren t already within the for obsloc loop, move these two lines to be the first two within the loop: E = vector(0,0,0) Earrow = arrow(pos = obsloc, axis = E*Escale, o Unfortunately, two of our observation locations are on the loop, and so E would be infinite there. To avoid that problem, add this pair of lines at the bottom of your for obsloc loop (indented just one level) if mag(e) > : Earrow.axis = vector(0,0,0) o Finally, increase the rate to rate(1000) or just comment it out so things aren t painfully slow. Pause and Consider: Rotate the scene with the mouse to get a feeling for the nature of the pattern of electric field. Look at your display; does it make sense? Do the magnitudes and directions of the orange arrows make sense? The electric field is zero at the center of the ring (why?). The electric field also approaches zero very far from the ring. Therefore we should expect that along the axis there should be a place where the magnitude of the field is a maximum. Do you see such a maximum on the axis in your display? RingE2.py 7

8 Electric Field of a Uniformly Charged Thin Plate You ll simply but carefully modify your RingE2.py program to instead model a uniformly, positively charged square plate. Save a copy of RingE2.py as PlateE.py Writing / Repurposing the Program. The plate you ll model measures 0.01m 0.3m 0.3 m. It has uniform charge 50e-9 Coulombs. Here are the modifications you ll want to make to your code. o The object you ll use to visually represent the source is a box. A box has attributes pos (location of its center), length, width, height, and color. Give your box length 0.01m, width 0.3m, and height 0.3m. I d suggest defining L, H, and W in your constants section and then referencing them within your source= box( ) line. o Just like you d created your obslocations, now create sourcelocations so its x components run from L/2 to L/2 in Ns steps and its y components run from H/2 to H/s in Ns steps. o Since the preceding step means you ve broken the source into Ns 2 segments, change the segment s charge, dq, to be Q/Ns**2. o In your calculations section, change the for theta in line to be for sourceloc in sourcelocations: and remove the subsequent line that used to define sourceloc in terms of R and theta since you ve already created all your source locations and stored them in the sourcelocations list. That should be it! PlateE.py 8

9 Phys 232 Lab