Assignment 6: Heat Transfer Page 1

600.112: Intro Programming for Scientists and Engineers

Assignment 6: Heat Transfer∗†
Peter H. Fröhlich Joanne Selinski
[email protected] [email protected]
Due Dates: 3pm Wednesdays 10/21 & 10/28

Introduction regard to style.

The sixth assignment for 600.112: Introductory

Programming for Scientists and Engineers is all Background
about heat transfer and how to simulate it.
There are three required things to do: First you’ll What is heat? It’s probably in bad taste to start with
write a program to solve a simple one-dimensional a joke about the miserably humid 100◦ F Baltimore
heat transfer problem for a metal rod (rod.py, summer or refer to a popular 2009 tune by Nelly,
10 points). Second you’ll write a program so let’s be more scientific.
to solve a more complex two-dimensional heat Thermodynamics tells us that heat—on a macro-
transfer problem for a metal plate (plate.py, scopic level—is energy: the internal energy of a
22 points). Third you’ll write a faster ver- system is the sum of heat supplied to the sys-
sion of the two-dimensional heat transfer problem tem and the amount of work done on it. Statisti-
(plateFast.py, 18 points). cal mechanics tells us that heat—on a microscopic
We’ll continue working with vectors and matri- level—is movement: the atoms of a system move
ces in this assignment - exploring cell level ma- (or vibrate) faster the hotter the system happens to
nipulations and also whole array manipulations. be.
We’ll also introduce two new Python libraries! The Heat can be transferred in various ways: by con-
first is for plotting images: matplotlib. This li- duction (coal heats oven), by convection (flame
brary has many features and functions, including a heats pan), or by radiation (sun heats earth). We’ll
set common to MATLAB. The matplotlib webpage only consider heat transfer by conduction for this
contains many examples as well as links to sev- project, and we’ll also restrict our attention to
eral tutorials if you’re interested in learning more. solids.
The second library we’ll use is the N UM P Y li- Join us in a Gedankenexperiment! Imagine two
brary for scientific computations. This will allow copper cubes of equal size and mass. One of them
us to speed-up the matrix computations for the heat has a has a temperature of 25◦ C while the other
plate problem by moving many computations from has a temperature of 75◦ C. Imagine further that
P YTHON down closer to the machine itself. Make these copper cubes are perfectly insulated from the
sure that you have installed the necessary packages surrounding world and that there is no heat trans-
(PYTHON - MATPLOTLIB and NUMPY) through the fer by convection or radiation. What will happen
synaptic package manager before beginning.
∗
You must submit complete zip files with all *.py Special thanks to Jimmy Su and William Yu for helping
us develop this project.
and *.txt files needed to run your solutions as de- †
Disclaimer: This is not a course in physics or biology
tailed below, and on Blackboard before the dead-
or epidemiology or even mathematics. Our exposition of the
lines. Also, don’t forget to include descriptive doc- science behind the projects cuts corners whenever we can do
strings and doctests for your functions, and make so without lying outright. We are not trying to teach you
sure that your programs are all pep8 compliant with anything but computer science!

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 2

when we bring the two cubes into “perfect” physi- Then we can in turn approximate the second
cal contact? derivative at pm like this:
Along the area of contact, the atoms of the 75◦ C 
∂T 

∂ 2 T  − ∂T

cube will vibrate faster than those of the 25◦ C

