5. Surface Temperatures

Transcription

1 5. Surface Temperatures For this case we are given a thin rectangular sheet of metal, whose temperature we can conveniently measure at any points along its four edges. If the edge temperatures are held steady, then temperatures within the sheet will settle down to a steady state. We want to determine those steady-state interior temperatures, without having to undertake the difficult job of physically measuring temperatures away from the edges. To make this problem tractable, we can impose an imaginary square grid on the rectangular sheet, and can then focus on estimating the temperatures at the grid points. Suppose that we let t ij represent the known temperature or x ij the unknown temperature at the grid point in the ith row and jth column of the grid. For example, in a grid of 1 1 meter squares on a 3 5 meter sheet, the known temperatures at grid points on the edges would be as follows: t 12 t 13 t 14 t 15 t 21 t 26 t 31 t 36 t 42 t 43 t 44 t 45 The unknown temperatures x ij at the grid points in the interior would be these: x 22 x 23 x 24 x 25 x 32 x 33 x 34 x 35 In general, for an m n meter sheet, there will be 2(m 1) + 2(n 1) known temperatures, and (m 1)(n 1) unknown temperatures. A computational scheme for estimating the interior temperatures can be based on the following very simple observation: Averaging rule: The temperature at any interior grid point is approximately the average of the temperatures at the four other nearest grid points. For example, the temperatures at the 4 grid points nearest to x 34 are x 33, x 24, x 35,andt 44. Since the average of 4 temperatures is 1 / 4 their sum, the averaging rule states that x 34 1 / 4 x / 4 x / 4 x / 4 t

2 This is only an estimate, but we can treat it as an equality in order to get an approximation to the temperatures at the interior grid points. We then have a linear equation corresponding to each interior point: x 22 = 1 / 4 t / 4 t / 4 x / 4 x 32 x 32 = 1 / 4 t / 4 x / 4 x / 4 t 42 x 23 = 1 / 4 x / 4 t / 4 x / 4 x 33 x 33 = 1 / 4 x / 4 x / 4 x / 4 t 43 x 24 = 1 / 4 x / 4 t / 4 x / 4 x 34 x 34 = 1 / 4 x / 4 x / 4 x / 4 t 44 x 25 = 1 / 4 x / 4 t / 4 t / 4 x 35 x 35 = 1 / 4 x / 4 x / 4 t / 4 t 45 Altogether, we have 8 equations in 8 variables. We ll first investigate the direct solution of these equations by elimination. Then we ll look at a different, iterative approach to the solution. Direct solution. Sorting out the variables from the constants in the expressions above, we arrive at the following matrix form for our equations: x / 1 4 / x 22 t 12 + t 21 x 32 1 / / x 32 t 42 + t 31 x 23 1 / / 1 4 / x 23 t 13 x 33 0 = 1 / 1 4 / / x 33 x / / / 4 0 x 24 1 t 43 / 4. t 14 x / 1 4 / / 4 x 34 t 44 x / / 4 x 25 t 15 + t 26 x / 1 4 / 4 0 x 35 t 45 + t 36 Calling the vector of variables x, the matrix A, and the vector of constants b, we can describe this system more concisely as x = Ax + b, or in standard equation form with all the variables on the left, as (I A)x = b. (Recall that I is the identity matrix, so that Ix is the same as x.) Given any particular boundary temperatures, it is straightforward (if a bit tedious) to set up and solve the equations in Matlab. As an example, if the boundary temperatures are 36

3 then the interior temperatures may be calculated in Matlab as follows: >> A = [ ; ; ; ; ; ; ; ]; >> b = 0.25 * [- 3-4; - 3-4; - 1; + 1; + 2; + 4; ; ]; >> x = (eye(8) - A) \ b; >> reshape (x, [2 4]) ans = The reshape function is used at the end to display the column vector of 8 variables in a 2 4 table, such that each row (or column) of result values corresponds to a row (or column) of interior grid points. The temperature is for the point in the first interior row and third interior column of the grid, for example, which is x 24. More grid points would give a better approximation, but you can see that a manual approach to entering the matrix and boundary temperatures will become too tedious and error-prone as the grid is refined. To carry out the approximation on a practical scale, we ll need to write a program that sets up the equations automatically for a specified grid size. Such a program is possible because our averaging rules produce equations that are all very similar in structure. This similarity carries over into a very regular structure for the equations coefficient matrix. 37

