Алговики - Вклад [ru]

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T16:06:52Z

Jhuighuy: /* Масштабируемость алгоритма и его реализации */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значений вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, если <math>P</math> — количество вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math>, можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходные данные — трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием накладных расходов на обмен данными между процессами (то есть все данные, необходимые для соответствующего вычисления, локальны относительно процесса) при вычислении коэффициентов приближенного решения и значений функции, а также лишь двумя обменами данными между этапами вычислений.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использованием CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:38:33Z

Jhuighuy: /* Существующие реализации алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значений вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, если <math>P</math> — количество вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math>, можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходные данные — трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием накладных расходов на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использованием CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:36:50Z

Jhuighuy: /* Масштабируемость алгоритма и его реализации */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значений вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, если <math>P</math> — количество вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math>, можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходные данные — трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием накладных расходов на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:35:17Z

Jhuighuy: /* Входные и выходные данные алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значений вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, если <math>P</math> — количество вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math>, можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходные данные — трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:33:16Z

Jhuighuy: /* Ресурс параллелизма алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значений вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, если <math>P</math> — количество вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math>, можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:32:13Z

Jhuighuy: /* Ресурс параллелизма алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значений вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:31:13Z

Jhuighuy: /* Ресурс параллелизма алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационный граф показывает, что коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этий значение вычисляется в виде сумм, дополнительного увеличения производительности можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:28:20Z

Jhuighuy: /* Ресурс параллелизма алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Информационного граф показывает, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:26:56Z

Jhuighuy: /* Макроструктура алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:26:48Z

Jhuighuy: /* Макроструктура алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

С сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:25:39Z

Jhuighuy: /* Вычислительное ядро алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождения приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:25:15Z

Jhuighuy: /* Вычислительное ядро алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для поиска коэффициентов приближенного решения, а также для нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:23:53Z

Jhuighuy: /* Вычислительное ядро алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из подсчета интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:21:54Z

Jhuighuy: /* Математическое описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки по базисным функции, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:18:32Z

Jhuighuy: /* Математическое описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставив в уравнение выражение для приближенного решения, получим формулу невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:17:13Z

Jhuighuy: /* Математическое описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:16:01Z

Jhuighuy: /* Математическое описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение, представленное выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы базисной функции, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:14:15Z

Jhuighuy: /* Свойства и структура алгоритмов */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты определяются условием ортогональности невязки базисной функции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:10:59Z

Jhuighuy: /* Общее описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:10:17Z

Jhuighuy: /* Общее описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) используется для решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:09:58Z

Jhuighuy: /* Общее описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) предполагает решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:09:35Z

Jhuighuy: /* Общее описание алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) -- метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:07:00Z

Jhuighuy: /* Существующие реализации алгоритма */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

* [https://github.com/asaks/Galerkin-Method-Integral-Equation-MPI] Реализация метода Галеркина для интегрального уравнения с использованием MPI.
* [https://github.com/chanchikwan/sg2] Реализация метода Галеркина для задач CFD с использование CUDA.

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T15:02:57Z

Jhuighuy: /* Масштабируемость алгоритма и его реализации */

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая. Это можно объяснить отсутствием расходом на обмен данными между процессами при вычислении коэффициентов приближенного решения и значений функции.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T14:57:36Z

Jhuighuy:

Уравнение Пуассона, решение методом Галеркина, [[Участник:Jhuighuy|Бутаков О.Б]].

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 1. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z + M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Для оценки масштабируемости были выбраны значения <math>N_x=N_y=N_z=M_x=M_y=M_z=64</math>. Все тесты проводились на суперкомпьютере Ломоносов-1.

[[Файл:GalerkinMPI_Perf.png|thumb|center|500px|Рисунок 2. Оценка сильной масштабируемости метода Галеркина.]]

Анализируя график, видно, что производительность растет линейно с увеличением количества вычислительных узлов. Шкала на данном графике логарифмическая.

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013 
Самарский А. А. Введение в численные методы, 1982.

Участник:Jhuighuy

2017-11-29T10:48:36Z

Jhuighuy: Новая страница: «Бутаков Олег Борисович, 404 гр. 2017-2018»

Бутаков Олег Борисович, 404 гр. 2017-2018

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T10:41:01Z

Jhuighuy: /* Схема реализации последовательного алгоритма */

Уравнение Пуассона, решение методом Галеркина, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 0 0 0, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 2. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z}{Q}+\frac{M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T10:40:33Z

Jhuighuy: /* Макроструктура алгоритма */

Уравнение Пуассона, решение методом Галеркина, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=0..M_x, j=0..M_y, k=0..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 1 1 1, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 2. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z}{Q}+\frac{M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T10:39:01Z

Jhuighuy:

Уравнение Пуассона, решение методом Галеркина, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. Алгоритм:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

=== Схема реализации последовательного алгоритма ===

'''Первый этап''' на языке Fortran (для наглядности вложенные конструкции упрощены):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 1 1 1, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

[[Файл:GalerkinInfGraph.png|thumb|center|300px|Рисунок 2. Информационный граф метода Галеркина.]]

* На нулевом ярусе алгоритма происходит генерация или считывание правой части уравнения.
* На первом ярусе вычисляются коэффициенты.
* На втором ярусе происходит объединение их в общий массив.
* На третьем ярусе вычисляется сеточная функция.
* На четвертом ярусе происходит вывод.

=== Ресурс параллелизма алгоритма ===

Из информационного графа видно, что можно коэффициенты <math>C_{m,n,l}</math> и <math>\hat{u}_{h,i,j,k}</math> можно вычислять параллельно. Так как каждое из этих значение вычисляется в виде сумм, дополнительный параллелизм можно достичь за счет параллельного суммирования. Таким образом, при количестве <math>P</math> вычислительных узлов, при <math>P \le min(N_x N_y N_z, M_x M_y M_z)</math> можно достичь производительности в <math>O(\frac{N_x N_y N_z M_x M_y M_z}{P})</math> операций. 
При <math>P \gt min(N_x N_y N_z, M_x M_y M_z)</math>, положив <math>Q = mod(P, min(N_x N_y N_z, M_x M_y M_z))</math>, за счет параллельного суммирования, эта величина равна <math>O(\frac{N_x N_y N_z}{Q}+\frac{M_x M_y M_z}{Q})</math>.

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T09:47:59Z

Jhuighuy: /* Входные и выходные данные алгоритма */

Уравнение Пуассона, решение методом Галеркина, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. В другом варианте сначала вычислим часть коэффициентов, частичные суммы базисных функций на подсчитанных коэффициентах, а затем итоговую функцию.

Первый вариант:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

Второй вариант:
# Определим разбиение, например, <math>N_z</math> на <math>S</math> не пересекающихся подмножеств <math>[k_{0,s}, k_{1,s}]: \sqcup_{s=1}^{S}[k_{0,s}, k_{1,s}]=[1,N_z]</math>. Для всех <math>s=1..S:</math>
## Для всех <math>i=1..N_x, j=1..N_y, k=k_{0,s}..k_{1,s}</math> вычислить <math>C_{m,n,l}</math>.
## Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}^{s} =
\Sigma_{m,n=1,l=k_{0,s}}^{N_x,N_y,k_{1,s}} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z})</math>.
# Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k} = \Sigma_{s=1}^{S}\hat{u}_{h,i,j,k}^{s} </math>

=== Схема реализации последовательного алгоритма ===

Опишем лишь первый вариант макроструктуры, так как второй имеет смысл рассматривать лишь в случае последовательной реализации.

'''Первый этап''' на языке Fortran (для наглядности упростим вложенные конструкции):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 1 1 1, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

В качестве входных данных выступает трехмерный массив <math>M_x \times M_y \times M_z</math> правой части уравнения. Выходной массив - трехмерный массив решения той же размерности.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Jhuighuy/Уравнение Пуассона, решение методом Галеркина

2017-11-29T09:45:18Z

Jhuighuy: Новая страница: «Уравнение Пуассона, решение методом Галеркина, Бутаков О.Б. 404 группа. == Свойства и струк…»

Уравнение Пуассона, решение методом Галеркина, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритмов ==

=== Общее описание алгоритма ===

Метод Галеркина (Галеркина-Бубнова) метод решения краевых задач для дифференциальных уравнений. В данной статье рассмотрим алгоритм метода Галеркина для решения уравнения Пуассона с краевыми условиями первого рода:
:<math>
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}
\begin{cases}
\laplace u = -f, u = \phi(x,y,z), (x,y,z) \in G, G = (0,L_x)\times(0,L_y)\times(0,L_z),
\\
u(x,y,z) = 0, (x,y,z) \in \partial G.
\end{cases}
</math>