∂x m+1/2 ∂x m−1/2
≈
cube. Every now and then a 75◦ C atom will “hit” a ∂x2 m ∆x
25◦ C atom and transfer its “kinetic energy” in the Tm+1 −Tm
− Tm −Tm−1
∆x ∆x
process, creating a 75◦ C atom in the 25◦ C cube and ≈
∆x
vice versa. Since this happens all along the area Tm+1 − Tm − Tm + Tm−1
of contact, pretty soon we’ll have an even mixture ≈
∆x2
of 75◦ C and 25◦ C atoms wiggling around in these Tm+1 − 2Tm + Tm−1
two “layers” of each cube. So on average, across ≈
∆x2
all the atoms along the area of contact, we have a
temperature of (25◦ C + 75◦ C) ÷ 2 = 50◦ C. Our approximation for one-dimensional heat trans-
What about the “next two layers” of atoms in fer by conduction becomes
each cube? They will in turn “exchange” equal Tm+1 − 2Tm + Tm−1
amounts of 75◦ C and 25◦ C atoms with the contact =0
∆x2
layers, and so on. Eventually the average tempera-
ture of both cubes will be 50◦ C, and it will remain which—when solved for the point pm —confirms
50◦ C even if we separate them again. our earlier suspicion that heat transfer is averaging:
1
Tm = (Tm+1 + Tm−1 )
2
Mathematics The obvious extension to the two-dimensional case
is also valid:
The basic mathematical model for one- 1
dimensional heat transfer by conduction is a Tm,n = (Tm−1,n + Tm+1,n + Tm,n−1 + Tm,n+1 )
4
second-order partial differential equation:
There’s a lot to say about the limitations of finite
∂ 2T difference equations, but we won’t worry about
=0 that here. Also note that a full understanding of
∂x2
this math background is not necessary for complet-
Sometimes we can find analytical solutions to such ing the assignment!
equations, but often all we can do is approximate
the solution numerically. One approach to a nu-
merical approximation is to transform the differen-
1 Metal Rod [10 points]
tial equations into finite difference equations: Imagine a metal rod of negligible thickness stick-
ing through a building’s brick wall. The inside of
df f (x + ∆x) − f (x) the building is cooled to 70◦ F while the outside of
≈
dx ∆x the building is sweltering at 100◦ F . To keep things
simple we’ll assume that the wall itself has no in-
We discretize the continuous x domain into n fluence whatsoever on the temperature of the rod.
points p1 , p2 , . . . , pn spaced ∆x apart; pick some For this problem you will write a program that
point pm and approximate the first derivatives at computes the temperature distribution along the
pm − 21 ∆x and pm + 12 ∆x as follows: rod inside the wall. Please call your program
 rod.py and nothing else. Figure 1 shows what
∂T  Tm − Tm−1 the output of your program should look like: The
≈ temperature along the rod increases linearly from
∂x m−1/2
 ∆x
70◦ F inside the building to 100◦ F outside the
 building.
∂T  Tm+1 − Tm We need to decide two things to solve this prob-
≈
∂x m+1/2
 ∆x lem in Python: First, how should we represent

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 3

Figure 1 Correct temperatures along the rod. mathplotlib.pyplot over and over again we
abbreviate the imported module to a single capital
letter. For a larger program this convention of us-
ing a single capital letter may be confusing, but for
a rather short program we’ll be okay.
Finding the temperature of a segment inside the
rod requires that we average the temperatures of
its two neighboring segments. It’s important that
we average the two neighbors from the old temper-
ature distribution into a new temperature distribu-
tion. Otherwise we would average the values in-
consistently: one would be from the next step in
the simulation while the other would be from the
previous step. So we write a function that “runs
through” the current rod and computes a new tem-
perature distribution by averaging the relevant ele-
the temperature distribution of the rod? Second, ments of the old temperature distribution:
how should we perform the “repeated averaging” d e f distribute ( old ) :
of temperatures along the rod? new = old [ : ] # makes a copy
The temperature at any given point in the rod is a f o r i i n r a n g e ( 1 , LENGTH + 1 ) :
new [ i ] = ( old [ i − 1 ] + old [ i +←-
floating point number. Therefore the distribution of 1]) / 2
temperatures along the rod is a sequence of float- r e t u r n new
ing point numbers. The first and last temperatures
in this sequence are special because they represent Note that we only recompute the temperatures in-
the fixed temperatures inside and outside the build- side the rod, the boundary conditions never change.
ing.1 If we divide the rod itself into 100 equal-sized Clearly if we only call the distribute function once,
segments, the total length of our sequence is 102 only the temperatures at the ends of the rod will
elements including the fixed endpoints. So we can change. If we keep averaging, this process will
represent the rod with a vector of floats. The initial “grow” successive approximations to the final tem-
temperature of “unknown” interior segments could perature distribution from those endpoints toward
be set to anything, so let’s set those to 0.0 to be- the center of the rod.
gin with. Here is a first version of the program But when do we stop the computation? After
that simply sets up the initial temperature distribu- distributing the temperatures across the rod again
tion along the rod and plots it using pyplot from the and again, we will eventually reach a “steady state”
matplotlib library: in which none of the temperatures change signif-
i m p o r t matplotlib . pyplot as P
icantly anymore. So ideally we’d simply check
if the temperature distribution before averaging is
LENGTH = 100 equal to the temperature distribution after averag-
ing. However, since our temperatures are floats we
d e f main ( ) : cannot compare for “exact” equality. Instead we
current = [ 0 . 0 ] ∗ ( LENGTH + 2 )
have to figure out if two floating point values are
current [ 0 ] = 7 0 . 0
current[ −1] = 1 0 0 . 0 “close enough” so we can consider them “equiva-
lent” as far as our simulation is concerned. Let’s
P . plot ( current ) write a function that performs this “approximate
P . xlabel ( ” s e g m e n t ” ) equality check” given a bound  (epsilon); we’ll
P . ylabel ( ” t e m p e r a t u r e ” ) use the absolute error version here (for other ap-
P . show ( )
plications the relative error version may be more
main ( ) appropriate):

