BlogFor BusinessTalk to a counsellor
CoursesIIT ProgramsPlacementsLog in
BlogFor Business
Talk to a counsellor
Challenge

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

VVijay Anand Rathnavel6 Dec 2021

Objective: To solve the steady and unsteady 2D heat conduction problem by using the point iterative techniques (Implicit and explicit).

For solving implicit equations use the follwoing methods:-

1. Jacobi

2. Gauss-seidel

3. Successive over-relaxation (SOR)

Inputs:

The Boundary conditions for the problem are as follows;

Top Boundary = 600 K

Bottom Boundary = 900 K

Left Boundary = 400 K

Right Boundary = 800 K

Absolute error criteria is 1e-4 (tolerance)

Assumptions:

Error = 9e9

alpha =0.3

Omega =1.1

Solution:

For steady state 2D heat conduction `(del^2 T)/(del x^2) + (del^2 T)/(del y^2) =0`

`Tunderset(P)`= Curent point`

`Tunderset(R)`= Point on the right`

`Tunderset(L)`= Point on the left`

`Tunderset(T)`= Point on the top`

`Tunderset(B)`= Point on the bottom`

`T underset(P)` `=1/K*(( Tl+Tr)/ (deltax^2) + ( Tl+Tb)/ (deltay^2))`

`K = 2*(deltax^2+deltay^2)/(deltax^2*deltay^2)`

For unsteady state or transient state 2D heat conduction`(del T)/(del t) = alpha *( (del^2 T)/(del x^2)+(del^2 T)/(del y^2) )`

`Tp overset(n+1)``= K*(Tp overset(n)``+ K1*(Tl+Tr) overset(n+1)``+ K2*(Tt+Tb) overset(n+1)``)`

where `K= 1/(1+2k1+2k2)`

`K1 = alpha* (deltat)/(deltax^2)`

`K2 = alpha* (deltat)/(deltay^2)`

if n --> Explicit solution

if n+1 --> Implicit solution

Matlab code:

Steady state 2D heat conduction (Implicit Method)

a) Jacobi Method

b) Gauss-Seidel Method

c) Sucessive Over Relaxation Method

% Code to solve steadystate 2D Heat conduction
% d^T/dx^2 + d^T/dy^2 = 0

clear all
close all
clc

% Defining nodes
nx=10;
ny=nx;

% Creating T matrix with inner nodes
T=300*ones(nx,ny);

%Assigning boundary conditions
T_L=400;
T_R=800;
T_T=600;
T_B=900;

T(1,:)=T_T;
T(:,1)=T_L;
T(:,end)=T_R;
T(end,:)=T_B;
T(1,1)=(T_L+T_T)/2;
T(1,end)=(T_T+T_R)/2;
T(end,1)=(T_L+T_B)/2;
T(end,end)=(T_B+T_R)/2;

% Creating copy of U
T_old=T;
x=linspace(0,1,nx);
y=linspace(0,1,ny);


% Inputs
error=9e9;
tol= 1e-4;
delta_x=x(2)-x(1);
delta_y=y(2)-y(1);
k= 2*(delta_x^2+delta_y^2)/(delta_x^2*delta_y^2);
omega=1.5; % Arrived based on iteration

for iterative_solver=1:3
    if iterative_solver==1 % Jacobi_Method
        [T] = jacobi_method(nx,ny,x,y,T,T_old,error,tol,delta_x,delta_y,k);
    elseif iterative_solver==2 % Gauss-Seidel_Method
        [T] = gauss_seidel_method(nx,ny,x,y,T,T_old,error,tol,delta_x,delta_y,k);
    elseif iterative_solver==3 % SOR_Method
        [T] = SOR_method(nx,ny,x,y,T,T_old,error,tol,delta_x,delta_y,k,omega);
    end
end




function [T] = jacobi_method(nx,ny,x,y,T,T_old,error,tol,delta_x,delta_y,k)

jacobi_iter=1;
while(error>tol)
    for i=2:nx-1
        for j=2:ny-1
            T(i,j)=(1/k)*((T_old(i-1,j)+T_old(i+1,j))/delta_x^2)...
                +(1/k)*((T_old(i,j-1)+T_old(i,j+1))/delta_y^2);
        end
    end
    error =max(max(abs(T_old-T)));
    T_old=T;
    jacobi_iter=jacobi_iter+1;
end

figure(1)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title_text = sprintf('Iteration Number = %d',jacobi_iter);
title(title_text,'(Steadystate) + Implicit with Jacobi Method')
pause(0.03)
end


function [T] = gauss_seidel_method(nx,ny,x,y,T,T_old,error,tol,delta_x,delta_y,k)

gs_iter=1;
while(error>tol)
    for i=2:nx-1
        for j=2:ny-1
            T(i,j)=(1/k)*((T(i-1,j)+T_old(i+1,j))/delta_x^2)...
                +(1/k)*((T(i,j-1)+T_old(i,j+1))/delta_y^2);
        end
    end
    error =max(max(abs(T_old-T)));
    T_old=T;
    gs_iter=gs_iter+1;

end
figure(2)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title_text = sprintf('Iteration Number = %d',gs_iter);
title(title_text,'(Steadystate) + Implicit with Gauss-Seidel Method')
pause(0.03)

end



function [T] = SOR_method(nx,ny,x,y,T,T_old,error,tol,delta_x,delta_y,k,omega)
SOR_iter=1;
while(error>tol)
    for i=2:nx-1
        for j=2:ny-1
            T(i,j)=(1-omega)*T_old(i,j)+omega*((1/k)*((T(i-1,j)+T_old(i+1,j))/delta_x^2)...
                +(1/k)*((T(i,j-1)+T_old(i,j+1))/delta_y^2));
        end
    end
    error =max(max(abs(T_old-T)));
    T_old=T;
    SOR_iter=SOR_iter+1;

end
figure(3)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title_text = sprintf('Iteration Number = %d',SOR_iter);
title(title_text,'(Steadystate) + Implicit with SOR Method')
pause(0.03)
end

Steady state 2D heat conduction (Explicit Method)

% Code to solve unsteadystate 2D Heat conduction Explicit
% dT/dt = alpha*(d^T/dx^2 + d^T/dy^2)

clear all
close all
clc

% Defining nodes
nx=10;
ny=nx;

% Defining time steps
t=14;
dt=0.01;
nt=t/dt;

% Creating T matrix with inner nodes
T=300*ones(nx,ny);

%Assigning boundary conditions
T_L=400;
T_R=800;
T_T=600;
T_B=900;

T(1,:)=T_T;
T(:,1)=T_L;
T(:,end)=T_R;
T(end,:)=T_B;
T(1,1)=(T_L+T_T)/2;
T(1,end)=(T_T+T_R)/2;
T(end,1)=(T_L+T_B)/2;
T(end,end)=(T_B+T_R)/2;

% Creating copy of U
T_old=T;
x=linspace(0,1,nx);
y=linspace(0,1,ny);


% Inputs
delta_x=x(2)-x(1);
delta_y=y(2)-y(1);
alpha=0.3;
k1= alpha*(dt/delta_x^2);
k2= alpha*(dt/delta_y^2);

for k=1:nt
    for i=2:nx-1
        for j=2:ny-1
            T(i,j)=T_old(i,j)+k1*(T_old(i-1,j)-2*T_old(i,j)+T_old(i+1,j))...
                +k2*(T_old(i,j-1)-2*T_old(i,j)+T_old(i,j+1));
        end
    end
    T_old=T;
end

figure(4)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title('(Unsteady/Transient) + Explict Method')
pause(0.03)

2) Implict Method:

a) Jacobi Method

b) Gauss-Seidel Method

c) Sucessive Over Relaxation Method

% Code to solve unsteadystate 2D Heat conduction Explicit
% dT/dt = alpha*(d^T/dx^2 + d^T/dy^2)


clear all
close all
clc

% Defining nodes
nx=10;
ny=nx;

% Defining time steps
t=14;
dt=0.01;
nt=t/dt;

% Creating T matrix with inner nodes
T=300*ones(nx,ny);

%Assigning boundary conditions
T_L=400;
T_R=800;
T_T=600;
T_B=900;

T(1,:)=T_T;
T(:,1)=T_L;
T(:,end)=T_R;
T(end,:)=T_B;
T(1,1)=(T_L+T_T)/2;
T(1,end)=(T_T+T_R)/2;
T(end,1)=(T_L+T_B)/2;
T(end,end)=(T_B+T_R)/2;

% Creating copy of U
T_old=T;
T_prev_dt=T;
x=linspace(0,1,nx);
y=linspace(0,1,ny);


% Inputs
% error=9e9;
tol= 1e-4;
delta_x=x(2)-x(1);
delta_y=y(2)-y(1);
alpha=1.2;
k1= alpha*(dt/(delta_x^2));
k2= alpha*(dt/(delta_y^2));

omega=1.3; % Arrived based on iteration
 
for iterative_solver=1:3
    if iterative_solver==1 % Jacobi_Method
        [T] = jacobi_method_unsteady_implicit(nt,nx,ny,x,y,T,T_old,T_prev_dt,tol,k1,k2);
    elseif iterative_solver==2 % Gauss-Seidel_Method
        [T] = gauss_seidel_method_unsteady_implicit(nt,nx,ny,x,y,T,T_old,T_prev_dt,tol,k1,k2);
    elseif iterative_solver==3 % SOR_Method
        [T] = SOR_method_unsteady_implicit(nt,nx,ny,x,y,T,T_old,tol,T_prev_dt,k1,k2,omega);
    end
end




function [T] = jacobi_method_unsteady_implicit(nt,nx,ny,x,y,T,T_old,T_prev_dt,tol,k1,k2)
jacobi_iter_un_i=1;
for m=1:nt
    error=9e9;
    while(error>tol)
        for i=2:nx-1
            for j=2:ny-1
                term1=(1+(2*k1)+(2*k2))^-1;
                term2=k1*term1;
                term3=k2*term1;

                H= (T_old(i-1,j))+(T_old(i+1,j));
                V= (T_old(i,j-1))+(T_old(i,j+1));

                T(i,j)=(T_prev_dt(i,j)*term1)+(H*term2)+(V*term3);
            end
        end
        error =max(max(abs(T_old-T)));
        T_old=T;
        jacobi_iter_un_i=jacobi_iter_un_i+1;
    end
    T_prev_dt=T;


end
figure(1)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title_text = sprintf('Iteration Number = %d',jacobi_iter_un_i);
title(title_text,'(Unsteady/Transient) + Implicit with Jacobi Method')
pause(0.03)

end


function [T] = gauss_seidel_method_unsteady_implicit(nt,nx,ny,x,y,T,T_old,T_prev_dt,tol,k1,k2)
gs_iter_un_i=1;
for m=1:nt
    error=9e9;
    while(error>tol)
        for i=2:nx-1
            for j=2:ny-1
                term1=(1+(2*k1)+(2*k2))^-1;
                term2=k1*term1;
                term3=k2*term1;

                H= (T(i-1,j))+(T_old(i+1,j));
                V= (T(i,j-1))+(T_old(i,j+1));

                T(i,j)=(T_prev_dt(i,j)*term1)+(H*term2)+(V*term3);
            end
        end
        error =max(max(abs(T_old-T)));
        T_old=T;
        gs_iter_un_i=gs_iter_un_i+1;
    end
    T_prev_dt=T;


end
figure(2)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title_text = sprintf('Iteration Number = %d',gs_iter_un_i);
title(title_text,'(Unsteady/Transient) + Implicit with Gauss-Seidel Method')
pause(0.03)

end


function [T] = SOR_method_unsteady_implicit(nt,nx,ny,x,y,T,T_old,tol,T_prev_dt,k1,k2,omega)
SOR_iter_un_i=1;
for m=1:nt
    error=9e9;
    while(error>tol)
        for i=2:nx-1
            for j=2:ny-1
                term1=(1+(2*k1)+(2*k2))^-1;
                term2=k1*term1;
                term3=k2*term1;

                H= (T(i-1,j))+(T_old(i+1,j));
                V= (T(i,j-1))+(T_old(i,j+1));

                T(i,j)=(1-omega)*T_old(i,j)+omega*((T_prev_dt(i,j)*term1)+(H*term2)+(V*term3));
            end
        end
        error =max(max(abs(T_old-T)));
        T_old=T;

        SOR_iter_un_i=SOR_iter_un_i+1;
    end
    T_prev_dt=T;



end
figure(3)
contourf(x,y,T)
clabel(contourf(x,y,T))
colorbar
colormap(turbo)
set(gca,'ydir','reverse')
xlabel('X-Axis')
ylabel('Y-Axis')
title_text = sprintf('Iteration Number = %d',SOR_iter_un_i);
title(title_text,'(Unsteady/Transient) + Implicit with SOR Method')
pause(0.03)

end

Results Plots and Conclusion:

Steady state Implicit - Jacobi Method:

Steady state Implicit - Gauss-Seidel Method:

Steady state Implicit - Succesive Over relaxation (SOR) Method:

Unsteady /Transient state Explicit:

Unsteady /Transient state - Implicit - Jacobi Method:

Unsteady /Transient state - Implicit - Gauss-Seidel Method:

Unsteady /Transient state - Implicit - SOR Method:

As expected both in steady state and unsteady state the number of iteration is reduced for Gauss-Seidel and Sucessive over relation when compared to jacobi method.

No. of Iterations: Jacobi> Gauss-Seidel> SOR

For unsteday state explict method enough time to be given for the solution to diffuse. In this example t is taken as 14 seconds so nt=1400 where nt = t/dt where dt=0.01.

Your portfolio, next

Ship work like this
in your own course.

Talk to a career counsellor

Free 20-minute call. We'll map the right course to where you want to work.

By submitting you agree to our Terms and Privacy Policy.

Talk to a career counsellor

Free 20-minute call. We'll map the right course to where you want to work.

By submitting you agree to our Terms and Privacy Policy.