Алгоритм предполагает выбор полного набора базисных функций, удовлетворяющих краевым условиям. Решение строится в виде линейной комбинации базисных функций, коэффициенты находятся исходя из ортогональности невязки базисной фукнции.

=== Математическое описание алгоритма ===

Выберем тригонометрическую систему базисных функций:
:<math>
\phi_{m,n,l} = sin(\frac{\pi m x}{L_x})sin(\frac{\pi n y}{L_y})sin(\frac{\pi l z}{L_z}), m=1..N_x, n=1..N_y, l=1..N_z.
</math>

Очевидно, эта система удовлетворяет краевым условиям. Проверим ортогональность функций, введя скалярное произведение <math>(u,v) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} u v dx dy dz</math>:
:<math>
(\phi_{m,n,l} \phi_{i,j,k}) = \int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} \phi_{m,n,l} \phi_{i,j,k} dx dy dz
= \int_{0}^{L_x} sin(\frac{\pi m x}{L_x}) sin(\frac{\pi i x}{L_x}) dx \int_{0}^{L_y} sin(\frac{\pi n x}{L_y}) sin(\frac{\pi j x}{L_y}) dy \int_{0}^{L_z} sin(\frac{\pi l x}{L_z}) sin(\frac{\pi k x}{L_z}) dz
= \delta_{m,i}\frac{L_x}{2} \delta_{n,j}\frac{L_y}{2} \delta_{l,k}\frac{L_z}{2}.
</math>

Выражение выше, с учетом известной ортогональности тригонометрического ряда, дает выражение для нормы, которое потребуется в дальнейшем. 
Представим приближенное решение в виде комбинации базисных функций:
:<math>
\hat{u} = \Sigma_{m,n,l=1}^{L_x,L_y,L_z} C_{m,n,l} \phi_{m,n,l}
</math>.

Подставим выражение для приближенного решения в уравнение, получим выражение для невязки:
:<math>
R(x,y,z) = \laplace\hat{u} + f = -\Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \phi_{m,n,l} + f
</math>.

Разложив выражение для невязки, потребуем ортогональность невязки базисным функциям:
:<math>
\begin{split}
&R_{i,j,k} = (R, \phi_{i,j,k}) = -C_{i,j,k} \pi^2(\frac{m^2}{L_x^2}+\frac{n^2}{L_y^2}+\frac{l^2}{L_z^2}) \frac{L_x}{2}\frac{L_y}{2}\frac{L_z}{2} + (f, \phi_{i,j,k}) = 0
\Rightarrow
\\
&C_{i,j,k} = \frac{8 L_x L_y L_z (f, \phi_{i,j,k})}{\pi^2 ((i L_y L_z)^2 + (j L_x L_z)^2 + (k L_x L_y)^2)}, i=1..N_x, j=1..N_y. k=1..N_z.
\end{split}
</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из вычисления интегралов для нахождения коэффициентов приближенного решения, а также нахождение приближенного решения на сетке. Опишем сетку:
:<math>
\omega_h = [(x_i,y_j,z_k); x_i=i\Delta x, y_j=i\Delta y, z_k=k\Delta k; L_x=M_x\Delta x, L_y=M_y\Delta y, L_z=M_z\Delta z].
</math>

Тогда трехмерный интеграл будет приближенно описываться выражением:
:<math>
\int_{0}^{L_x}\int_{0}^{L_y}\int_{0}^{L_z} f dx dy dz \approx \Sigma_{m,n,l=1}^{M_x,M_y,M_z} f(x_i,y_j,z_k)\Delta x\Delta y\Delta z.
</math>

Вычисление функции на сетке тривиально:
:<math>
\hat{u}_{h,i,j,k} = \Sigma_{m,n,l=1}^{N_x,N_y,N_z} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z}).
</math>

=== Макроструктура алгоритма ===

Рассмотрим две возможные структуры алгоритма, в одной сначала вычислим все коэффициенты, а потом восстановим функцию. В другом варианте сначала вычислим часть коэффициентов, частичные суммы базисных функций на подсчитанных коэффициентах, а затем итоговую функцию.

Первый вариант:
# Для всех <math>i=1..N_x, j=1..N_y, k=1..N_z</math> вычислить <math>C_{m,n,l}</math>.
# Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}</math>.

Второй вариант:
# Определим разбиение, например, <math>N_z</math> на <math>S</math> не пересекающихся подмножеств <math>[k_{0,s}, k_{1,s}]: \sqcup_{s=1}^{S}[k_{0,s}, k_{1,s}]=[1,N_z]</math>. Для всех <math>s=1..S:</math>
## Для всех <math>i=1..N_x, j=1..N_y, k=k_{0,s}..k_{1,s}</math> вычислить <math>C_{m,n,l}</math>.
## Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k}^{s} =
\Sigma_{m,n=1,l=k_{0,s}}^{N_x,N_y,k_{1,s}} C_{m,n,l} sin(\frac{\pi m x_i}{L_x})sin(\frac{\pi n y_j}{L_y})sin(\frac{\pi l z_k}{L_z})</math>.
# Для всех <math>i=1..M_x, j=1..M_y, k=1..M_z</math> вычислить <math>\hat{u}_{h,i,j,k} = \Sigma_{s=1}^{S}\hat{u}_{h,i,j,k}^{s} </math>

=== Схема реализации последовательного алгоритма ===

Опишем лишь первый вариант макроструктуры, так как второй имеет смысл рассматривать лишь в случае последовательной реализации.

'''Первый этап''' на языке Fortran (для наглядности упростим вложенные конструкции):
Do i j k = 1 1 1, Nx Ny Nz
r = 0.0D0
Do i0 j0 k0 = 1 1 1, Mx My Mz
x = i0*dx
y = j0*dy
z = k0*dz
r = r + dx*dy*dz*f(i0,j0,k0)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
c(i, j, k) = 8*r / (Pi**2*(Ly*Lz/Lx*i**2 + Lx*Lz/Ly*j**2 + Lx*Ly/Lz*k**2))
End Do

'''Второй этап''':
Do i0 j0 k0 = 1 1 1, M_x M_y M_z
x = i0*dx
y = j0*dy
z = k0*dz
s = 0.0D0
Do i j k = 1 1 1, N_x N_y N_z
s = s + c(i, j, k)*Sin(Pi*i*x/Lx)*Sin(Pi*j*y/Ly)*Sin(Pi*k*z/Lz)
End Do
u(i0, j0, k0) = s
End Do

=== Последовательная сложность алгоритма ===

Вычислительную сложность первого варианта алгоритма можно оценить как <math>O(N_x N_y N_z M_x M_y M_z)</math> операций с плавающей точкой.

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-11-28T14:27:17Z

Jhuighuy: Полностью удалено содержимое страницы

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-11-28T14:26:16Z

Jhuighuy:

Явная техника расщепления операторов для системы уравнений Навье-Стокса, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Данный алгоритм является одним из численных методов решения системы уравнений Навье-Стокса:
:<math>
\renewcommand{\vec}[1]{\mathbf{#1}}
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}

\newcommand{\nsVelocity}{\vec{v}}
\newcommand{\nsPressure}{p}

\newcommand{\nsForces}{\vec{g}}

\newcommand{\nsEquationMotion}{
\frac{\partial \nsVelocity}{\partial t} + (\nsVelocity, \nabla)\nsVelocity
= -\frac{1}{\rho}\nabla\nsPressure + \nu\laplace\nsVelocity + \vec{g}
}
\newcommand{\nsEquationContinuity}{
(\nabla, \nsVelocity) = 0
}
\newcommand{\nsSystem}{
\begin{cases}
\nsEquationMotion,
\\
\nsEquationContinuity.
\end{cases}
}
\nsSystem
</math>

На сегодняшний день одной из самых популярных стратегий численного решения системы уравнений Навье-Стокса является техника расщепления операторов. Концепция этих техник заключается в том, что исходная нелинейная система разбивается на несколько более простых уравнений, например, Пуассона, Бюргерса и несколько явных или неявных выражений для вычисления величин на новом временном слое. Сначала, отбросив уравнение неразрывности, вычисляется промежуточное ''предсказанное'' поле скоростей, а потом оно проецируется на соленоидальное поле.

=== Математическое описание алгоритма ===

Разложим производную по времени с первым порядком точности в момент <math>t = \tau l</math>:
:<math>
\newcommand{\nsVelocityL}{\nsVelocity^l}
\newcommand{\nsVelocityA}{\vec{v}^*}
\newcommand{\nsVelocityC}{\vec{v}^c}
\newcommand{\nsVelocityLp}{\nsVelocity^{l+1}}

\newcommand{\nsPressureL}{\nsPressure^l}
\newcommand{\nsPressureLp}{\nsPressure^{l+1}}

\newcommand{\nsForcesL}{\nsForces^l}

\newcommand{\nsPhiDy}{\frac{\partial\phi}{\partial y}}
\newcommand{\nsPhiDn}{\frac{\partial\phi}{\partial n}}

\begin{equation*}
\frac{\nsVelocityLp - \nsVelocityL}{\tau}
+ (\nsVelocityL, \nabla)\nsVelocityL
+ \frac{1}{\rho}\nabla\nsPressureL
= \nu\laplace\nsVelocityL
+ \nsForcesL.
\end{equation*}
</math>

Однако невозможно утверждать, что вычисленная скорость на новом временном слое на самом деле есть искомая величина, в силу того, что уравнение неразрывности не было учтено. Помимо того, отсутствует выражение для вычисления давления на следующем шаге по времени.
Поэтому будем считать, что вычисляемая по этой формуле величина является некоторой промежуточной ''предсказанной'' скоростью <math>\nsVelocityA</math>. Также добавим параметр <math>\beta</math> при градиенте давления для большей гибкости:

:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Разложим поле скоростей <math>\nsVelocityLp</math> на два (промежуточное поле <math>\nsVelocityA</math> и поле поправок <math>\nsVelocityC</math>) с таким условием, чтобы выполнялось уравнение неразрывности:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA + \nsVelocityC
\\
&(\nabla, \nsVelocityLp) = 0.
\end{split}
\end{equation*}
</math>

Скорость на новом временном слое выразим через исходное уравнение движения аналогично полю промежуточных скоростей, однако входящий в выражение член с градиентом давления будем вычислять неявным образом:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{1}{\rho}\nabla\nsPressureLp
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Теперь, вычитая <math>\nsVelocityA</math> из <math>\nsVelocityLp</math>, получим выражение для поля поправок:
:<math>
\begin{equation*}
\nsVelocityC
= \nsVelocityLp - \nsVelocityA
= -\frac{\tau}{\rho}\nabla(\nsPressureLp - \beta\nsPressureL).
\end{equation*}
</math>
Тогда, положив поле <math>\phi = \nsPressureLp - \beta\nsPressureL</math>, перейдем к новому выражению для скорости на следующем шаге по времени:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityA
- \frac{\tau}{\rho}\nabla\phi.
\end{equation*}
</math>
Необходимо потребовать выполнения уравнения неразрывности для <math>\nsVelocityLp</math>:
:<math>
\begin{equation*}
0
= (\nabla, \nsVelocityLp)
= (\nabla, \nsVelocityA - \frac{\tau}{\rho}\nabla\phi)
= (\nabla, \nsVelocityA) - \frac{\tau}{\rho}\laplace\phi.
\end{equation*}
</math>
Тем самым приходим к уравнению Пуассона относительно <math>\phi</math>:
:<math>
\begin{equation*}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA).
\end{equation*}
</math>

Решив уравнение Пуассона, можем найти явные формулы для вычисления давления и скорости на следующем временном слое:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

Подводя итоги, выпишем алгоритм для простейшей явной техники расщепления операторов:
* Вычисляем промежуточное поле скоростей:
:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL;
\end{equation*}
</math>
* Решаем уравнение Пуассона:
:<math>
\begin{equation*}
\begin{cases}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA),
\\
\nsPhiDn\bigl|_{\partial\Omega} = 0;
\end{cases}
\end{equation*}
</math>
* Находим значения скорости и давления на следующем шаге по времени:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

=== Вычислительное ядро алгоритма ===

Применим метод конечных разностей для решение системы уравнений Навье-Стокса в двухмерной прямоугольной области на равномерной сетке с начальными и краевыми данными течения Пуазёйля. Введем равномерную сетку <math>\omega</math> с шагами <math>\Delta x</math> и <math>\Delta y</math>:
:<math>
\begin{equation*}
\begin{split}
&\omega = \bigl[ (x_i, y_j),
i \in \overline{0,N_x},
j \in \overline{0,N_y} \bigl],
\\
&f_{i,j} = f(i\Delta x, j\Delta y).
\end{split}
\end{equation*}
</math>

Вычислительное ядро алгоритма состоит из вычислений по формулам конечных разностей для первых и вторых производных, а также скалярных произведений, возникающих при произведении матрицы на вектор, осуществляющегося в рамках итерационного метода для решения линейной системы уравнений дискретной задачи Пуассона. Выпишем, например, формулы для вторых частных производных скорости:
:<math>
\newcommand{\nsVelocityQ}{\vec{v}^{?}}

\newcommand{\nsVelocityQDx}{\frac{\partial\nsVelocityQ}{\partial x}}
\newcommand{\nsVelocityQDy}{\frac{\partial\nsVelocityQ}{\partial y}}

\newcommand{\nsVelocityQDxDx}{\frac{\partial^2 \nsVelocityQ}{\partial x^2}}
\newcommand{\nsVelocityQDyDy}{\frac{\partial^2 \nsVelocityQ}{\partial y^2}}

\newcommand{\nsPressureLDx}{\frac{\partial\nsPressureL}{\partial x}}
\newcommand{\nsPressureLDy}{\frac{\partial\nsPressureL}{\partial y}}

\begin{equation*}
\begin{split}
\nsVelocityQDyDy \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i,j+1}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i,j-1}}{\Delta y^2},
i \in \overline{0,N}, j \in \overline{1,M-1}.
\\
\nsVelocityQDxDx \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i+1,j}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i-1,j}}{\Delta x^2},
i \in \overline{1,N-1}, j \in \overline{1,M-1}.
\end{split}
\end{equation*}
</math>

В качественно итерационного метода выберем Стабилизированный Метод Бисопряженных Градиентов (BiCGStab). Данный метод выбран лишь потому, что матрица для дискретной задачи Пуассона не является симметрической. Для реализации этого метода требуется лишь операция умножения матрицы на вектор и скалярное произведение. Генерацию матрицы для задачи Пуассона добавлять в ядро не будем. Кратко опишем итерационный процесс:
;Подготовка перед итерационным процессом
# Выберем начальное приближение <math> x^0 </math>
# <math> r^0 = b - Ax^0</math>
# <math> \tilde{r} = r^0 </math>
# <math> \rho^0 = \alpha^0 = \omega^0 = 1 </math>
# <math> v^0 = p^0 = 0 </math>

;<math>k</math>-я итерация метода:
# <math>\rho^k = (\tilde{r}, r^{k-1})</math>
# <math> \beta^k = \frac{\rho^{k}}{\rho^{k-1}} \frac{\alpha^{k-1}}{\omega^{k-1}} </math>
# <math> p^k = r^{k-1} + \beta^k ( p^{k-1} - \omega^{k-1} v^{k-1} ) </math>
# <math> v^k = A p ^k </math>
# <math> \alpha^k = \frac{\rho^k}{(\tilde{r}, v^k)} </math>
# <math> s^k = r^{k-1} - \alpha v^k </math>
# <math> t^k = A s^k </math>
# <math> \omega^k = \frac{(t^k, s^k)} {(t^k, t^k)} </math>
# <math> x^k = x^{k-1} + \omega^k s^k + \alpha^k p^k </math>
# <math> r^k = s^k - \omega^k t^k</math>

=== Макроструктура алгоритма ===

Опишем макроструктуру в виде обновления полей скорости и давления на новом шаге по времени:

# Вычисление поля предсказанных скоростей (здесь и далее дифференциальные операторы аппроксимированы формулами конечных разностей) <math> \nsVelocityA </math>.
# Вычисление правой части для дискретного уравнения Пуассона: <math> \theta = \frac{\rho}{\tau}(\nabla, \nsVelocityA) </math>.
# Решение дискретной задачи Пуассона <math>Au = f, A \approx \laplace, u \approx \phi, f \approx \theta</math> методом BiCGStab.
# Вычисление поля скоростей на новом шаге по времени.
# Вычисление поля давления на новом шаге по времени.

=== Схема реализации последовательного алгоритма ===

1. Вычисление поля предсказанных скоростей (здесь и далее дифференциальные операторы аппроксимированы формулами конечных разностей) <math> \nsVelocityA </math>:
Do j=1, n_y-1
Do i=1, n_x-1
v_ast(i, j, :) = v_l(i, j, :) - Tau*dv_dv(i, j, v_l, v_l) &
- Tau*Beta*grad_p(i, j, p_l) + Tau/Re*lap_v(i, j, v_l)
End Do
End Do