Note the new form of import we’ve used here. 1. In the language of partial differential equations, these
Since it would be rather tedious to keep writing two temperatures are our boundary conditions.

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 4

d e f floats_equiv ( a , b , epsilon ) : Figure 2 Incorrect temperatures,  too large.

’’’
R e t u r n T r u e i f two f l o a t i n g p o i n t
v a l u e s a and b a r e w i t h i n some
e p s i l o n d i f f e r e n c e , F a l s e ←-
otherwise .
’’’
r e t u r n a b s ( a − b ) <= epsilon

So we consider two floats “equivalent” if they don’t

differ by more than . Note that you must add
doctests to this function!
Now we can write a function that compares two
temperature distributions in the same way and re-
turns True if they are “equivalent” for our pur-
poses:
d e f lists_equiv ( a , b , epsilon ) :
assert l e n ( a ) == l e n ( b )
for i in range ( len (a) ) :
0.1, 0.01, 0.001, . . . ) and find one that actually pro-
i f n o t floats_equiv ( a [ i ] , b [ i←- duces the correct result from Figure 1. For refer-
] , epsilon ) : ence, Figure 2 shows what the wrong output for an
r e t u r n False  that’s too large looks like.
r e t u r n True Challenge: Imagine that the rod touches a pipe
Note how we extended the definition of “equiva- with a temperature of 40◦ F at a single segment in
lent” for two floating point values to a sequence: the middle of the brick wall. How hard is it to
two sequences are “equivalent” if all their corre- modify our existing program to compute the cor-
sponding values are “equivalent.” Make sure you rect temperature distribution for this new problem?
add a docstring with doctests to this function also. Can you think of a way to reorganize the program
We can now rewrite the main program to per- that would have made this change easier? Can you
form the appropriate number of averaging steps: think of a way to generalize the program to the
point where any number of boundary conditions
d e f main ( ) : for a one-dimensional heat transfer problem could
current = [ 0 . 0 ] ∗ ( LENGTH + 2 )
current [ 0 ] = 7 0 . 0
be handled by the same exact program? You can ei-
current[ −1] = 1 0 0 . 0 ther discuss these issues in a README file (make
sure to include it in your zip), or write and sub-
after = distribute ( current ) mit a more general version of the solution called
w h i l e n o t lists_equiv ( after , ←- rod2.py. Just make sure that no matter what,
current , EPSILON ) :
you submit the original rod.py solution without
current = after # t h i s i s n o t ←-
a copy , b u t a r e l a b e l l i n g enhancements.
after = distribute ( current )