4 In the case of our 3 5 grid, the pattern of the nonzero elements in our matrix A is easy to see. The diagonals immediately above and below the main diagonal have an entry of 1 / 4 in every other position. The diagonals immediately above and below those are filled with entries of 1 / 4. All other entries are zeros. There s also a pattern to the placement of the edge temperatures into the constant term b of our equation system. The left and right edge temperatures go into the constants of the first and last two equations, respectively. The top and bottom edge temperatures appear in the constants of the odd-numbered and even-numbered equations. Given this information, we can proceed to write an M-file grid.m that does all the setup work for the temperature problem. It takes as arguments four arrays of temperatures along the four edges, and returns the appropriate matrix A and vector b: function [A,b] = grid (Tlft, Trgt, Ttop, Tbot) for i = 1:2:7 A(i+1,i) =.25; A(i,i+1) =.25; for i = 1:6 A(i+2,i) =.25; A(i,i+2) =.25; for i = 1:2 b(i,1) =.25 * Tlft(i); b(i+6,1) =.25 * Trgt(i); for i = 1:4 b(2*i-1,1) = b(2*i-1,1) +.25 * Ttop(i); b(2*i,1) = b(2*i,1) +.25 * Tbot(i); The first two for loops generate the two diagonal patterns of.25 entries in A, and then two more for loops build up the vector b. For the edge temperatures in our example, the grid function can be applied directly to the appropriate arrays, after which the solution x is determined from A and b as before: >> [A,b] = grid ([-4-4], [8 7], [ ], [ ]); >> x = (eye(8) - A) \ b; >> reshape (x, [2 4]) ans = An extension of grid to the 3 n case is easily made. The patterns are the same, only longer, so it sufficient to generalize the loop arrays (like 1:2:7 and 1:6) and a few other numbers that refer specifically to the 3 5 example. The 38

5 same M-function can handle n 3 grids, by simply exchanging the left/right edge temperatures with the top/bottom ones in the arguments. The general m n case is somewhat harder, but there are still only 5 non-zero diagonals in the coefficient matrix. Iterative solution. A different, iterative method of solving these equations is motivated by the physical process of temperature diffusion in the metal plate. We imagine that the edge temperatures are at their fixed values, but that the interior temperatures are initially at some values x (0) that have not yet reached their steady state. The diffusion of heat then causes the interior temperatures to start changing. As a rough approximation, we can say that, after some small step of time, the temperature of each interior point is adjusted according to our averaging rule: it becomes the average of the temperatures at the point s four nearest neighbors. Because we are using the same averaging rule, we have the same matrix expression for the new temperatures, x (1), in terms of the initial ones: x (1) = Ax (0) + b. After another small step of time, the heat diffuses some more, and we use the same rule to estimate the further interior temperature change as x (2) = Ax (1) + b. Subsequent steps lead to temperatures x (3) = Ax (2) + b, x (4) = Ax (3) + b, and so forth. In general, the formula for an iteration of temperature change is x (k+1) = Ax (k) + b, k = 1, 2, 3,... The iterations could go on indefinitely, but if the temperatures behave as we intuitively expect, then they will eventually settle down to their steady-state values. As a practical matter, we stop when x (k+1) appears to equal x (k) to the accuracy we desire. Then, writing x for either of the last, equal iterates, we have approximately x = Ax + b, which is the system we wanted to solve. A simple M-file griditer1.m suffices to carry out these iterations. After calling grid.m to set up A and b, and initializing x to a vector of all zeroes (for lack of a better choice), the temperature is re-iterated and displayed a fixed number of times: function x = griditer1 (A, b); x = [0; 0; 0; 0; 0; 0; 0; 0]; for step= 1:50 x = A * x + b; fprintf ( %3d\n, step); disp (reshape(x,2,4)); The first several iterations look like this, 39

6 >> [A,b] = grid ([-4-4], [8 7], [ ], [ ]); >> x = griditer1 (A, b); and here are some later ones: To the four decimal places shown here, there are no changes after iteration 28, at which point we have the same solution as before. It might occur to an engineer that one need not take the trouble of generating A and b just to carry out such a simple series of iterations. A simplified M-file griditer2.m could take as input a 4 6 matrix G of grid points both edge and interior that have been set to their initial temperatures. It could then perform the iterations directly to modify the values of the interior grid points, using the simple averaging rule explicitly: function G = griditer2 (G); for step= 1:50 for j = 2:5 for i = 2:3 G(i,j) =.25 * (G(i,j-1) + G(i-1,j) + G(i,j+1) + G(i+1,j)); fprintf ( %3d\n, step); disp (G(2:3,2:5)); 40

7 Then all that s necessary is to initialize G and run the M-file on it. several iterations are as follows: The first >> G(1:4,1:6) = 0; >> G(2:3,1) = [-4; -4]; >> G(2:3,6) = [ 8; 7]; >> G(1,2:5) = [ ]; >> G(4,2:5) = [ ]; >> G = griditer2 (G); Comparing with the previous version, we see that the iterates of the interior temperatures start off quite differently! They do eventually converge to the same values as before, however: The number of iterations to convergence is seen to drop to 16, however, in comparison to the 28 we saw before. How can two implementations of the same iterative scheme yield such different results? The explanation must be that they re not computing the iterates in precisely the same way. A perceptive engineer would notice that, in griditer1.m, we ask Matlab to compute the whole vector A*x+bfrom x and then to assign the whole result back to x. Ingriditer2.m, however, new values of G(i,j) are used immediately in the computations for other grid points 41

8 during the same iteration. The new value of G(2,2), for example, is used immediately in the next pass through the innermost loop as part of the computation of G(2,3). The mixing of new and old values in the same iteration seems like a mistake, yet it clearly speeds up computation of the solution in our particular example. Further experiments would show, moreover, that the mistaken implementation is quite consistently reliable and faster in the speed with which the interior temperatures approach their steady-state values. In fact, it is simply a special case of an alternative iterative solution method whose reliability and speed have been proven mathematically. Other ideas have been found to speed the convergence even more. As a result, the iterative approach is attractive for solving large systems of very simple or regular equations. 42