2. Вычисление правой части для дискретного уравнения Пуассона:
Do j=1, n_y-1
Do i=1, n_x-1
Theta(i, j) = 1.0D0/Tau*div_v(i, j, v_ast, v_flags)
End Do
End Do

3. Решение дискретной задачи Пуассона <math>Au = f, A \approx \laplace, u \approx \phi, f \approx \theta</math> методом BiCGStab: 

3.1. Конвертирование поля <math>\theta</math> в вектор <math>f</math> с учетом граничных условий, где переменная indices отображает двумерную индексацию в одномерную, введена для удобства в случае не прямоугольной области:
Do j=0, n_y
f(indices(1, j)) = Theta(1, j)*d_y**2 + (Beta-1.0)*b*p_0
Do i=2, n_x-2
f(indices(i, j)) = Theta(i, j)*d_y**2
End Do
f(indices(n_x-1, j)) = Theta(n_x-1, j)*d_y**2 + (Beta-1.0)*b*p_1
End Do

3.2. Решение дискретного уравнения Пуассона:
Call solve_bicgstab(A, u, f)

3.3. Конвертирование вектора <math>u</math> в скалярное поле <math>\phi</math>:
Do j=0, n_y
Do i=1, n_x-1
Phi(i, j) = u(indices(i, j))
End Do
End Do

4. Вычисление поля скоростей на новом шаге по времени:
Do j=1, n_y-1
Do i=1, n_x
v_l(i, j, :) = v_ast(i, j, :) - Tau*grad_phi(i, j, Phi)
End Do
End Do

5. Вычисление поля давления на новом шаге по времени:
Do j=0, n_y
Do i=1, n_x-1
p_l(i, j) = Phi(i, j) + Beta*p_l(i, j)
End Do
End Do

=== Последовательная сложность алгоритма ===

Первый, второй, четвертый и пятый этапы занимают <math>O(N_x N_y)</math> операций умножения и деления.

=== Информационный граф ===

Кек

=== Ресурс параллелизма алгоритма ===

Кек

=== Входные и выходные данные алгоритма ===

Кек

=== Свойства алгоритма ===

==Программная реализация алгоритма ==

Кек

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

Кек

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Кек

==Литература==
Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-11-26T13:08:38Z

Jhuighuy:

Явная техника расщепления операторов для системы уравнений Навье-Стокса, Бутаков О.Б. 404 группа.

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Данный алгоритм является одним из численных методов решения системы уравнений Навье-Стокса:
:<math>
\renewcommand{\vec}[1]{\mathbf{#1}}
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}

\newcommand{\nsVelocity}{\vec{v}}
\newcommand{\nsPressure}{p}

\newcommand{\nsForces}{\vec{g}}

\newcommand{\nsEquationMotion}{
\frac{\partial \nsVelocity}{\partial t} + (\nsVelocity, \nabla)\nsVelocity
= -\frac{1}{\rho}\nabla\nsPressure + \nu\laplace\nsVelocity + \vec{g}
}
\newcommand{\nsEquationContinuity}{
(\nabla, \nsVelocity) = 0
}
\newcommand{\nsSystem}{
\begin{cases}
\nsEquationMotion,
\\
\nsEquationContinuity.
\end{cases}
}
\nsSystem
</math>

На сегодняшний день одной из самых популярных стратегий численного решения системы уравнений Навье-Стокса является техника расщепления операторов. Концепция этих техник заключается в том, что исходная нелинейная система разбивается на несколько более простых уравнений, например, Пуассона, Бюргерса и несколько явных или неявных выражений для вычисления величин на новом временном слое. Сначала, отбросив уравнение неразрывности, вычисляется промежуточное ''предсказанное'' поле скоростей, а потом оно проецируется на соленоидальное поле.

=== Математическое описание алгоритма ===

Разложим производную по времени с первым порядком точности в момент <math>t = \tau l</math>:
:<math>
\newcommand{\nsVelocityL}{\nsVelocity^l}
\newcommand{\nsVelocityA}{\vec{v}^*}
\newcommand{\nsVelocityC}{\vec{v}^c}
\newcommand{\nsVelocityLp}{\nsVelocity^{l+1}}

\newcommand{\nsPressureL}{\nsPressure^l}
\newcommand{\nsPressureLp}{\nsPressure^{l+1}}

\newcommand{\nsForcesL}{\nsForces^l}

\newcommand{\nsPhiDy}{\frac{\partial\phi}{\partial y}}
\newcommand{\nsPhiDn}{\frac{\partial\phi}{\partial n}}

\begin{equation*}
\frac{\nsVelocityLp - \nsVelocityL}{\tau}
+ (\nsVelocityL, \nabla)\nsVelocityL
+ \frac{1}{\rho}\nabla\nsPressureL
= \nu\laplace\nsVelocityL
+ \nsForcesL.
\end{equation*}
</math>

Однако невозможно утверждать, что вычисленная скорость на новом временном слое на самом деле есть искомая величина, в силу того, что уравнение неразрывности не было учтено. Помимо того, отсутствует выражение для вычисления давления на следующем шаге по времени.
Поэтому будем считать, что вычисляемая по этой формуле величина является некоторой промежуточной ''предсказанной'' скоростью <math>\nsVelocityA</math>. Также добавим параметр <math>\beta</math> при градиенте давления для большей гибкости:

:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Разложим поле скоростей <math>\nsVelocityLp</math> на два (промежуточное поле <math>\nsVelocityA</math> и поле поправок <math>\nsVelocityC</math>) с таким условием, чтобы выполнялось уравнение неразрывности:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA + \nsVelocityC
\\
&(\nabla, \nsVelocityLp) = 0.
\end{split}
\end{equation*}
</math>

Скорость на новом временном слое выразим через исходное уравнение движения аналогично полю промежуточных скоростей, однако входящий в выражение член с градиентом давления будем вычислять неявным образом:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{1}{\rho}\nabla\nsPressureLp
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Теперь, вычитая <math>\nsVelocityA</math> из <math>\nsVelocityLp</math>, получим выражение для поля поправок:
:<math>
\begin{equation*}
\nsVelocityC
= \nsVelocityLp - \nsVelocityA
= -\frac{\tau}{\rho}\nabla(\nsPressureLp - \beta\nsPressureL).
\end{equation*}
</math>
Тогда, положив поле <math>\phi = \nsPressureLp - \beta\nsPressureL</math>, перейдем к новому выражению для скорости на следующем шаге по времени:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityA
- \frac{\tau}{\rho}\nabla\phi.
\end{equation*}
</math>
Необходимо потребовать выполнения уравнения неразрывности для <math>\nsVelocityLp</math>:
:<math>
\begin{equation*}
0
= (\nabla, \nsVelocityLp)
= (\nabla, \nsVelocityA - \frac{\tau}{\rho}\nabla\phi)
= (\nabla, \nsVelocityA) - \frac{\tau}{\rho}\laplace\phi.
\end{equation*}
</math>
Тем самым приходим к уравнению Пуассона относительно <math>\phi</math>:
:<math>
\begin{equation*}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA).
\end{equation*}
</math>

Решив уравнение Пуассона, можем найти явные формулы для вычисления давления и скорости на следующем временном слое:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

Подводя итоги, выпишем алгоритм для простейшей явной техники расщепления операторов:
* Вычисляем промежуточное поле скоростей:
:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL;
\end{equation*}
</math>
* Решаем уравнение Пуассона:
:<math>
\begin{equation*}
\begin{cases}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA),
\\
\nsPhiDn\bigl|_{\partial\Omega} = 0;
\end{cases}
\end{equation*}
</math>
* Находим значения скорости и давления на следующем шаге по времени:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

=== Вычислительное ядро алгоритма ===

Применим метод конечных разностей для решение системы уравнений Навье-Стокса в двухмерной прямоугольной области на равномерной сетке с начальными и краевыми данными течения Пуазёйля. Введем равномерную сетку <math>\omega</math> с шагами <math>\Delta x</math> и <math>\Delta y</math>:
:<math>
\begin{equation*}
\begin{split}
&\omega = \bigl[ (x_i, y_j),
i \in \overline{0,N_x},
j \in \overline{0,N_y} \bigl],
\\
&f_{i,j} = f(i\Delta x, j\Delta y).
\end{split}
\end{equation*}
</math>

Вычислительное ядро алгоритма состоит из вычислений по формулам конечных разностей для первых и вторых производных, а также скалярных произведений, возникающих при произведении матрицы на вектор, осуществляющегося в рамках итерационного метода для решения линейной системы уравнений дискретной задачи Пуассона. Выпишем, например, формулы для вторых частных производных скорости:
:<math>
\newcommand{\nsVelocityQ}{\vec{v}^{?}}

