Week 5.1 - Mid term project - Solving the steady and unsteady 2D heat conduction problem

1. Problem Description:
• We have a 2D rectangular region (let’s call it a slab) with specific boundary conditions.
• The boundary temperatures are as follows:
• Top Boundary: 600 K
• Bottom Boundary: 900 K
• Left Boundary: 400 K
• Right Boundary: 800 K
2. Finite-Difference Method:
• We’ll use the finite-difference method to approximate the solution.
• The idea is to discretize the region into a grid of nodes and calculate temperatures at these nodes.
3. Iterative Techniques: We’ll implement the following point iterative methods for solving the implicit equations:

a. Jacobi Method:

• Update each node’s temperature based on the average of its neighboring nodes.
• Repeat until convergence.

b. Gauss-Seidel Method:

• Update each node’s temperature using the most recently calculated values of its neighbors.
• This method converges faster than Jacobi.
• Iterations continue until convergence.

c. Successive Over-Relaxation (SOR):

• A modification of Gauss-Seidel that accelerates convergence.
• Introduces a relaxation factor (usually denoted by ω).
• Update each node’s temperature using a weighted average of its neighbors.
• The formula for updating a node’s temperature is: [ T_{m,n}^{(k+1)} = (1 - \omega)T_{m,n}^{(k)} + \frac{\omega}{4} \left( T_{m+1,n}^{(k+1)} + T_{m-1,n}^{(k)} + T_{m,n+1}^{(k+1)} + T_{m,n-1}^{(k)} \right) ]
• Adjust the value of ω to optimize convergence.
3. Absolute Error Criteria:
• We’ll stop iterating when the absolute error (difference between successive iterations) falls below 1e-4.
4. Heat Transfer Calculation:
• Once we have the temperature field, we can use Fourier’s Law to determine the heat transfer within the medium.

Remember that this numerical approach provides an approximate solution, but we can make the error very small by refining the mesh

Solving 2D heat conduction equation of steady state :

since, the temperature doesn't change with time the above equation reduces to

as we don't know value sat some nodes like T( i+1) and T(j+1) we take guess values and we get a set of coupled equations and are to be solved at once ,as when there

are guess values we use iterative solvers and those values converge under solver and we get a converged solution.we will say that our solution is converged when new iteration values and old values are same.

Here we use three type of iterative solvers ,

1) Jacobian Iterative Solver :

In jacobi method , each iteration is done using a set of previous values, even if new values are available in the middle of an iteration.Like when you are solving for n+1 iteration and for i th node you will use values of previous(n) iteration even if you have the updated values of the nodes in current iteration.so this method is called method of simultaneous displacements.

The 2D steady state heat conduction equation for this method is

2) Gauss-Seidel iterative solver :

In Gauss-Seidel, as soon as you find a new value in the current iteration you will use it for finding other values in the current iteration.

Like when you are solving for n+1 iteration and for i th node you will use all the available values upto i-1 node of current iteration(n+1) and use i+1 node values and above values of previous iteration(n).SO we get more converged values.so this method is called method of spontaneous displacements.

The 2D steady state heat conduction equation for this method is

Successive Over-Relaxation( SOR) method :

It is a variant of the Gauss-Seidel method for solving a linear system of equations, resulting in faster convergence.You can also use jacobi method .Here an extra term called relaxation factor (omega)is multiplied to gauss seidel generated term to scale the convergence rate and solve the equation faster.To calculate new value we take old value and take a parameter omega and take rate of change.

The 2D steady state heat conduction equation for this method is

for scaling jacobian method,where Tj is the result of jacobian method

when omega = 0 we get new value is equal to old value which gives wrong result.

when omega goes from 0 to 1 we are switching from no update to an update using gauss siedal or jacobi method.

when omega >1 then we are taking the update from gauss siedal method and scaling up the convergence rate. The value we give is called over relaxition factor.

when omega <1 ,The value we give is called under relaxition factor.This is used when the solution given by gauss siedel is over relaxed we give omega value less than 1 to get the converged solution.

Input Variable:

Nodes: we are going to take no. of nodes in X-direction,nx and in Y-direction,ny=20

In the above three plot results you can see that the number of iterations and the computation time for jacobi iteration method is high i.e,826 iterations and 189.158 seconds time and then it is for gauss seidel method with 442 iterations and 101.2 seconds time and then for SOR.On addition of over relaxation factor to the gauss seidel method i.e, SOR method you can see that the solution is calculated in just 59 iterations and 14.3 seconds time.The SOR method depends on relaxation factor and the solution is optimum with less number of iterations and computational time when the omega value is 1.72 and the value above or below this the number iterations gets increased and when the value is above 1.99 the solution is getting blow up.so the maximum value of omega must be less than 2.you can see the blown up result if it is given greater than 2 in the below image.

Input Variable:

Nodes: we are going to take no. of nodes in X-direction,nx and in Y-direction,ny=20

Length of the domain: This is taken as 1 along x-axis and y-axis.

Given, Tolerance assumed to be 1e-4.

And we also assumed error as 999 .we can assume any value but it must be greater than the required tolerance.

By taking these as inputs we create a function for each solver and use those function in the main program and solve the 2D steady state equation on a square domain.

Main Program:

clear all

As it is of explict form it easy to solve these equations as we use previous time step values which are already known . we solve these equations directly by keeping it in the time loop and space loop.

rom the above plots you can conclude that explicit method takes less time to execute but when it comes to stability it mainly depend on CFL condition if this condition is not satisfied the solution gets blow up.Where as in the implicit methods jacobian method gives the solution in 7970 iterations where as gauss method takes 6629 iterations but using SOR method you get the solution in 5098 iterations but the computational tine high for SOR and then jacobian but for the gauss method is is faster than other two.Here in SOR method if you use omega value more or less than 1.06 you can see the iteration count increases when it crosses 1.9 then you see that the solution got blew up.so its value should be given less than 2.you can also observe that for any values of alpha dx and dt the solution will be stable, like explicit it is not dependent of CFL condition.