fd1d_heat_implicit

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

This code solves

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

over the interval [A,B] with boundary conditions

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

over the time interval [T0,T1] with initial conditions

        U(X,T0) = U0(X)

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

The solver applies an implicit backward 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,+dtT) - 2 U(X,+dtT) + U(X+dx,+dtT) )
       ------------------  = F(X,T+dt) + k *  ---------------------------------------------
                dt                                   dx * dx

or, assuming we have solved for all values of U at time T, we have

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

which can be written as A*x=b, where A is a tridiagonal matrix whose entries are the same for every time step.

Licensing:

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

Languages:

fd1d_heat_implicit 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 codes:

fd1d_advection_lax_wendroff, a Python code 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_explicit, a Python code which uses the finite difference method (FDM) and explicit time stepping to solve the time dependent heat equation in 1D.

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

Reference:

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_implicit.py, the source code.
fd1d_heat_implicit.sh, runs all the tests.
fd1d_heat_implicit.txt, the output file.

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 H(X,T) 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.
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_test031.png, a PNG image of the solution.
t_test03.txt, the T data.
x_test03.txt, the X data.

Last revised on 24 January 2020.