\newcommand{\nsVelocityQDx}{\frac{\partial\nsVelocityQ}{\partial x}}
\newcommand{\nsVelocityQDy}{\frac{\partial\nsVelocityQ}{\partial y}}

\newcommand{\nsVelocityQDxDx}{\frac{\partial^2 \nsVelocityQ}{\partial x^2}}
\newcommand{\nsVelocityQDyDy}{\frac{\partial^2 \nsVelocityQ}{\partial y^2}}

\newcommand{\nsPressureLDx}{\frac{\partial\nsPressureL}{\partial x}}
\newcommand{\nsPressureLDy}{\frac{\partial\nsPressureL}{\partial y}}

\begin{equation*}
\begin{split}
\nsVelocityQDyDy \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i,j+1}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i,j-1}}{\Delta y^2},
i \in \overline{0,N}, j \in \overline{1,M-1}.
\\
\nsVelocityQDxDx \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i+1,j}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i-1,j}}{\Delta x^2},
i \in \overline{1,N-1}, j \in \overline{1,M-1}.
\end{split}
\end{equation*}
</math>

В качественно итерационного метода выберем Стабилизированный Метод Бисопряженных Градиентов (BiCGStab). Данный метод выбран лишь потому, что матрица для дискретной задачи Пуассона не является симметрической. Для реализации этого метода требуется лишь операция умножения матрицы на вектор и скалярное произведение. Генерацию матрицы для задачи Пуассона добавлять в ядро не будем. Кратко опишем итерационный процесс:
;Подготовка перед итерационным процессом
# Выберем начальное приближение <math> x^0 </math>
# <math> r^0 = b - Ax^0</math>
# <math> \tilde{r} = r^0 </math>
# <math> \rho^0 = \alpha^0 = \omega^0 = 1 </math>
# <math> v^0 = p^0 = 0 </math>

;<math>k</math>-я итерация метода:
# <math>\rho^k = (\tilde{r}, r^{k-1})</math>
# <math> \beta^k = \frac{\rho^{k}}{\rho^{k-1}} \frac{\alpha^{k-1}}{\omega^{k-1}} </math>
# <math> p^k = r^{k-1} + \beta^k ( p^{k-1} - \omega^{k-1} v^{k-1} ) </math>
# <math> v^k = A p ^k </math>
# <math> \alpha^k = \frac{\rho^k}{(\tilde{r}, v^k)} </math>
# <math> s^k = r^{k-1} - \alpha v^k </math>
# <math> t^k = A s^k </math>
# <math> \omega^k = \frac{(t^k, s^k)} {(t^k, t^k)} </math>
# <math> x^k = x^{k-1} + \omega^k s^k + \alpha^k p^k </math>
# <math> r^k = s^k - \omega^k t^k</math>

=== Макроструктура алгоритма ===

Опишем макроструктуру в виде обновления полей скорости и давления на новом шаге по времени:

# Вычисление поля предсказанных скоростей (здесь и далее дифференциальные операторы аппроксимированы формулами конечных разностей) <math> \nsVelocityA </math>.
# Вычисление правой части для дискретного уравнения Пуассона: <math> \theta = \frac{\rho}{\tau}(\nabla, \nsVelocityA) </math>.
# Решение дискретной задачи Пуассона <math>Au = f, A \approx \laplace, u \approx \phi, f \approx \theta</math> методом BiCGStab.
# Вычисление поля скоростей на новом шаге по времени.
# Вычисление поля давления на новом шаге по времени.

=== Схема реализации последовательного алгоритма ===

1. Вычисление поля предсказанных скоростей (здесь и далее дифференциальные операторы аппроксимированы формулами конечных разностей) <math> \nsVelocityA </math>:
Do j=1, n_y-1
Do i=1, n_x-1
v_ast(i, j, :) = v_l(i, j, :) - Tau*dv_dv(i, j, v_l, v_l) &
- Tau*Beta*grad_p(i, j, p_l) + Tau/Re*lap_v(i, j, v_l)
End Do
End Do

2. Вычисление правой части для дискретного уравнения Пуассона:
Do j=1, n_y-1
Do i=1, n_x-1
Theta(i, j) = 1.0D0/Tau*div_v(i, j, v_ast, v_flags)
End Do
End Do

3. Решение дискретной задачи Пуассона <math>Au = f, A \approx \laplace, u \approx \phi, f \approx \theta</math> методом BiCGStab: 
3.1. Конвертирование поля <math>\theta</math> в вектор <math>f</math> с учетом граничных условий, где переменная indices отображает двумерную индексацию в одномерную, введена для удобства в случае не прямоугольной области:
Do j=0, n_y
f(indices(1, j)) = Theta(1, j)*d_y**2 + (Beta-1.0)*b*p_0
Do i=2, n_x-2
f(indices(i, j)) = Theta(i, j)*d_y**2
End Do
f(indices(n_x-1, j)) = Theta(n_x-1, j)*d_y**2 + (Beta-1.0)*b*p_1
End Do
3.2. Решение дискретного уравнения Пуассона:
Call solve_bicgstab(A, u, f)
3.3. Конвертирование вектора <math>u</math> в скалярное поле <math>\phi</math>:
Do j=0, n_y
Do i=1, n_x-1
Phi(i, j) = u(indices(i, j))
End Do
End Do

4. Вычисление поля скоростей на новом шаге по времени:
Do j=1, n_y-1
Do i=1, n_x
v_l(i, j, :) = v_ast(i, j, :) - Tau*grad_phi(i, j, Phi)
End Do
End Do

5. Вычисление поля давления на новом шаге по времени:
Do j=0, n_y
Do i=1, n_x-1
p_l(i, j) = Phi(i, j) + Beta*p_l(i, j)
End Do
End Do

=== Последовательная сложность алгоритма ===

Первый, второй, четвертый и пятый этапы занимают <math>O(N_x N_y)</math> операций умножения и деления.

==Программная реализация алгоритма ==

==Литература==
Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-10-24T05:24:14Z

Jhuighuy: /* Свойства и структура алгоритма */

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Данный алгоритм является одним из численных методов решения системы уравнений Навье-Стокса:
:<math>
\renewcommand{\vec}[1]{\mathbf{#1}}
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}

\newcommand{\nsVelocity}{\vec{v}}
\newcommand{\nsPressure}{p}

\newcommand{\nsForces}{\vec{g}}

\newcommand{\nsEquationMotion}{
\frac{\partial \nsVelocity}{\partial t} + (\nsVelocity, \nabla)\nsVelocity
= -\frac{1}{\rho}\nabla\nsPressure + \nu\laplace\nsVelocity + \vec{g}
}
\newcommand{\nsEquationContinuity}{
(\nabla, \nsVelocity) = 0
}
\newcommand{\nsSystem}{
\begin{cases}
\nsEquationMotion,
\\
\nsEquationContinuity.
\end{cases}
}
\nsSystem
</math>

На сегодняшний день одной из самых популярных стратегий численного решения системы уравнений Навье-Стокса является техника расщепления операторов. Концепция этих техник заключается в том, что исходная нелинейная система разбивается на несколько более простых уравнений, например, Пуассона, Бюргерса и несколько явных или неявных выражений для вычисления величин на новом временном слое. Сначала, отбросив уравнение неразрывности, вычисляется промежуточное ''предсказанное'' поле скоростей, а потом оно проецируется на соленоидальное поле.

=== Математическое описание алгоритма ===

Разложим производную по времени с первым порядком точности в момент <math>t = \tau l</math>:
:<math>
\newcommand{\nsVelocityL}{\nsVelocity^l}
\newcommand{\nsVelocityA}{\vec{v}^*}
\newcommand{\nsVelocityC}{\vec{v}^c}
\newcommand{\nsVelocityLp}{\nsVelocity^{l+1}}

\newcommand{\nsPressureL}{\nsPressure^l}
\newcommand{\nsPressureLp}{\nsPressure^{l+1}}

\newcommand{\nsForcesL}{\nsForces^l}

\newcommand{\nsPhiDy}{\frac{\partial\phi}{\partial y}}
\newcommand{\nsPhiDn}{\frac{\partial\phi}{\partial n}}

\begin{equation*}
\frac{\nsVelocityLp - \nsVelocityL}{\tau}
+ (\nsVelocityL, \nabla)\nsVelocityL
+ \frac{1}{\rho}\nabla\nsPressureL
= \nu\laplace\nsVelocityL
+ \nsForcesL.
\end{equation*}
</math>

Однако невозможно утверждать, что вычисленная скорость на новом временном слое на самом деле есть искомая величина, в силу того, что уравнение неразрывности не было учтено. Помимо того, отсутствует выражение для вычисления давления на следующем шаге по времени.
Поэтому будем считать, что вычисляемая по этой формуле величина является некоторой промежуточной ''предсказанной'' скоростью <math>\nsVelocityA</math>. Также добавим параметр <math>\beta</math> при градиенте давления для большей гибкости:

:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Разложим поле скоростей <math>\nsVelocityLp</math> на два (промежуточное поле <math>\nsVelocityA</math> и поле поправок <math>\nsVelocityC</math>) с таким условием, чтобы выполнялось уравнение неразрывности:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA + \nsVelocityC
\\
&(\nabla, \nsVelocityLp) = 0.
\end{split}
\end{equation*}
</math>

Скорость на новом временном слое выразим через исходное уравнение движения аналогично полю промежуточных скоростей, однако входящий в выражение член с градиентом давления будем вычислять неявным образом:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{1}{\rho}\nabla\nsPressureLp
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Теперь, вычитая <math>\nsVelocityA</math> из <math>\nsVelocityLp</math>, получим выражение для поля поправок:
:<math>
\begin{equation*}
\nsVelocityC
= \nsVelocityLp - \nsVelocityA
= -\frac{\tau}{\rho}\nabla(\nsPressureLp - \beta\nsPressureL).
\end{equation*}
</math>
Тогда, положив поле <math>\phi = \nsPressureLp - \beta\nsPressureL</math>, перейдем к новому выражению для скорости на следующем шаге по времени:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityA
- \frac{\tau}{\rho}\nabla\phi.
\end{equation*}
</math>
Необходимо потребовать выполнения уравнения неразрывности для <math>\nsVelocityLp</math>:
:<math>
\begin{equation*}
0
= (\nabla, \nsVelocityLp)
= (\nabla, \nsVelocityA - \frac{\tau}{\rho}\nabla\phi)
= (\nabla, \nsVelocityA) - \frac{\tau}{\rho}\laplace\phi.
\end{equation*}
</math>
Тем самым приходим к уравнению Пуассона относительно <math>\phi</math>:
:<math>
\begin{equation*}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA).
\end{equation*}
</math>

