All Courses
All Courses
Courses by Software
Courses by Semester
Courses by Domain
Tool-focused Courses
Machine learning
POPULAR COURSES
Success Stories
I. Aim: Solve the 2D steady and unsteady state heat conduction equation by explicit and implicit methods using iterative solvers. II. Problem Statement: Solve the 2D heat conduction equation by using the point iterative techniques. The Boundary conditions for the problem are as follows; Top Boundary = 600 K Bottom Boundary…
Rajesh Simhadri
updated on 19 Apr 2021
I. Aim:
Solve the 2D steady and unsteady state heat conduction equation by explicit and implicit methods using iterative solvers.
II. Problem Statement:
Solve the 2D heat conduction equation by using the point iterative techniques. 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
Implement the following methods for solving implicit equations.
1. Jacobi
2. Gauss-seidel
3. Successive over-relaxation
Write a code in MATLAB to solve for the temperature distribution for the steady-state and transient problem using implicit and explicit methods.
III. Governing equations and mathematical formulation:
The transient 2d heat conduction equation is given by:
∂T∂t+α(∂2T∂x2+∂2T∂y2)=0 ............(1)
Where T = Temperature
t = time
αis the thermal diffusivity
x & y are domain directions.
For steady-state conditions∂T∂t=0 , therefore equation reduces to:
∂2T∂x2+∂2T∂y2=0 ........(2)
Consider a 2d grid as shown below:
The equation (2) is elliptic in nature, hence using 2nd order central difference approximation, the temperature distribution T(i,j) at a point P(i,j) along x,y directions in the two-dimensional domain can be found as :
∂2T∂x2+∂2T∂y2≈(T(i+1,j)−2T(i,j)+T(i−1,j)dx2+T(i,j+1)−2T(i,j)+T(i,j−1)dy2)=0
Rewriting the above equation;
T(i,j)≈⎛⎜⎝dx2⋅dy22(dx2+dy2)⎞⎟⎠(T(i+1,j)+T(i−1,j)dx2+T(i,j+1)+T(i,j−1)dy2)
The above equation represents the steady-state temperature distribution at a point T(i,j) in the 2d domain. Similarly, we can write the temperature at all grid points in the 2d domain. This set of linear coupled equations can be solved by implicit numerical method iteratively along with boundary conditions over the entire domain to find the steady-state overall temperature distribution in the domain. The boundary conditions refer to the temperature at the boundaries of the domain.
Numerical solution schemes are often referred to as being explicit or implicit. When a direct computation of the dependent variables can be made in terms of known quantities, the computation is said to be explicit. When the dependent variables are defined by coupled sets of equations, and either a matrix or iterative technique is needed to obtain the solution, the numerical method is said to be implicit. There are three types of implicit techniques to solve the linear coupled equations namely Jacobi, Gauss Siedel and Successive over-relaxation methods.
The Jacobi Method:
The first iterative technique is called the Jacobi method, after Carl Gustav Jacob Jacobi (1804–1851).
This method makes two assumptions:
(1) that the system is given by:
has a unique solution and (2) that the coefficient matrix A has no zeros on its main diagonal.
If any of the diagonal entries are zero, then rows or columns must be interchanged to obtain a coefficient matrix that has nonzero entries on the main diagonal.
To begin with the Jacobi method, we solve the first equation for x1, the second equation for x2and so on, as follows.
Then we make an initial approximation of the solution:
and substitute these values of xi into the right-hand side of the rewritten equations to obtain the first approximation. After this procedure has been completed, one iteration has been performed. In the same way, the second approximation is formed by substituting the first approximation’s x-values into the right-hand side of the rewritten equations. By repeated iterations, a sequence of approximations are performed that often converges to the actual solution.
The Gauss-Seidel Method:
This is more of a modification of the Jacobi method called the Gauss-Seidel method, named after Carl Friedrich Gauss (1777–1855) and Philipp L. Seidel (1821–1896). This modification is easier to use than the Jacobi method, and it often requires fewer iterations to produce the same degree of accuracy. With the Jacobi method, the values of xiobtained in the nth approximation remain unchanged until the entire (n+1)th approximation has been calculated. With the Gauss-Seidel method, on the other hand, we use the new values of each xi as soon as they are
known. That is, once x1is determined from the first equation, its value is then used in the second equation to obtain the new x2.Similarly, the new x1 and x2 are used in the third equation to obtain the new x3 and so on.
Neither of the iterative methods discussed always converges. That is, it is possible to apply the Jacobi method or the Gauss-Seidel method to a system of linear equations and obtain a divergent sequence of approximations. In such cases, it is said that the method diverges.
If A is a strictly diagonally dominant matrix, then the system of linear equations given by has a unique solution to which the Jacobi method and the Gauss-Seidel method will converge for any initial approximation.
An×n matrix A is strictly diagonally dominant if the absolute value of each entry
on the main diagonal is greater than the sum of the absolute values of the other entries in the same row.
Successive over-relaxation(SOR):
This method is a modification of the Gauss Siedel method.It is often referred to as an accelerated scheme, as it reduces the gap between two iterations and landing of its original position.
xNew=(1−w)xold+(w.xG.S)
here,xGS−xold2−1 is the rate of change of xNew value in the gauss seidel method at that instantaneous iteration. w is the relaxation factor that increases this rate of change by a factor at each iteration. This makes the iteration procedure aggressive`
Transient 2d heat conduction equation:
The transient 2d heat conduction equation as given in (1):
∂T∂t+α(∂2T∂x2+∂2T∂y2)=0 `
The transient temperature distribution T(i,j) at a point P(i,j) along x,y directions in the two-dimensional domain at a time 't' can be found as by numerical approximation as:
∂T∂x+α(∂2T∂x2+∂2T∂y2)≈(Tn+1i,j−Tni,jdt)−(α(T(i+1,j)−2T(i,j)+T(i−1,j)dx2+T(i,j+1)−2T(i,j)+T(i,j−1)dy2))=0
where dt is the time increment, TnandTn+1 are the temperature at 'n' and 'n+1' time step. The first order forward difference approximation is used for the time derivative and 2nd order central difference approximation for space deivatives.
Rewriting the above equation :
Tn+1i,j≈Tni,j+(α(dtdx2)(T(i+1,j)−2T(i,j)+T(i−1,j))+α(dtdy2)(T(i,j+1)−2T(i,j)+T(i,j−1)))p .....(3`
Where, p is 'n' for an explicit scheme of the numerical solution and 'n+1' for an implicit method of solution.
Explicit method solution:
The above equation can be simplified for the explicit scheme as
Tn+1i,j≈Tni,j+k1(T(i+1,j)n−2T(i,j)n+T(i−1,j)n)+k2(T(i,j+1)n−2T(i,j)n+T(i,j−1)n)
where, k1=α(dtdx2) and k2=α(dtdy2) are the CFL numbers for the heat diffusion along x and y directions.
The above equation can be solved by a direct method like Gauss-elimination over the entire time period and space considered in a domain to find the temperature distribution.
Implicit method solution:
Equation (3) can be simplified for the implicit numerical method as :
Tn+1i,j≈(11+2k1+2k2)[Tni,j+k1⋅(Ti+1,j+Ti−1,j)n+1+k2⋅(Ti,j+1+Ti,j−1)n+1]
where, k1=α(dtdx2) and k2=α(dtdy2).
The above-simplified equation can be solved iteratively using Jacobi, Gauss Siedel and Successive over-relaxation methods.
IV. Input parameters :
The parameters assumed for solving the above 2d steady and unsteady heat conduction equation are:
1. Domain Length (x-direction) = 1 m
2. Domain height (y-direction) = 1m
3. number of grid points each in x and y directions = 10
4. Thermal diffusivity, aplha = 1.4 m^2/s
5. Time step size(dt) = 1e-4
6. Number of time steps = 1600.
V. Program:
The program is written in Matlab for solving the steady-state condition using implicit iterative methods and unsteady state using explicit and implicit methods.
Main Program:
%2d steady state conduction
%d^2T/d^x2+d^2T/dy^2 = 0
clear all
close all
clc
%domain properties
L =1;
H =1;
%grid points/no of nodes
nx = 10;
ny = 10;
x =linspace(0,L,nx);
y =linspace(0,L,ny);
%grid size
dx = L/(nx-1);
dy = H/(nx-1);
%transient analysis parameters
dt = 1e-4;
nt = 1400;
t = nt*dt;
alpha = 1.4;
%initial conditions & Boundary conditions
T = 300*(ones(nx,ny));
T(2:9,1) = 400;
T(1,2:9) = 900;
T(10,2:9) = 600;
T(2:9,10) = 800;
T(1,1) = 500;
T(1,10) = 700;
T(10,1) = 650;
T(10,10) = 850;
%initializing the domain
T_prev_dt = T;
Told = T;
%error criteria and tolerance of convergence
error = 9e9;
tol = 1e-4;
%steady state
%jacobi method
[T,jacobi_iter] =jacobi(T,dx,dy,nx,ny,Told,error,tol);
figure(1)
contourf(x,y,T,'showtext','on')
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Steady state Temperature distribution for Jacobi method (iterations = %d)',jacobi_iter) )
%Gauss_siedel method
[T,gs_iter] =gs(T,dx,dy,nx,ny,Told,error,tol);
figure(2)
contourf(x,y,T,'showtext','on')
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Steady state Temperature distribution for Gauss-Siedel method (iterations = %d)',gs_iter))
%SOR method
[T,sor_iter] =sor(T,dx,dy,nx,ny,Told,error,tol);
figure(3)
contourf(x,y,T,'showtext','on')
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Steady state Temperature distribution for SOR method (iterations = %d)',sor_iter))
%2d transient conduction
%%dT/dt = alpha(d^2T/dx^2+dy^2)
%Explicit method
[T_explicit] = explicit(nt,dt,T,dx,dy,nx,ny,Told,alpha);
figure(4)
contourf(x,y,T,'showtext','on')
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Transient Temperature distribution for explicit method (timesteps = %d)',nt))
%jacobi_implicit method
[T,jacobi_iter_implicit] = implicit1_jacobi(nt,dt,T,T_prev_dt,dx,dy,nx,ny,Told,alpha,tol);
figure(5)
contourf(x,y,T,'showtext','on')
pause (0.2)
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Temperature distribution for implicit Jacobi method (timesteps = %d),iterations = %d',nt,jacobi_iter_implicit))
%gs_implicit method
[T,gs_iter_implicit] = implicit1_gs(nt,dt,T,T_prev_dt,dx,dy,nx,ny,Told,alpha,tol);
figure(6)
contourf(x,y,T,'showtext','on')
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Temperature distribution for implicit Gauss siedel method (timesteps = %d),iterations = %d',nt,gs_iter_implicit))
%sor_implicit method
[T,sor_iter_implicit] = implicit1_sor(nt,dt,T,T_prev_dt,dx,dy,nx,ny,Told,alpha,tol)
figure(7)
contourf(x,y,T,'showtext','on')
xlabel('X-direction')
ylabel('Y-direction')
title(sprintf('Temperature distribution for implicit SOR method (timesteps = %d),iterations = %d',nt,sor_iter_implicit))
Code Explanation:
Step1: clear all – command to clear the workspace.
Step 2: close all – command to close all opened previous plots.
Step 3: clc – command to clear the command window.
Step 4: The domain properties, number of grid points, element length, time step size, number of time steps, thermal diffusivity , initial and boundary conditions, error tolerance criteria etc are defined.
Step 5: The temperature distribution in the domain is evaluated for steady and unsteady cases by calling appropriate functions and plotted as contour plots. The function codes for each type of numerical scheme for steady and unsteady methods are given below:
1. Function code for steady-state temperature distribution using Jacobi method.
%Function code for steady-state temperature distribution using Jacobi method.
function [T,jacobi_iter] = jacobi(T,dx,dy,nx,ny,Told,error,tol)
jacobi_iter = 1; %initializing the iteration number
while(error>tol) %convergence criteria of error > tol
%looping over the 2d xy domain
for i = 2:nx-1
for j = 2:ny-1
k = (2*((dx^2+dy^2)/(dx^2*dy^2)));
term1 = (Told(i-1,j)+Told(i+1,j))/dx^2;
term2 = (Told(i,j-1)+Told(i,j+1))/dy^2;
T(i,j) = (term1/k)+(term2/k);
end
end
error = max(max((abs(T-Told))));
Told = T;
jacobi_iter = jacobi_iter+1;
end
end
The function code takes the domain properties, the number of grid points along x, y-direction, error and tolerance criteria, initial temperature and boundary conditions of the domain. The output arguments of the function are the steady state temperature distribution and the number of iterations taken to reach the convergence.
A nested for loop is used to compute the temperature distribution in the XY space domain. The space loop is executed in a while statement, which iterates the space loop until the error is greater than the tolerance criteria value. After each space loop iteration, the error in terms of initial temperature and temperature of the current iteration are compared. If the error from the current iteration is greater than the tolerance value, the while statement continues with the next iteration with the temperature from the current iteration is used as initial temperature for the next iteration. This process continues until convergence criteria are met.
The steady-state temperature distribution computed using Jacobi method is shown in the figure below:
From, the above plot it can be inferred that the steady-state condition for temperature distribution required 208 iterations using the Jacobi method of the numerical solution. The temperature inside the domain is dependent on the boundary conditions applied and the initial temperature inside the domain.
2. Function code for steady-state temperature distribution using the Gauss_seidel method:
%steady state 2d conduction
function [T,gs_iter] = gs(T,dx,dy,nx,ny,Told,error,tol)
gs_iter = 1;
while(error>tol)
for i = 2:nx-1
for j = 2:ny-1
k = (2*((dx^2+dy^2)/(dx^2*dy^2)));
term1 = (T(i-1,j)+Told(i+1,j))/dx^2;
term2 = (T(i,j-1)+Told(i,j+1))/dy^2;
T(i,j) = (term1/k)+(term2/k);
end
end
error = max(max((abs(T-Told))));
Told = T;
gs_iter = gs_iter+1;
end
end
The function code for temperature distribution is similar to that of the Jacobi method except that the temperature T(i,j) for the current iteration is computed using the temperature at points (i-1,j) and (i,j-1) from the current iteration itself. This makes the solution to converge faster.
The steady-state temperature distribution computed using the Gauss-Siedel method is shown in the figure below:
From, the above plot it can be inferred that the steady-state condition for temperature distribution required 112 iterations using the Gauss-Seidel method of the numerical solution. The temperature distribution is exactly the same as the Jacobi solution, but the iterations reduced to 112. This shows Gauss_Siedel method converges faster due to using the updated temperature values of the current iteration for the space points at (i-1,j)and (i,j-1) to compute the T(i,j).
3. Function code for steady-state temperature distribution using the SOR method:
function [T,sor_iter] = sor(T,dx,dy,nx,ny,Told,error,tol)
sor_iter = 1;
w = 1.5;
while(error>tol)
for i = 2:nx-1
for j = 2:ny-1
k = (2*((dx^2+dy^2)/(dx^2*dy^2)));
term1 = (T(i-1,j)+Told(i+1,j))/dx^2;
term2 = (T(i,j-1)+Told(i,j+1))/dy^2;
T(i,j) = (term1/k)+(term2/k);
T(i,j) = (1-w)*Told(i,j)+(w*T(i,j));
end
end
error = max(max((abs(T-Told))));
Told = T;
sor_iter = sor_iter+1;
end
end
The SOR approach is a modification to the GS method which is aggressive and a relaxation factor is used to compute the temperature distribution. If the value of the relaxation factor is greater than 1 it is called the over-relaxation approach and if less than 1 it is under relaxation. Choice of w is important to achieve the solution in an optimum number of iterations. For the present problem, w=1.5 is used.
The steady-state temperature distribution computed using the Gauss-Siedel method is shown in the figure below:
From, the above plot it can be inferred that the steady-state condition for temperature distribution required only 29 iterations using the SOR method of the numerical solution. The temperature distribution is exactly the same as the Jacobi /GS solution, but the iterations reduced to 29. This shows SOR method converges faster using the optimum relaxation factor.
4. Function code for unsteady 2d heat conduction temperature distribution using the explicit method:
%explicit solution for unsteady 2d conduction
function [T] = explicit(nt,dt,T,dx,dy,nx,ny,Told,alpha)
k1 =(alpha*(dt/dx^2));
k2 =(alpha*(dt/dy^2));
for k = 1:nt %time loop
for i = 2:nx-1
for j = 2:ny-1
term1 = Told(i,j);
term2 = k1*(Told(i-1,j)-2*Told(i,j)+Told(i+1,j));
term3 = k2*(Told(i,j-1)-2*Told(i,j)+Told(i,j+1));
T(i,j) = term1+term2+term3;
end
end
Told = T;
end
end
The function code takes the domain properties, the number of grid points along x, y-direction, time step size and number of time steps, initial temperature and boundary conditions of the domain. Although the solution is for the unsteady problem, the number of time steps considered such that steady-state temperature distribution is obtained. The output arguments of the function are the temperature distribution and the number of iterations taken to reach the steady-state after marching in the time domain. A nested for loop is used to compute the temperature variation in the domain with space and time. After each time step is executed the temperature from the current time step is used and the initial temperature for the next time step, so that the temperature profile marching in time is achieved. Since , the temperature at any time step is computed with the known values of temperature from the previous time step, no iteration type solving is required in the explicit method.
The transient temperature distribution computed using the explicit method is shown in the figure below:
The above plot shows the transient temperature distribution after the 1400 time step in the domain with a time step size of 1e-4 s. This is similar to the steady-state temperature distribution. The thermal diffusivity plays an important role in how the heat diffuses in a domain. It is considered to be 1.4 m^2/s, in order the CFL number is less than 0.5 in each domain direction and to reach steady-state faster. Hence for a thermal diffusivity value of 1.4 m^2/s, the steady-state is reached after 1400 time steps with a time step size of 1e-4 s.
4. Function code for unsteady 2d heat conduction temperature distribution using the implicit jacobi method:
function [T,jacobi_iter_implicit] = implicit1_jacobi(nt,dt,T,T_prev_dt,dx,dy,nx,ny,Told,alpha,tol)
jacobi_iter_implicit = 1;
k1 =(alpha*(dt/dx^2));
k2 =(alpha*(dt/dy^2));
for k = 1:nt
error = 9e9;
while(error>tol)
for i = 2:nx-1
for j = 2:ny-1
term1 = (1/(1+(2*k1)+(2*k2)));
term2 = term1*k1;
term3 = term1*k2;
M = (Told(i-1,j)+Told(i+1,j));
V = (Told(i,j-1)+Told(i,j+1));
T(i,j) = (term1*T_prev_dt(i,j))+(M*term2)+(V*term3);
end
end
error = max(max(abs(T-Told)));
Told = T;
jacobi_iter_implicit = jacobi_iter_implicit+1 ;
end
T_prev_dt = T;
end
end
The function code for temperature distribution using the implicit Jacobi method is similar to the steady-state method, except that the while statement is executed in a for loop of time increments to consider the effect of unsteady nature. The temperature distribution at a point(i,j) is estimated by considering the time-dependent temperature value from the previous time step as the initial condition in the domain and the space-dependent temperature values of neighbouring points from the previous space iteration for the current time step.
The transient temperature distribution computed using the implicit Jacobi method is shown in the figure below:
The plot above shows the temperature distribution in the domain after 1400 timesteps. It is similar to the steady-state distribution. The iterations mentioned in the plot are for the total time steps considered, hence the transient Jacobi solution took almost 27 times more iterations than the steady solution (iteration = 208) to reach a steady-state.
4. Function code for unsteady 2d heat conduction temperature distribution using the implicit Gauss-Siedel method:
function [T,gs_iter_implicit] = implicit1_gs(nt,dt,T,T_prev_dt,dx,dy,nx,ny,Told,alpha,tol)
gs_iter_implicit = 1;
k1 =(alpha*(dt/dx^2));
k2 =(alpha*(dt/dy^2));
for k = 1:nt
error = 9e9;
while(error>tol)
for i = 2:nx-1
for j = 2:ny-1
term1 = (1/(1+(2*k1)+(2*k2)));
term2 = term1*k1;
term3 = term1*k2;
M = (T(i-1,j)+Told(i+1,j));
V = (T(i,j-1)+Told(i,j+1));
T(i,j) = (term1*T_prev_dt(i,j))+(M*term2)+(V*term3);
end
end
error = max(max(abs(T-Told)));
Told = T;
gs_iter_implicit = gs_iter_implicit+1;
end
T_prev_dt = T;
end
end
The function code for temperature distribution using the implicit GS method is similar to the steady-state method, except that the while statement is executed in a for loop of time increments to consider the effect of unsteady nature. The temperature distribution at a point(i,j) for the current time step is estimated by considering the time-dependent temperature value from the previous time step as the initial condition in the domain and the space-dependent temperature values of neighbouring points from the previous space iteration for points (i+1,j) and (i,j+1) and for the current time step for points (i-1,j),(i,j-1).
The transient temperature distribution computed using the implicit GS method is shown in the figure below:
The plot above shows the temperature distribution in the domain after 1400 timesteps. It is similar to the steady-state distribution. The iterations mentioned in the plot are for the total time steps considered, hence the transient GS solution took almost 44 times more iterations than the steady solution (iteration = 112) to reach a steady state. The Gauss_Siedel method converges faster than the Jacobi method, due to using the updated temperature values of the current iteration for the space points at (i-1,j)and (i,j-1) to compute the T(i,j).
4. Function code for unsteady 2d heat conduction temperature distribution using the implicit SOR method:
function [T,sor_iter_implicit] = implicit1_sor(nt,dt,T,T_prev_dt,dx,dy,nx,ny,Told,alpha,tol)
sor_iter_implicit = 1;
k1 =(alpha*(dt/dx^2));
k2 =(alpha*(dt/dy^2));
w = 1.02;
for k = 1:nt
error = 9e9;
while(error>tol)
for i = 2:nx-1
for j = 2:ny-1
term1 = (1/(1+(2*k1)+(2*k2)));
term2 = term1*k1;
term3 = term1*k2;
M = (T(i-1,j)+Told(i+1,j));
V = (T(i,j-1)+Told(i,j+1));
T(i,j) = (term1*T_prev_dt(i,j))+(M*term2)+(V*term3);
T(i,j) = (1-w)*Told(i,j)+(w*T(i,j));
end
end
error = max(max(abs(T-Told)));
Told = T;
sor_iter_implicit = sor_iter_implicit+1;
end
T_prev_dt = T;
end
end
The SOR approach is a modification to the GS method which is aggressive and a relaxation factor is used to compute the temperature distribution. If the value of the relaxation factor is greater than 1 it is called the over-relaxation approach and if less than 1 it is under relaxation. Choice of w is important to achieve the solution in an optimum number of iterations. For the present problem, w=1.5 is used.
The transient temperature distribution computed using the implicit SOR method is shown in the figure below:
From, the above plot it can be inferred that 4408 iterations were performed for the timesteps considered using the SOR method.
Conclusion:
The objective of this project is to solve the 2D heat conduction equation both in steady and unsteady states using point iterative techniques and to write a program in Matlab to solve them. The First 2D steady state heat conduction equation is solved using Jacobi, Gauss Siedel and SOR methods. It is found that SOR method converges to the solution in a lesser number of iterations. Then the unsteady heat conduction equation is solved using both explicit and implicit time integration techniques. The explicit method is the direct method of solution, which calculates the information about a quantity of the present time step using the information about the quantity from previous timesteps in the whole domain. The CFL number plays an important role in the explicit method of solution which is directly related to the stability of the solution. The implicit time integration method using Jacobi, GS and SOR methods also converge to the steady-state solution but require a higher number of iterations. The time integration methods should be used only when the time rate of change of quantities is important rather than a final state. If a final equilibrium state is important, steady-state solution methods should be preffered.
Leave a comment
Thanks for choosing to leave a comment. Please keep in mind that all the comments are moderated as per our comment policy, and your email will not be published for privacy reasons. Please leave a personal & meaningful conversation.
Other comments...
Week 11: FSAE Car Project
I. Aim: Aerodynamic flow simulation around a prototype FSAE car using Converge CFD. II. Introduction: The Formula SAE® (FASE) series competitions challenge teams of university undergraduate and graduate students to conceive, design, fabricate, develop, and compete with small, formula-style vehicles. The competitions…
21 May 2022 08:11 AM IST
Modeling and Simulation of flow around an Ahmed Body
I. Aim: Aerodynamic flow simulation around an Ahmed body using Converge CFD. II. Introduction: The Ahmed body is a generic car body (a simplified vehicle model). The flow of air around the Ahmed body captures the essential flow features around an automobile and was first defined and characterized by Ahmed [1] in…
29 Apr 2022 12:50 AM IST
Flow over an NACA Airfoil for different Angle of Attacks.
I. Aim: 2D CFD analysis of flow over an airfoil using Converge CFD. II. Problem Statement: Perform 2D transient analysis of flow over an airfoil at different angle of attacks. The case setup is done using ConvergeCFD and simulation is run in the CYGWIN terminal. Further, post-processing is done using Converge…
19 Mar 2022 02:31 AM IST
Week 8: Literature review RANS derivation and analysis
I. Aim: Literature review RANS derivation and analysis II. Introduction: TURBULENT FLOWS : Generally, a flow is differentiated between a laminar and a turbulent flow state. If the flow velocity is very small, the flow will be laminar, and if the flow velocity exceeds a certain boundary value, the flow becomes turbulent.…
12 Mar 2022 02:21 AM IST
Related Courses
Skill-Lync offers industry relevant advanced engineering courses for engineering students by partnering with industry experts.
© 2025 Skill-Lync Inc. All Rights Reserved.