P . plot ( current )
P . xlabel ( ” s e g m e n t ” )
2 Metal Plate [22 points]
P . ylabel ( ” t e m p e r a t u r e ” )
P . show ( ) Imagine a metal plate of negligible thickness that
we apply heat sources or cooling agents to. Fig-
Starting from the initial temperature distribution, ure 3 shows what happens to a plate that started
we keep averaging until two consecutive distribu- out at 25◦ C when we apply a single heat source of
tions are close enough. Once we reach that “steady 100◦ C: Eventually the entire plate will have a tem-
state” we plot the final temperature distribution. perature of 100◦ C. Figure 4 shows a slightly more
Done! interesting scenario: If the plate is surrounded by
Except for one thing: We never actually a cooling agent that keeps the edges at 25◦ C, then
said what  should be for this simulation! only a relatively small part of the plate will actu-
Play with different values for  (for example ally get warm. Figures 5 and 6 illustrate how heat

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 5

Figure 3 One heat source, no boundary conditions. Figure 6 One heat source, one boundary cooled.

Figure 4 One heat source, all boundaries cooled. Figure 7 Sample input to the plate.py program.
10
CCCCCCCCCC
.........C
.........C
.........C
.........C
.........C
.........C
..H......C
.........C
.........C

For this problem you will write a program that

computes the “steady state” temperature distribu-
tion of a square metal plate to which a number of
from our heat source spreads through the plate if
heat sources and cooling agents are being applied.
two boundaries or only one boundary are cooled to
Please call your program plate.py and nothing
25◦ C.
else.
Figure 5 One heat source, two boundaries cooled. The input for your program will be a text file
plate.txt of the form illustrated in Figure 7.
The first line of the text file will give the size of the
plate, so in the case of Figure 7 we are dealing with
a 10-by-10 plate.2 This is followed by lines de-
scribing the boundary conditions: For a 10-by-10
plate there must be 10 lines of 10 characters each.
A capital “C” stands for a “cooling agent” which
has a temperature of 25◦ C whereas a capital “H”
stands for a “heat source” which has a temperature
of 100◦ C. Cells marked as heat sources or cool-
ing agents are “fixed” once and for all, just like the
boundary conditions for the metal rod were. A pe-
2. The size is given as the number of “cells” on each axis;
each “cell” is comparable to a “segment” of the metal rod
from the previous problem.

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 6

riod “.” simply means that the temperature of that >>> new_matrix(3, 1, False)
cell is not fixed but computed as part of the simu- [[False], [False], [False]]
lation; it’s probably easiest if you set those cells to >>> numRows([[1], [2]])
2
0◦ C initially. >>> numCols([[1], [2]])
Conceptually the program you need to write for 1
this problem is very similar to the one we wrote
for the metal rod before: Once again you’ll have to You can reuse floats_equiv(a, b) from
set up a representation for the temperature distribu- the previous problem, but you’ll have to write
tion, once again you’ll have to average that distri- a new matrices_equiv(a, b) function for
bution repeatedly until you reach a “steady state,” this one.
and once again you’ll plot the final temperature One matrix for the temperature distribution is
distribution. Nevertheless, the program for metal not enough however. You’ll also have to somehow
plates is significantly more complicated, so think- keep track of which positions in your matrix are
ing things through ahead of time is a very good fixed by boundary conditions and which positions
idea. are free in the sense that you need to compute their
Let’s talk about the representation of the temper- temperature. We suggest that you use two matri-
ature distribution first. Obviously you cannot use ces. The first one (called current in the sam-
a one-dimensional representation anymore, instead ple listing below) is a matrix of floating point val-
you’ll have to use a matrix—i.e. a list of nested ues and contains the temperatures in each “cell”
lists—that you can index with a row and a col- of the metal plate we’re simulating; this includes
umn. We have written some code for matrices be- the temperatures for boundary conditions as well.
fore, and if you have it in your notes or download The second one (called fixed in the sample list-
it from the course schedule, you can put it to good ing below) is a matrix of boolean values, True and
use here. Your choices for using it are to cut and False; an entry in this matrix is True if it’s tem-
paste the necessary functions into this program file, perature is specified by a boundary condition and
or to put our matrices.py module in the same folder therefore fixed; an entry in this matrix is False if
as these programs and import it into your plate.py the corresponding temperature cell is one you have
program. If you do it the second way, make sure to compute.
that you include matrices.py in your submission With this in mind, here is a possible main pro-
zip! gram that illustrates how closely related the “big
You’ll definitely need a function to create a new picture” of the metal rod and the metal plate are:
matrix of a given size as it would be tedious to re- d e f main ( ) :
peat the code for that every time you need a new current , fixed = read_config ( ”←-
matrix. A function like plate . txt ”)

new matrix(rows, columns, value) after = distribute ( current , fixed )

w h i l e n o t matrices_equiv ( after , ←-
that returns a new matrix with the given number of current ) :
rows and columns—and with each cell initialized current = after
after = distribute ( current , ←-
to the given value—seems about right. When you
fixed )
pass a matrix to another function, that function will
also have to be able to find out how many rows and P . imshow ( current , origin=” u p p e r ” )
columns the matrix has. So two more functions like P . axis ( ” o f f ” )
P . tight_layout ( )
numRows(matrix) P . colorbar ( ticks= r a n g e ( 0 , 1 2 6 , 2 5 ) ←-
numCols(matrix) ) . set_label ( ” t e m p e r a t u r e ” )
P . show ( )
that return the number of rows or columns of the
given matrix are probably a good idea as well. We’re plotting the results differently now because
Consider these examples: we have to display two-dimensional data using
imshow; the axis and tight layout func-
>>> new_matrix(2, 2, 0.0) tions simply reduce the “wasted space” around the
[[0.0, 0.0], [0.0, 0.0]] image, and the colorbar function creates the bar

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 7

on the right side that explains which color corre- 3 NumPy Heat Transfer [18
sponds to which temperature.
points]
The new distribute function needs both the
temperature distribution current and the ma- For this problem you’ll re-write the program for
trix fixed telling it which cells are “not to be the heat-plate simulation, but this time using the
touched” as it were. So when you’re about to com- N UM P Y library for scientific computations. That
pute the average for a given cell, you check first is, your new program should produce the exact
if that cell is a boundary condition; if so, you skip same results as the previous program (as far as pos-
it; otherwise you actually compute its new aver- sible with floating point numbers), but it should
age. Computing the average for a given cell re- be faster because N UM P Y allows you to move
quires that you get the temperatures of the 2–4 many computations from P YTHON down closer
neighboring cells (north, south, east and west); this to the machine itself. Please call your program
is more complicated than in the case of the metal plateFast.py, nothing else.
rod, and you probably don’t want to do it in the The last step of the program to draw the resulting
distribute function itself; instead you should steady-state heat distribution using matplotlib
write a helper function neighbors that returns a will be exactly the same in this version of the pro-
list with 2–4 temperatures depending on the posi- gram. The part of the program that sets up the tem-
tion you pass in (think about “cells” at the “edge” perature and fixed matrices from an input file will
of the plate). be enhanced to create a third matrix necessary to
What’s left is the read config function perform the revised computation as described be-
which has to read the data file and create both of low. Also, the function to determine if two matri-
the matrices. After opening the file you should read ces are equivalent should be rewritten to take ad-
a single line first to find out how big you need to vantage of N UM P Y’s fast operations.
make your matrices and to know how many more However, the main difference will be in the part
lines to expect: of the program that repeatedly averages the tem-
peratures around each cell to compute the new tem-
perature of a cell using something like this equa-
data = open(name) tion:
line = data.readline() 1
Ti,j = (Ti−1,j + Ti+1,j + Ti,j−1 + Ti,j+1 )
size = int(line) 4
... At the edges and corners of the plate where we have
only 2 or 3 neighbors instead of 4, the formula is
adjusted accordingly. This is the part we’ll tackle
After that step you just read line-by-line as we’ve rewriting first.
always done it; for each line, you have to go This part of the program takes the most time:
through the characters on that line and initialize in- We repeatedly “run across” the rows and columns
dividual elements of your matrices as appropriate. of the plate to produce new values for all com-
Add any other helpful functions you may think of puted cells, and all of the computation is carried
to simplify the coding in this one. Note that the out “cell-by-cell.” So only the actual arithmetic is
way we’ve written and used this function, it returns performed directly by the machine (fast on aver-
a tuple of both matrices! age), most of the remaining code (loops, access of
Lastly, update main() so that it prompts the user matrix elements) is performed by P YTHON (slow
for the name of the input file. That way you can on average). Therefore this is the part where we
easily run your program with many different plate can improve performance the most if we are able
configurations. We’ve created a starter file for you to express our solution in terms of matrix opera-
to use, plateStart.py, which has the skeleton tions provided by N UM P Y: each of those opera-
of each method described here, along with some tions is fast (on average) and deals with all cells of
documentation and a few of the harder new state- the matrix on the machine level without involving
ments as well. Don’t forget docstrings, doctests P YTHON again.
and pep8 style for all parts of your finished pro- We need to rethink the way we perform averag-
gram! ing to get away from the idea of doing it “cell-by-

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 8

cell”, a relatively slow sequential approach. In- Figure 8 The numpy.roll function in action.
stead of dealing with a single cell and it’s neigh- >>> a
array([[1, 2, 3],
bors, we want to deal with all cells at the same
[4, 5, 6],
time, a faster parallel processing approach. Obvi- [7, 8, 9]])
ously we have to still worry about the edges and >>> numpy.roll(a, 1, 0)
corners of the plate where the averaging computa- array([[7, 8, 9],
tion needs to proceed differently than in the center, [1, 2, 3],
but let’s focus on the center first. [4, 5, 6]])
>>> numpy.roll(a, -1, 0)
If you consider a cell (i, j) for which we want array([[4, 5, 6],
to compute a new temperature, we first need to [7, 8, 9],
sum up the temperatures of the cells around it: [1, 2, 3]])
(i − 1, j), (i + 1, j), (i, j − 1), (i, j + 1). The key in- >>> numpy.roll(a, 1, 1)
sight is to realize that instead of looking at the left array([[3, 1, 2],
[6, 4, 5],
(i, j − 1) neighbor, we could simply “shift the ma-
[9, 7, 8]])
trix” one column to the right and use the cell (i, j) >>> numpy.roll(a, -1, 1)
of the shifted matrix. Of course the same is true array([[2, 3, 1],
for the other neighbors: Each of which can equally [5, 6, 4],
well be found at position (i, j) in some appropri- [8, 9, 7]])
ately shifted matrix. As soon as we “line up” the
elements correctly, we can use N UM P Y’s element-
wise whole matrix addition operation to express the trix elements around. Once we roll, we need to
averaging step as follows: zero out the new row or column, and we can use
N UM P Y’s convenient array slicing operations for
1 
N = ↑ O+↓ O+← O+→ O that. Here is one of the resulting functions - it’s up
4
to you to write the other three.
Here N is the “new” matrix of (averaged) tem- d e f up ( matrix ) :
peratures while O is the “old” matrix of temper- ” ” ” Move m a t r i x up one row . ” ” ”
new = N . roll ( matrix , −1, 0 )
atures. Obviously this is not yet correct for edges
new[ −1 , : ] = 0
and corners: First we should only add 2 or 3 cells r e t u r n new
there instead of 4, second we should divide by 2 or
3 instead of 4 to get the correct average. d e f down ( matrix ) :
Let’s focus on how we would shift the ma- ” ” ” Move m a t r i x down one row . ” ” ”
trix first; luckily N UM P Y provides a function pass
roll that works as demonstrated in Figure 8:
d e f left ( matrix ) :
We can “shift” a matrix by a certain number ” ” ” Move m a t r i x l e f t one column . ” ” ”
of elements along a certain axis; for example, pass
numpy.roll(a, 1, 0) shifts all rows down
by one. In general, for a multi-dimensional array, d e f right ( matrix ) :
the roll function takes an array as the first parame- ” ” ” Move m a t r i x r i g h t one column . ←-
”””
ter, the shift amount as the second parameter, and pass
the dimension or axis along which to shift as the
third parameter. In the first example, note that the Using these functions, we can shift our matrix
row “shifted out” at the bottom re-enters the matrix appropriately and add the shifted matrices together
at the top. to compute the sums we need in each new cell: for
That last aspect is what makes roll not quite cells in the center of the matrix, the four shifted
suitable for us: The only way to “ignore” a neigh- matrices will have the correct neighbors at position
bor when averaging (as we need to along the edges) (i, j); for cells on the edges of the matrix, three
is to fill in a row or column of zeros instead! The of the four shifted matrices will have the correct
functions you need to shift the temperature matrix neighbors while one will have a zero; for cells in
for averaging will have to do that, but we can still the corners of the matrix, two of the four shifted
use roll to do the expensive part of moving ma- matrices will have the correct neighbors while two

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 9

Figure 9 The numpy.where function in action. ready used such a matrix to keep track of where
>>> a the boundary conditions are, but again you had to
array([[False, True, True],
process it one element at a time; now we can use
[ True, False, True],
[ True, True, False]], dtype=bool) N UM P Y to distinguish between boundary condi-
>>> b tions and computed cells in one go. So provided
array([[ 4., 4., 4.], we have three matrices, one with the current tem-
[ 4., 4., 4.], peratures (old), one with the boundary conditions
[ 4., 4., 4.]]) marked by True (clamped), and one with the ap-
>>> c
array([[ 0., 0., 0.],
propriate divisors (divs), our averaging step now
[ 0., 0., 0.], reads as follows:
[ 0., 0., 0.]]) d e f average ( old , clamped , divs ) :
>>> where(a, b, c) sums = up ( old ) + down ( old ) + left ( ←-
array([[ 0., 4., 4.], old ) + right ( old )
[ 4., 0., 4.], averages = sums / divs
[ 4., 4., 0.]]) new = N . where ( clamped , old , ←-
averages )
r e t u r n new

will have zeros. However, to compute the averages That was simple, wasn’t it? No more neigh-
we still have to divide by the appropriate number bors to find, no more values to add up and average,
of neighbors. Luckily N UM P Y allows us to per- it’s all taken care of by N UM P Y. The rest of the
form element-wise division of a matrix, so if we program is mostly concerned with input and out-
set up a corresponding divisors matrix of the same put just like before. However, you must use the
size as the temperature matrics, with values 2 in the N UM P Y zeros function to create the initial matri-
corners, 3 on the edges, and 4 everywhere else, we ces. A N UM P Y matrix is not the same data type as
can divide the matrix of sums by the divisors ma- a nested list - so all our fast operations and revised
trix to compute the proper averages. Building this functions will only work if we consistently use the
matrix is pretty straightfoward, using the functions same data type throughout the program. Lastly,
we’ve already built: we will also compare matrices using N UM P Y of
d e f make_divisor ( size ) : course. This can be done very compactly with ma-
base = N . ones ( ( size , size ) ) trix subtraction and the min and max functions, as
div = up ( base ) + down ( base ) + left←- shown in the listing below.
( base ) + right ( base )
r e t u r n div i m p o r t matplotlib . pyplot as P
i m p o r t numpy as N
Note that you don’t want to use the old cell-by-cell
method of initializing a matrix so that you have the EPSILON = 0 . 0 0 0 1
HOT = 1 0 0 . 0
most speed-up possible. COLD = 2 5 . 0
There’s one more thing to take care of though:
Our approach of averaging the entire matrix also ...
computes results for positions that should not be
changed because they are boundary conditions! In d e f matrices_close_enough ( a , b ) :
d = a − b
other words, once we are done computing the av-
r e t u r n max ( a b s ( d . min ( ) ) , a b s ( d . max←-
erages, we want to write only those into the re- ( ) ) ) <= EPSILON
sult matrix that were not already fixed in the initial
problem. This is where N UM P Y’s where func- Let’s not forget the reason we did all this: so
tion comes in handy, see Figure 9: We can select our program would run faster! You’ll need to use
between the elements of two matrices based on a a pretty large input file in order to see a notice-
third bool matrix; if, for example, all elements able difference between the original plate.py solu-
of cond are True, then numpy.where(cond, tion and the new plateFast.py solution. For an extra
a, b) is just going to be the matrix a; if they are challenge, write a program to randomly create arbi-
all false, it’s going to be the matrix b instead. trarily large input files that simulate CPU cooling.
In the solution to part two you should have al- Submission Summary: Remember to include

600.112: IPSE Summer 2015

Assignment 6: Heat Transfer Page 10

all the following files in your final submission zip:

program files rod.py, plate.py, plateFast.py and in-
put file plate.txt for testing the plate programs.
Lastly, include our lecture matrix module matri-
ces.py if you import it to use in any of your pro-
grams, as well as any other modules you create and
import to avoid cutting and pasting of functions
into multiple programs. Also remember to make
all your .py files pep8 compliant, and include doc-
strings and doctests for all functions (except where
random data is used since the outcome can’t be pre-
dicted).

600.112: IPSE Summer 2015