Решив уравнение Пуассона, можем найти явные формулы для вычисления давления и скорости на следующем временном слое:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

Подводя итоги, выпишем алгоритм для простейшей явной техники расщепления операторов:
* Вычисляем промежуточное поле скоростей:
:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL;
\end{equation*}
</math>
* Решаем уравнение Пуассона:
:<math>
\begin{equation*}
\begin{cases}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA),
\\
\nsPhiDn\bigl|_{\partial\Omega} = 0;
\end{cases}
\end{equation*}
</math>
* Находим значения скорости и давления на следующем шаге по времени:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

=== Вычислительное ядро алгоритма ===

Применим метод конечных разностей для решение системы уравнений Навье-Стокса в двухмерной прямоугольной области на равномерной сетке с начальными и краевыми данными течения Пуазёйля. Введем равномерную сетку <math>\omega</math> с шагами <math>\Delta x</math> и <math>\Delta y</math>:
:<math>
\begin{equation*}
\begin{split}
&\omega = \bigl[ (x_i, y_j),
i \in \overline{0,N},
j \in \overline{0,M} \bigl],
\\
&f_{i,j} = f(i\Delta x, j\Delta y).
\end{split}
\end{equation*}
</math>

Вычислительное ядро алгоритма состоит из вычислений по формулам конечных разностей для первых и вторых производных, а также скалярных произведений, возникающих при произведении матрицы на вектор, осуществляющегося в рамках итерационного метода для решения линейной системы уравнений дискретной задачи Пуассона. Выпишем, например, формулы для вторых частных производных скорости:
:<math>
\newcommand{\nsVelocityQ}{\vec{v}^{?}}

\newcommand{\nsVelocityQDx}{\frac{\partial\nsVelocityQ}{\partial x}}
\newcommand{\nsVelocityQDy}{\frac{\partial\nsVelocityQ}{\partial y}}

\newcommand{\nsVelocityQDxDx}{\frac{\partial^2 \nsVelocityQ}{\partial x^2}}
\newcommand{\nsVelocityQDyDy}{\frac{\partial^2 \nsVelocityQ}{\partial y^2}}

\newcommand{\nsPressureLDx}{\frac{\partial\nsPressureL}{\partial x}}
\newcommand{\nsPressureLDy}{\frac{\partial\nsPressureL}{\partial y}}

\begin{equation*}
\begin{split}
\nsVelocityQDyDy \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i,j+1}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i,j-1}}{\Delta y^2},
i \in \overline{0,N}, j \in \overline{1,M-1}.
\\
\nsVelocityQDxDx \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i+1,j}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i-1,j}}{\Delta x^2},
i \in \overline{1,N-1}, j \in \overline{1,M-1}.
\end{split}
\end{equation*}
</math>

В качественно итерационного метода выберем Стабилизированный Метод Бисопряженных Градиентов (BiCGStab). Данный метод выбран лишь потому, что матрица для дискретной задачи Пуассона не является симметрической. Для реализации этого метода требуется лишь операция умножения матрицы на вектор и скалярное произведение. Генерацию матрицы для задачи Пуассона добавлять в ядро не будем. Кратко опишем итерационный процесс:
;Подготовка перед итерационным процессом
# Выберем начальное приближение <math> x^0 </math>
# <math> r^0 = b - Ax^0</math>
# <math> \tilde{r} = r^0 </math>
# <math> \rho^0 = \alpha^0 = \omega^0 = 1 </math>
# <math> v^0 = p^0 = 0 </math>

;<math>k</math>-я итерация метода:
# <math>\rho^k = (\tilde{r}, r^{k-1})</math>
# <math> \beta^k = \frac{\rho^{k}}{\rho^{k-1}} \frac{\alpha^{k-1}}{\omega^{k-1}} </math>
# <math> p^k = r^{k-1} + \beta^k ( p^{k-1} - \omega^{k-1} v^{k-1} ) </math>
# <math> v^k = A p ^k </math>
# <math> \alpha^k = \frac{\rho^k}{(\tilde{r}, v^k)} </math>
# <math> s^k = r^{k-1} - \alpha v^k </math>
# <math> t^k = A s^k </math>
# <math> \omega^k = \frac{(t^k, s^k)} {(t^k, t^k)} </math>
# <math> x^k = x^{k-1} + \omega^k s^k + \alpha^k p^k </math>
# <math> r^k = s^k - \omega^k t^k</math>

* Вычисление промежуточных полей по формулам конечных разностей.
* Решение дискретной задачи Пуассона.
* Вычисление искомых параметров задачи на новом временном слое по формулам конечных разностей.

==Программная реализация алгоритма ==

==Литература==
Абакумов М.В., Гулин А.В. Лекции по численным методам математической физики: Учеб. пособие. - М.:ИНФРА-М,2013

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-10-21T21:38:59Z

Jhuighuy:

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-10-21T21:38:49Z

Jhuighuy: /* Вычислительное ядро алгоритма */

