FD1D_HEAT_EXPLICIT
Finite Difference Solution of the
Time Dependent 1D Heat Equation
using Explicit Time Stepping

FD1D_HEAT_EXPLICIT is a Python library which solves the time-dependent 1D heat equation, using the finite difference method in space, and an explicit version of the method of lines to handle integration in time.

This program solves

        dUdT - k * d2UdX2 = F(X,T)
      

        U(A,T) = UA(T),
        U(B,T) = UB(T),
      

        U(X,T0) = U0(X)
      

A second order finite difference is used to approximate the second derivative in space.

The solver applies an explicit forward Euler approximation to the first derivative in time.

The resulting finite difference form can be written as

       U(X,T+dt) - U(X,T)         ( U(X-dx,T) - 2 U(X,T) + U(X+dx,T) )
       ------------------  = k *  ------------------------------------ + F(X,T)
                dt                          dx * dx
      

       U(X,T+dt) = U(X,T) + cfl * ( U(X-dx,T) - 2 U(X,T) + U(X+dx,T) ) + dt * F(X,T)
      

        cfl = k * dt / dx / dx
      

Other approaches would involve a fully implicit backward Euler approximation or the Crank-Nicholson approximation. These latter two methods have improved stability.

A second worthwhile change would be to replace the constant heat conductivity K by a function K(X,T). The spatial variation would allow for the modeling of a region divided into subregions of different materials.

Usage:

h_new = fd1d_heat_explicit ( x_num, x, t, dt, cfl, rhs, bc, h )

• x_num, the number of equally spaced nodes;
• x, the coordinates of the nodes;
• t, the current time;
• dt, the time step;
• cfl, the Courant-Friedrichs-Loewy coefficient;
• rhs, a function to evaluate the right hand side source terms.
• bc, a function to enforce the boundary conditions.
• h, the vector of temperatures at time T.
• h_new, the vector of temperatures at time T+DT.

Licensing:

The computer code and data files described and made available on this web page are distributed under the GNU LGPL license.

Languages:

FD1D_HEAT_EXPLICIT is available in a C version and a C++ version and a FORTRAN90 version and a MATLAB version and a Python version

Related Data and Programs:

FD1D_ADVECTION_LAX_WENDROFF, a Python program which applies the finite difference method (FDM) to solve the time-dependent advection equation ut = - c * ux in one spatial dimension, with a constant velocity, using the Lax-Wendroff method to treat the time derivative.

FD1D_HEAT_IMPLICIT, a Python program which uses the finite difference method (FDM) and implicit time stepping to solve the time dependent heat equation in 1D.

FD2D_HEAT_STEADY, a Python program which uses the finite difference method (FDM) to solve the steady (time independent) heat equation in 2D.

FEM1D, a Python program which applies the finite element method, with piecewise linear basis functions, to a linear two point boundary value problem;

FEM1D_HEAT_EXPLICIT, a Python program which uses the finite element method (FEM) and explicit time stepping to solve the time dependent heat equation in 1D.

Reference:

1. George Lindfield, John Penny,
   Numerical Methods Using MATLAB,
   Second Edition,
   Prentice Hall, 1999,
   ISBN: 0-13-012641-1,
   LC: QA297.P45.

Source Code:

• fd1d_heat_explicit_cfl.py, computes the Courant-Friedrichs-Loewy coefficient;
• fd1d_heat_explicit.py, carries out the calculation;
• r8mat_write.py, writes an R8MAT to a file.
• r8vec_write.py, writes an R8VEC to a file.
• timestamp.py, prints the YMDHMS date as a timestamp;

Examples and Tests:

• fd1d_heat_explicit_test.py, runs all the tests.
• fd1d_heat_explicit_test.txt, the output file.
• fd1d_heat_explicit_test01.py, runs test 1;
• fd1d_heat_explicit_test02.py, runs test 2;
• fd1d_heat_explicit_test03.py, runs test 3;

TEST01 runs with initial condition 50 everywhere, boundary conditions of 90 on the left and 70 on the right, and no right hand side source term.

• h_test01.txt, the computed H data.
• plot_test01.png, a PNG image of the solution.
• t_test01.txt, the T data.
• x_test01.txt, the X data.

TEST02 uses an exact solution of g(x,t) = exp ( - t ) .* sin ( sqrt ( k ) * x ).

• g_test02.txt, the exact data.
• h_test02.txt, the computed H data.
• plot_test02.png, a PNG image of the solution.
• plot_g_test02.png, a PNG image of the exact solution.
• t_test02.txt, the T data.
• x_test02.txt, the X data.

TEST03 runs on the interval -5 <= X <= 5, with initial condition 15 on the entire left and 25 on the entire right. The solution should settle down to a straight line from the left boundary to the right.

• h_test03.txt, the computed H data.
• plot_test03.png, a PNG image of the solution.
• t_test03.txt, the T data.
• x_test03.txt, the X data.

You can go up one level to the Python source codes.