In mathematics, numerical analysis and numerical partial differential equations, the domain decomposition method solves a boundary value problem by splitting it into smaller boundary value problems.

Table of contents |

2 A technical example |

## Overview

**(Model Problem)**The heat distribution in a square metal plate such that the left edge is kept at 1 degree, and the other edges are kept at 0 degree, after letting it sit for a long period of time satisfies the following boundary value problem:*f*_{xx}(*x*,*y*) +*f*_{yy}(*x*,*y*) = 0*f*(0,*y*) = 1;*f*(*x*,0) =*f*(*x*,1) =*f*(1,*y*) = 0

- where
*f*_{xx'\'}*and*fyy_{}*denote the second**partial derivatives with respect to*x*and*y'', respectively.

*domain*is the square [0,1] × [0,1].

This particular problem can be solved exactly on paper, so there is no need for a computer. However, this is an exceptional case, and most BVPs cannot be solved exactly. The only possibility is to use a computer to find an approximate solution.

### Solving on a computer

There are some difficulties, for instance it isn't possible to calculate *f*_{xx}(0.5,0.5) knowing *f* at only 64 points in the square. To solve this, one uses some sort of numerical approximation of the derivatives, see for instance the finite element method or finite differences. We ignore these difficulties and concentrate on another aspect of the problem.

### Solving linear problems

This is a system of 2 equations in 2 unknowns (*a*and

*b*). If we solve the BVP above in the manner suggested, we will need to solve a system of 64 equations in 64 unknowns. This is not a hard problem for modern computers, but if we use a larger number of samples, even modern computers cannot solve the BVP very efficiently.

### Domain decomposition

#### Size of the problems

We see that this system has only 4 important pieces of information. This means that a computer program will have an easier time solving two 1×1 systems than solving a single 2×2 system, because the pair of 1×1 systems are simpler than the single 2×2 system. While the 64×64 and 32×32 systems are too large to illustrate here, we could say by analogy that the 64×64 system has 4160 pieces of information, while the 32×32 systems each have 1056, or roughly a quarter of the 64×64 system.#### Domain decomposition algorithm

- 1) Begin with an approximate solution of the 64×64 system.
- 2) From the 64×64 system, create two 32×32 systems to improve the approximate solution.
- 3) Solve the two 32×32 systems.
- 4) Put the two 32×32 solutions "together" to improve the approximate solution to the 64×64 system.
- 5) If the solution isn't very good yet, repeat from 2.

*parallel*to use the power of multiple computers.

In fact, solving two 32×32 systems instead of a 64×64 system on a single computer (without using parallelism) is unlikely to be efficient. However, if we use more than two subdomains, the picture can change. For instance, we could use four 16×16 problems, and there's a chance that solving these will be better than solving a single 64×64 problem even if the domain decomposition algorithm needs to iterate a few times.

## A technical example

Here we assume that the reader is familiar with partial differential equations.

We will be solving the partial differential equation

The boundary condition is boundedness at infinity.
We decompose the domain **R**^{2} into two overlapping subdomains H_{1} = (− ∞,1] × **R** and H_{2} = [0,+ ∞) × **R**. In each subdomain, we will be solving a BVP of the form:

*u*^{( j )}_{xx}+*u*^{( j )}_{yy}=*f*in H_{j}*u*^{( j )}(*x*_{j},*y*) =*g*(*y*)

*x*

_{1}= 1 and

*x*

_{2}= 0 and taking boundedness at infinity as the other boundary condition. We denote the solution

*u*

^{( j )}of the above problem by S(

*f*,

*g*). Note that S is bilinear.

The Schwarz algorithm proceeds as follows:

- Start with approximate solutions
*u*^{( 1 )}_{0}and*u*^{( 2 )}_{0}of the PDE in subdomains H_{1}and H_{2}respectively. Initialize*k*to 1. - Calculate
*u*^{( j )}_{k + 1}= S(*f*,*u*^{(3 − j)}_{k}(*x*_{j})) with*j*= 1,2. - Increase
*k*by one and repeat 2 until sufficient precision is achieved.