Кек

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Данный алгоритм является одним из численных методов решения системы уравнений Навье-Стокса:
:<math>
\renewcommand{\vec}[1]{\mathbf{#1}}
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}

\newcommand{\nsVelocity}{\vec{v}}
\newcommand{\nsPressure}{p}

\newcommand{\nsForces}{\vec{g}}

\newcommand{\nsEquationMotion}{
\frac{\partial \nsVelocity}{\partial t} + (\nsVelocity, \nabla)\nsVelocity
= -\frac{1}{\rho}\nabla\nsPressure + \nu\laplace\nsVelocity + \vec{g}
}
\newcommand{\nsEquationContinuity}{
(\nabla, \nsVelocity) = 0
}
\newcommand{\nsSystem}{
\begin{cases}
\nsEquationMotion,
\\
\nsEquationContinuity.
\end{cases}
}
\nsSystem
</math>

На сегодняшний день одной из самых популярных стратегий численного решения системы уравнений Навье-Стокса является техника расщепления операторов. Концепция этих техник заключается в том, что исходная нелинейная система разбивается на несколько более простых уравнений, например, Пуассона, Бюргерса и несколько явных или неявных выражений для вычисления величин на новом временном слое. Сначала, отбросив уравнение неразрывности, вычисляется промежуточное ''предсказанное'' поле скоростей, а потом оно проецируется на соленоидальное поле.

=== Математическое описание алгоритма ===

Разложим производную по времени с первым порядком точности в момент <math>t = \tau l</math>:
:<math>
\newcommand{\nsVelocityL}{\nsVelocity^l}
\newcommand{\nsVelocityA}{\vec{v}^*}
\newcommand{\nsVelocityC}{\vec{v}^c}
\newcommand{\nsVelocityLp}{\nsVelocity^{l+1}}

\newcommand{\nsPressureL}{\nsPressure^l}
\newcommand{\nsPressureLp}{\nsPressure^{l+1}}

\newcommand{\nsForcesL}{\nsForces^l}

\newcommand{\nsPhiDy}{\frac{\partial\phi}{\partial y}}
\newcommand{\nsPhiDn}{\frac{\partial\phi}{\partial n}}

\begin{equation*}
\frac{\nsVelocityLp - \nsVelocityL}{\tau}
+ (\nsVelocityL, \nabla)\nsVelocityL
+ \frac{1}{\rho}\nabla\nsPressureL
= \nu\laplace\nsVelocityL
+ \nsForcesL.
\end{equation*}
</math>

Однако невозможно утверждать, что вычисленная скорость на новом временном слое на самом деле есть искомая величина, в силу того, что уравнение неразрывности не было учтено. Помимо того, отсутствует выражение для вычисления давления на следующем шаге по времени.
Поэтому будем считать, что вычисляемая по этой формуле величина является некоторой промежуточной ''предсказанной'' скоростью <math>\nsVelocityA</math>. Также добавим параметр <math>\beta</math> при градиенте давления для большей гибкости:

:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Разложим поле скоростей <math>\nsVelocityLp</math> на два (промежуточное поле <math>\nsVelocityA</math> и поле поправок <math>\nsVelocityC</math>) с таким условием, чтобы выполнялось уравнение неразрывности:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA + \nsVelocityC
\\
&(\nabla, \nsVelocityLp) = 0.
\end{split}
\end{equation*}
</math>

Скорость на новом временном слое выразим через исходное уравнение движения аналогично полю промежуточных скоростей, однако входящий в выражение член с градиентом давления будем вычислять неявным образом:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{1}{\rho}\nabla\nsPressureLp
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Теперь, вычитая <math>\nsVelocityA</math> из <math>\nsVelocityLp</math>, получим выражение для поля поправок:
:<math>
\begin{equation*}
\nsVelocityC
= \nsVelocityLp - \nsVelocityA
= -\frac{\tau}{\rho}\nabla(\nsPressureLp - \beta\nsPressureL).
\end{equation*}
</math>
Тогда, положив поле <math>\phi = \nsPressureLp - \beta\nsPressureL</math>, перейдем к новому выражению для скорости на следующем шаге по времени:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityA
- \frac{\tau}{\rho}\nabla\phi.
\end{equation*}
</math>
Необходимо потребовать выполнения уравнения неразрывности для <math>\nsVelocityLp</math>:
:<math>
\begin{equation*}
0
= (\nabla, \nsVelocityLp)
= (\nabla, \nsVelocityA - \frac{\tau}{\rho}\nabla\phi)
= (\nabla, \nsVelocityA) - \frac{\tau}{\rho}\laplace\phi.
\end{equation*}
</math>
Тем самым приходим к уравнению Пуассона относительно <math>\phi</math>:
:<math>
\begin{equation*}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA).
\end{equation*}
</math>

Решив уравнение Пуассона, можем найти явные формулы для вычисления давления и скорости на следующем временном слое:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

Подводя итоги, выпишем алгоритм для простейшей явной техники расщепления операторов:
* Вычисляем промежуточное поле скоростей:
:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL;
\end{equation*}
</math>
* Решаем уравнение Пуассона:
:<math>
\begin{equation*}
\begin{cases}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA),
\\
\nsPhiDn\bigl|_{\partial\Omega} = 0;
\end{cases}
\end{equation*}
</math>
* Находим значения скорости и давления на следующем шаге по времени:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

=== Вычислительное ядро алгоритма ===

Применим метод конечных разностей для решение системы уравнений Навье-Стокса в двухмерной прямоугольной области на равномерной сетке с начальными и краевыми данными течения Пуазёйля. Введем равномерную сетку <math>\omega</math> с шагами <math>\Delta x</math> и <math>\Delta y</math>:
:<math>
\begin{equation*}
\begin{split}
&\omega = \bigl[ (x_i, y_j),
i \in \overline{0,N},
j \in \overline{0,M} \bigl],
\\
&f_{i,j} = f(i\Delta x, j\Delta y).
\end{split}
\end{equation*}
</math>

Вычислительное ядро алгоритма состоит из вычислений по формулам конечных разностей для первых и вторых производных, а также скалярных произведений, возникающих при произведении матрицы на вектор, осуществляющегося в рамках итерационного метода для решения линейной системы уравнений дискретной задачи Пуассона. Выпишем, например, формулы для вторых частных производных скорости:
:<math>
\newcommand{\nsVelocityQ}{\vec{v}^{?}}

\newcommand{\nsVelocityQDx}{\frac{\partial\nsVelocityQ}{\partial x}}
\newcommand{\nsVelocityQDy}{\frac{\partial\nsVelocityQ}{\partial y}}

\newcommand{\nsVelocityQDxDx}{\frac{\partial^2 \nsVelocityQ}{\partial x^2}}
\newcommand{\nsVelocityQDyDy}{\frac{\partial^2 \nsVelocityQ}{\partial y^2}}

\newcommand{\nsPressureLDx}{\frac{\partial\nsPressureL}{\partial x}}
\newcommand{\nsPressureLDy}{\frac{\partial\nsPressureL}{\partial y}}

\begin{equation*}
\begin{split}
\nsVelocityQDyDy \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i,j+1}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i,j-1}}{\Delta y^2},
i \in \overline{0,N}, j \in \overline{1,M-1}.
\\
\nsVelocityQDxDx \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i+1,j}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i-1,j}}{\Delta x^2},
i \in \overline{1,N-1}, j \in \overline{1,M-1}.
\end{split}
\end{equation*}
</math>

В качественно итерационного метода выберем Стабилизированный Метод Бисопряженных Градиентов (BiCGStab). Данный метод выбран лишь потому, что матрица для дискретной задачи Пуассона не является симметрической. Для реализации этого метода требуется лишь операция умножения матрицы на вектор и скалярное произведение. Генерацию матрицы для задачи Пуассона добавлять в ядро не будем. Кратко опишем итерационный процесс:
;Подготовка перед итерационным процессом
# Выберем начальное приближение <math> x^0 </math>
# <math> r^0 = b - Ax^0</math>
# <math> \tilde{r} = r^0 </math>
# <math> \rho^0 = \alpha^0 = \omega^0 = 1 </math>
# <math> v^0 = p^0 = 0 </math>

;<math>k</math>-я итерация метода:
# <math>\rho^k = (\tilde{r}, r^{k-1})</math>
# <math> \beta^k = \frac{\rho^{k}}{\rho^{k-1}} \frac{\alpha^{k-1}}{\omega^{k-1}} </math>
# <math> p^k = r^{k-1} + \beta^k ( p^{k-1} - \omega^{k-1} v^{k-1} ) </math>
# <math> v^k = A p ^k </math>
# <math> \alpha^k = \frac{\rho^k}{(\tilde{r}, v^k)} </math>
# <math> s^k = r^{k-1} - \alpha v^k </math>
# <math> t^k = A s^k </math>
# <math> \omega^k = \frac{(t^k, s^k)} {(t^k, t^k)} </math>
# <math> x^k = x^{k-1} + \omega^k s^k + \alpha^k p^k </math>
# <math> r^k = s^k - \omega^k t^k</math>

* Вычисление промежуточных полей по формулам конечных разностей.
* Решение дискретной задачи Пуассона.
* Вычисление искомых параметров задачи на новом временном слое по формулам конечных разностей.

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-10-21T21:37:03Z

Jhuighuy: /* Вычислительное ядро алгоритма */

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-10-21T21:27:56Z

Jhuighuy:

Кек

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Данный алгоритм является одним из численных методов решения системы уравнений Навье-Стокса:
:<math>
\renewcommand{\vec}[1]{\mathbf{#1}}
\newcommand{\laplace}{\mathop{}\!\mathbin\bigtriangleup}

\newcommand{\nsVelocity}{\vec{v}}
\newcommand{\nsPressure}{p}

\newcommand{\nsForces}{\vec{g}}

\newcommand{\nsEquationMotion}{
\frac{\partial \nsVelocity}{\partial t} + (\nsVelocity, \nabla)\nsVelocity
= -\frac{1}{\rho}\nabla\nsPressure + \nu\laplace\nsVelocity + \vec{g}
}
\newcommand{\nsEquationContinuity}{
(\nabla, \nsVelocity) = 0
}
\newcommand{\nsSystem}{
\begin{cases}
\nsEquationMotion,
\\
\nsEquationContinuity.
\end{cases}
}
\nsSystem
</math>

На сегодняшний день одной из самых популярных стратегий численного решения системы уравнений Навье-Стокса является техника расщепления операторов. Концепция этих техник заключается в том, что исходная нелинейная система разбивается на несколько более простых уравнений, например, Пуассона, Бюргерса и несколько явных или неявных выражений для вычисления величин на новом временном слое. Сначала, отбросив уравнение неразрывности, вычисляется промежуточное ''предсказанное'' поле скоростей, а потом оно проецируется на соленоидальное поле.

=== Математическое описание алгоритма ===

Разложим производную по времени с первым порядком точности в момент <math>t = \tau l</math>:
:<math>
\newcommand{\nsVelocityL}{\nsVelocity^l}
\newcommand{\nsVelocityA}{\vec{v}^*}
\newcommand{\nsVelocityC}{\vec{v}^c}
\newcommand{\nsVelocityLp}{\nsVelocity^{l+1}}

\newcommand{\nsPressureL}{\nsPressure^l}
\newcommand{\nsPressureLp}{\nsPressure^{l+1}}

\newcommand{\nsForcesL}{\nsForces^l}

\newcommand{\nsPhiDy}{\frac{\partial\phi}{\partial y}}
\newcommand{\nsPhiDn}{\frac{\partial\phi}{\partial n}}

\begin{equation*}
\frac{\nsVelocityLp - \nsVelocityL}{\tau}
+ (\nsVelocityL, \nabla)\nsVelocityL
+ \frac{1}{\rho}\nabla\nsPressureL
= \nu\laplace\nsVelocityL
+ \nsForcesL.
\end{equation*}
</math>

Однако невозможно утверждать, что вычисленная скорость на новом временном слое на самом деле есть искомая величина, в силу того, что уравнение неразрывности не было учтено. Помимо того, отсутствует выражение для вычисления давления на следующем шаге по времени.
Поэтому будем считать, что вычисляемая по этой формуле величина является некоторой промежуточной ''предсказанной'' скоростью <math>\nsVelocityA</math>. Также добавим параметр <math>\beta</math> при градиенте давления для большей гибкости:

:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Разложим поле скоростей <math>\nsVelocityLp</math> на два (промежуточное поле <math>\nsVelocityA</math> и поле поправок <math>\nsVelocityC</math>) с таким условием, чтобы выполнялось уравнение неразрывности:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA + \nsVelocityC
\\
&(\nabla, \nsVelocityLp) = 0.
\end{split}
\end{equation*}
</math>

Скорость на новом временном слое выразим через исходное уравнение движения аналогично полю промежуточных скоростей, однако входящий в выражение член с градиентом давления будем вычислять неявным образом:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{1}{\rho}\nabla\nsPressureLp
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL.
\end{equation*}
</math>

Теперь, вычитая <math>\nsVelocityA</math> из <math>\nsVelocityLp</math>, получим выражение для поля поправок:
:<math>
\begin{equation*}
\nsVelocityC
= \nsVelocityLp - \nsVelocityA
= -\frac{\tau}{\rho}\nabla(\nsPressureLp - \beta\nsPressureL).
\end{equation*}
</math>
Тогда, положив поле <math>\phi = \nsPressureLp - \beta\nsPressureL</math>, перейдем к новому выражению для скорости на следующем шаге по времени:
:<math>
\begin{equation*}
\nsVelocityLp
= \nsVelocityA
- \frac{\tau}{\rho}\nabla\phi.
\end{equation*}
</math>
Необходимо потребовать выполнения уравнения неразрывности для <math>\nsVelocityLp</math>:
:<math>
\begin{equation*}
0
= (\nabla, \nsVelocityLp)
= (\nabla, \nsVelocityA - \frac{\tau}{\rho}\nabla\phi)
= (\nabla, \nsVelocityA) - \frac{\tau}{\rho}\laplace\phi.
\end{equation*}
</math>
Тем самым приходим к уравнению Пуассона относительно <math>\phi</math>:
:<math>
\begin{equation*}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA).
\end{equation*}
</math>

Решив уравнение Пуассона, можем найти явные формулы для вычисления давления и скорости на следующем временном слое:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

Подводя итоги, выпишем алгоритм для простейшей явной техники расщепления операторов:
* Вычисляем промежуточное поле скоростей:
:<math>
\begin{equation*}
\nsVelocityA
= \nsVelocityL
- \tau(\nsVelocityL, \nabla)\nsVelocityL
- \tau\frac{\beta}{\rho}\nabla\nsPressureL
+ \tau\nu\laplace\nsVelocityL
+ \tau\nsForcesL;
\end{equation*}
</math>
* Решаем уравнение Пуассона:
:<math>
\begin{equation*}
\begin{cases}
\laplace\phi = \frac{\rho}{\tau}(\nabla, \nsVelocityA),
\\
\nsPhiDn\bigl|_{\partial\Omega} = 0;
\end{cases}
\end{equation*}
</math>
* Находим значения скорости и давления на следующем шаге по времени:
:<math>
\begin{equation*}
\begin{split}
&\nsVelocityLp = \nsVelocityA - \frac{\tau}{\rho}\nabla\phi,
\\
&\nsPressureLp = \phi + \beta\nsPressureL.
\end{split}
\end{equation*}
</math>

=== Вычислительное ядро алгоритма ===

Применим метод конечных разностей для решение системы уравнений Навье-Стокса в двухмерной прямоугольной области на равномерной сетке с начальными и краевыми данными течения Пуазёйля. Введем равномерную сетку <math>\omega</math> с шагами <math>\Delta x</math> и <math>\Delta y</math>:
:<math>
\begin{equation*}
\begin{split}
&\omega = \bigl[ (x_i, y_j),
i \in \overline{0,N},
j \in \overline{0,M} \bigl],
\\
&f_{i,j} = f(i\Delta x, j\Delta y).
\end{split}
\end{equation*}
</math>

Вычислительное ядро алгоритма состоит из вычислений по формулам конечных разностей для первых и вторых производных, а также скалярных произведений, возникающих при произведении матрицы на вектор, осуществляющегося в рамках итерационного метода для решения линейной системы уравнений дискретной задачи Пуассона. Выпишем, например, формулы для вторых частных производных скорости:
:<math>
\newcommand{\nsVelocityQ}{\vec{v}^{?}}

\newcommand{\nsVelocityQDx}{\frac{\partial\nsVelocityQ}{\partial x}}
\newcommand{\nsVelocityQDy}{\frac{\partial\nsVelocityQ}{\partial y}}

\newcommand{\nsVelocityQDxDx}{\frac{\partial^2 \nsVelocityQ}{\partial x^2}}
\newcommand{\nsVelocityQDyDy}{\frac{\partial^2 \nsVelocityQ}{\partial y^2}}

\newcommand{\nsPressureLDx}{\frac{\partial\nsPressureL}{\partial x}}
\newcommand{\nsPressureLDy}{\frac{\partial\nsPressureL}{\partial y}}

\begin{equation*}
\begin{split}
\nsVelocityQDyDy \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i,j+1}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i,j-1}}{\Delta y^2},
i \in \overline{0,N}, j \in \overline{1,M-1}.
\\
\nsVelocityQDxDx \bigl|_{i,j}
\approx \frac{\nsVelocityQ_{i+1,j}
- 2\nsVelocityQ_{i,j}
+ \nsVelocityQ_{i-1,j}}{\Delta x^2},
i \in \overline{1,N-1}, j \in \overline{1,M-1}.
\end{split}
\end{equation*}
</math>

В качественно итерационного метода выберем Стабилизированный Метод Бисопряженных Градиентов (BiCGStab). Данный метод выбран лишь потому, что матрица для дискретной задачи Пуассона не является симметрической. Для реализации этого метода требуется лишь операция умножения матрицы на вектор и скалярное произведение. Генерацию матрицы для задачи Пуассона добавлять в ядро не будем.

* Вычисление промежуточных полей по формулам конечных разностей.
* Решение дискретной задачи Пуассона.
* Вычисление искомых параметров задачи на новом временном слое по формулам конечных разностей.

Заметим, что единственной нетривиальной операцией является итерационный процесс решения СЛАУ.

Участник:Jhuighuy/Явная техника расщепления операторов для системы уравнений Навье-Стокса

2017-10-21T17:03:02Z

Jhuighuy: Новая страница: «Кек == Свойства и структура алгоритма == === Общее описание алгоритма === Данный алгоритм я…»