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

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-09T02:12:20Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
mpi_rank, mpi_size = p -- ранг процесса в MPI_COMM_WORLD, размер MPI_COMM_WORLD (число процессов)

n -- число областей непрерывности

[[Image:my_info_graph.png]]

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

Пример: JobId = 1382989, p = 128, Time = 00:14

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-09T02:12:06Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
mpi_rank, mpi_size = p -- ранг процесса в MPI_COMM_WORLD, размер MPI_COMM_WORLD (число процессов)

n -- число областей непрерывности

[[Image:my_info_graph.png]]

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

lomonosov.parallel.ru username: abogovski_607

Пример работы: JobId = 1382989, p = 128, Time = 00:14

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-09T02:09:25Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
mpi_rank, mpi_size = p -- ранг процесса в MPI_COMM_WORLD, размер MPI_COMM_WORLD (число процессов)

n -- число областей непрерывности

[[Image:my_info_graph.png]]

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

lomonosov.parallel.ru username: abogovski_607
Пример: JobId = 1382989, p = 128, Time = 00:14

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-09T00:59:49Z

Abogovski: /* Информационный граф */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
mpi_rank, mpi_size = p -- ранг процесса в MPI_COMM_WORLD, размер MPI_COMM_WORLD (число процессов)

n -- число областей непрерывности

[[Image:my_info_graph.png]]

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

lomonosov.parallel.ru username: abogovski_607

{|
|-
| JobIds || p || Average Time(mm:ss)
|-
| 1382989, 1383000 || 128 || 00:14
|}

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-09T00:57:46Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
mpi_rank, mpi_size -- ранг процесса в MPI_COMM_WORLD, размер MPI_COMM_WORLD

n -- число областей непрерывности

м

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

lomonosov.parallel.ru username: abogovski_607

{|
|-
| JobIds || p || Average Time(mm:ss)
|-
| 1382989, 1383000 || 128 || 00:14
|}

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T22:58:55Z

Abogovski: /* Информационный граф */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
mpi_rank, mpi_size -- ранг процесса в MPI_COMM_WORLD, размер MPI_COMM_WORLD

n -- число областей непрерывности

м

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T22:05:59Z

Abogovski: /* Перебор на заданных диапазонах */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.

Способ обхода выбран таким образом, чтобы переход к следующему набору параметров требовал наименьшее число операций, для этого же используется стек T из n = AREAS_CNT матриц 2x2.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:17:29Z

Abogovski: /* Выбор диапазонов перебора для параметров каждой области */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из настроек перебора (заданных при компиляции) и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:17:04Z

Abogovski: /* Выбор диапазонов перебора для параметров каждой области */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из заданных при компиляции настроек перебора и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:16:25Z

Abogovski: /* Выбор диапазонов перебора для параметров каждой области */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Вычисление диапазона перебора из заданных при компиляции параметров и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:15:59Z

Abogovski: /* Выбор диапазонов перебора для параметров каждой области */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
Выбор вычисление диапазона перебора из заданных при компиляции параметров и "порядкового номера" процесса (ранга в MPI_COMM_WORLD)
можно отнести к вычислительному ядру
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:13:40Z

Abogovski: /* Схема реализации последовательного алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной:
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:11:20Z

Abogovski: /* Схема реализации последовательного алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядром всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. раздел вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:10:04Z

Abogovski: /* Схема реализации последовательного алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

Подробнее см. вычислительное ядро

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:09:03Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может стать только сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:08:37Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости может только стать сбор и сохранение всех результатов одним процессом, но он занимает очень мало времени по сравнению с перебором.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T21:07:06Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:55:55Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов (логарифмическая шкала), ось ординат -- время (линейная шкала). Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:55:17Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время. Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Graph_fixed1.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:51:52Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время. Получилось что-то похожее на <math>t = 1/p</math>

[[Image:Scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:51:22Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время. Получилось примерно <math>t = 1/p</math>

[[Image:Scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:51:05Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время. Получилось примерно <math>t \textasciitilde 1/p</math>

[[Image:Scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:49:40Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время. Получилось примерно <math>t \~ 1/p</math>

[[Image:Scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:49:32Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время. Получилось примерно <math>t ~ 1/p</math>

[[Image:Scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:40:56Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время.

[[Image:Scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:40:47Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время.
[[Image:Scaling_graph.png]]
[[Файл:scaling_graph.png]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:38:22Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Масштабируемость линейная. Ключевым ограничением масштабируемости является сбор и сохранение всех результатов одним процессом.

Ось абсцисс -- число процессов, ось ординат -- время.
[[File:Scaling_graph.jpg]]

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:09:32Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

Задача очень специфическая, поэтому других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:09:19Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

Задача очень специфическая -- других реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:09:04Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

Задача очень специфическая -- реализаций не найдено.

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:08:09Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной масштабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:07:06Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(k^{2n - p})</math>
(в сравнении с последовательной <math>O(k^{2n})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной мастшабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:06:01Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(2^{kn - p})</math>
(в сравнении с последовательной <math>O(2^{kn})</math>), так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной мастшабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:05:36Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(2^{kn - p})</math>
(в сравнении с последовательной <math>O(2^{kn})</math>, так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной мастшабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:05:24Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> - число параллельных процессов, тогда паралелльная сложность - амортизированное <math>O(2^{kn - p})</math>
(в сравнении с последовательной <math>O(2^{kn})</math>, так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной мастшабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T20:05:12Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

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

Пусть <math>p</math> -- число параллельных процессов, тогда паралелльная сложность -- амортизированное <math>O(2^{kn - p})</math>
(в сравнении с последовательной <math>O(2^{kn})</math>, так как пересылка и сохранение результатов в конце занимают намного меньше времени чем сам перебор, который распараллеливается с линейной мастшабируемостью.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:57:09Z

Abogovski: /* Литература */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

Диссертация: Дудкина А.А. "К <math>L_p</math>-теории эллиптических краевых задач с разрывными коэффицентами", Москва, 2009

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:46:31Z

Abogovski: /* Схема реализации последовательного алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1)) // 0 - номер процесса, 1 - количество процессов
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:45:03Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1))
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" времени исполнения является лишь идентификатор процесса и количество процессов.

В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:43:47Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1))
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия. Они определены в коде как константы (задаются во время компиляции)

В данной реализации "входными данными" является лишь идентификатор процесса и количество процессов (требуется для
В качестве выходных данных было взято число всех найденных наборов <math>\{ \varkappa\}, \{ \alpha\}</math>, удовлетворяющих требованиям с заданной точностью.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:36:23Z

Abogovski: /* Схема реализации последовательного алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
Приведенная выше паралелльная реализация является эффективной последовательной при выборе единственным вычислительным ядро всего диапазона перебора, то есть
<source lang="C++">
CheckRBoundaryCond(ParallelParams(0, 1))
</source>

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:31:48Z

Abogovski: /* Последовательная сложность алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
В первой подобласти: зафиксируем <math>\varkappa=1</math>
Далее перебор значений остальных параметров.

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноcть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:27:38Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
struct Area
{
double angle;
double kappa;
};

template<typename T>
struct Range
{
T min;
T max;
T step;
};

vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
struct Matrix
{
double elems[2][2];
};

const Matrix IdentityMatrix = { { { 1, 0 }, { 0, 1 } } };

inline void RotateScale(Matrix& out, const Matrix& in, double phi, double scale = 1.0)
{
double c = cos(phi);
double s = sin(phi);
out.elems[0][0] = in.elems[0][0] * c + in.elems[1][0] * s;
out.elems[0][1] = in.elems[0][1] * c + in.elems[1][1] * s;
out.elems[1][0] = scale * (- in.elems[0][0] * s + in.elems[1][0] * c);
out.elems[1][1] = scale * (- in.elems[0][1] * s + in.elems[1][1] * c);
}

int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
В первой подобласти: зафиксируем <math>\varkappa=1</math>
Далее перебор значений остальных параметров.

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:24:46Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math> (или весь диапазон, в случае последовательной реализации)
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

=== Выбор диапазонов перебора для параметров каждой области ===
<source lang="C++">
vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

=== Перебор на заданных диапазонах ===
Проверяется выполнения правого граничного условия при заданных условиях сопряжения решения в областях
(условия зависят от параметров <math>\varkappa, \alpha</math>) и заданном левом граничном условии.
<source lang="C++">
int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
В первой подобласти: зафиксируем <math>\varkappa=1</math>
Далее перебор значений остальных параметров.

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-08T19:19:24Z

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

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math>
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

Выбора диапазона перебора для параметров каждой области
<source lang="C++">
vector<Range<Area>> ParallelParams(int mpi_rank, int mpi_size)
{
vector<Range<Area>> ranges(AREAS_CNT);
constexpr double angle_step = (ANGLE_TO - ANGLE_FROM) / (double) RANGE_STEPS_CNT;
constexpr double kappa_step = (KAPPA_TO - KAPPA_FROM) / (double) RANGE_STEPS_CNT;
Range<Area> r0 = { { ANGLE_FROM + mpi_rank * angle_step, 1 }, { ANGLE_FROM + (mpi_rank + 1) * angle_step, 1 },{ angle_step, kappa_step } };
Range<Area> r1 = { { ANGLE_FROM, KAPPA_FROM },{ ANGLE_TO, KAPPA_TO },{ angle_step, kappa_step } };
ranges[0] = r0;
for (size_t i = 1; i < AREAS_CNT; ++i)
ranges[i] = r1;
return ranges;
}
</source>

<source lang="C++">
int vector<vector<Area>> CheckRBoundaryCond(vector<Range<Area>> ranges)
{
vector<vector<Area>> results;
vector<Area> areas(AREAS_CNT);
vector<Matrix> T(AREAS_CNT);

for (size_t i = 0; i < AREAS_CNT; ++i)
areas[i] = ranges[i].min;

T[0] = IdentityMatrix;
for (size_t i = 1; i < AREAS_CNT; ++i)
RotateScale(T[i], T[i - 1], areas[i - 1].angle, areas[i - 1].kappa / areas[i].kappa);

for (int lvl = AREAS_CNT; lvl > 0; ) {
// check boundary condition if at top lvl area
if (lvl == AREAS_CNT) {

double angle = 0.0;
for (size_t i = 0; i < AREAS_CNT; ++i)
angle += areas[i].angle;
double rbcond = T.back().elems[0][1] * cos(angle) + T.back().elems[1][1] * sin(angle);
if (abs(rbcond) < EPS) {
results.push_back(areas);
}
lvl--;
continue;
}

// try increase kappa at lvl-th area and go up
double next_kappa = areas[lvl].kappa + ranges[lvl].step.kappa;
if (next_kappa <= ranges[lvl].max.kappa + 0.5 * ranges[lvl].step.kappa) {
areas[lvl].kappa = next_kappa;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// try increase angle at lvl-th area and go up
double next_angle = areas[lvl].angle + ranges[lvl].step.angle;
if (next_angle <= ranges[lvl].max.angle + 0.5 * ranges[lvl].step.angle) {
areas[lvl].angle = next_angle;
RotateScale(T[lvl], T[lvl - 1], areas[lvl - 1].angle, areas[lvl - 1].kappa / areas[lvl].kappa);
lvl++;
continue;
}

// jump to previous area
areas[lvl] = ranges[lvl].min;
lvl--;
}

return results;
}
</source>

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
В первой подобласти: зафиксируем <math>\varkappa=1</math>
Далее перебор значений остальных параметров.

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
"Паралелельные" независимые ветви.

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-01T11:44:02Z

Abogovski: /* Информационный граф */

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-01T11:39:29Z

Abogovski: /* Информационный граф */

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-01T04:18:57Z

Abogovski: /* Информационный граф */

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-01T04:16:21Z

Abogovski: /* Последовательная сложность алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math>
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
В первой подобласти: зафиксируем <math>\varkappa=1</math>
Далее перебор значений остальных параметров.

== Последовательная сложность алгоритма ==
* n - число областей непрерывности <math>\varkappa</math>
* k - число пробных значений в диапазоне перебора

сложноть последовательной реализации -- <math>O(k^{2n})</math>

== Информационный граф ==
Это очень важный раздел описания. Именно здесь можно показать (увидеть) как устроена параллельная структура алгоритма, для чего приводится описание и изображение его информационного графа ([[глоссарий#Граф алгоритма|''графа алгоритма'']] <ref name="VVVVVV">Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с. </ref>). Для рисунков с изображением графа будут составлены рекомендации по их формированию, чтобы все информационные графы, внесенные в энциклопедию, можно было бы воспринимать и интерпретировать одинаково. Дополнительно можно привести полное параметрическое описание графа в терминах покрывающих функций <ref name="VVVVVV" />.

Интересных вариантов для отражения информационной структуры алгоритмов много. Для каких-то алгоритмов нужно показать максимально подробную структуру, а иногда важнее макроструктура. Много информации несут разного рода проекции информационного графа, выделяя его регулярные составляющие и одновременно скрывая несущественные детали. Иногда оказывается полезным показать последовательность в изменении графа при изменении значений внешних переменных (например, размеров матриц): мы часто ожидаем "подобное" изменение информационного графа, но это изменение не всегда очевидно на практике.

В целом, задача изображения графа алгоритма весьма нетривиальна. Начнем с того, что это потенциально бесконечный граф, число вершин и дуг которого определяется значениями внешних переменных, а они могут быть весьма и весьма велики. В такой ситуации, как правило, спасают упомянутые выше соображения подобия, делающие графы для разных значений внешних переменных "похожими": почти всегда достаточно привести лишь один граф небольшого размера, добавив, что графы для остальных значений будут устроены "точно также". На практике, увы, не всегда все так просто, и здесь нужно быть аккуратным.

Далее, граф алгоритма - это потенциально многомерный объект. Наиболее естественная система координат для размещения вершин и дуг информационного графа опирается на структуру вложенности циклов в реализации алгоритма. Если глубина вложенности циклов не превышает трех, то и граф размещается в привычном трехмерном пространстве, однако для более сложных циклических конструкций с глубиной вложенности 4 и больше необходимы специальные методы представления и изображения графов.

В данном разделе AlgoWiki могут использоваться многие интересные возможности, которые еще подлежат обсуждению: возможность повернуть граф при его отображении на экране компьютера для выбора наиболее удобного угла обзора, разметка вершин по типу соответствующим им операций, отражение [[глоссарий#Ярусно-параллельная форма графа алгоритма|''ярусно-параллельной формы графа'']] и другие. Но в любом случае нужно не забывать главную задачу данного раздела - показать информационную структуру алгоритма так, чтобы стали понятны все его ключевые особенности, особенности параллельной структуры, особенности множеств дуг, участки регулярности и, напротив, участки с недерминированной структурой, зависящей от входных данных.

На рис.1 показана информационная структура алгоритма умножения матриц, на рис.2 - информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей.

[[file:Fig1.svg|thumb|center|300px|Рис.1. Информационная структура алгоритма умножения матриц]]
[[file:Fig2.svg|thumb|center|300px|Рис.2. Информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей]]

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]

Участник:Abogovski/Вспомогательная задача при решении задачи Штурма-Лиувилля с условиями сопряжения

2016-12-01T04:14:53Z

Abogovski: /* Последовательная сложность алгоритма */

Боговский Антон, 409

= Свойства и структура алгоритмов =
К этой вспомогательной задаче (см. Математическое описание алгоритма) сводится решение задачи Штурма-Лиувилля с условия сопряжения, возникающей при разделении переменных в краевой задаче для эллиптического оператора с кусочно-постоянными коэффицентами. Ищутся области (углы) для которых, существуют собственное число равное единице.

== Общее описание алгоритма ==
Искомые области находятся перебором параметров области (углы, на которых коэффицент постоянен, и значения коэффицента на этих подобластях.

== Математическое описание алгоритма ==
Рассмотрим задачу Дирихле на ограниченной области для эллиптического уравнения в дивергентной форме с кусочно-постоянными коэффицентами.
<math>div(\varkappa grad u) = div F </math>,
где коэффицент <math>\varkappa</math> -- кусочно-постоянный. При решении задачи методом разделения переменных в полярных возникает задача Штурма-Лиувилля относительного полярного угла <math>\Phi'(\varphi) = \lambda \Phi(\varphi)</math> c условиями сопряжения на разрывах коэффицента: непрерывность <math>\Phi(\varphi)</math> и <math>\varkappa(\varphi)\Phi'(\varphi)</math>.

В качестве области для модельной задачи возьмем круг (или сектор круга) с радиальными линиями разрыва <math>\varkappa(\varphi)</math>. Тогда на каждом отрезке непрерывности <math>\varkappa(\varphi)</math> решение -- линейная комбинация <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>. Если для области такого вида (набора значений <math>\varkappa</math> и величин углов) существуют набор постоянных при <math>cos(\sqrt{-\lambda}\varphi)</math> и <math>sin(\sqrt{-\lambda}\varphi)</math>, такой что граничные условия и условия сопряжения выполнены, то существует собственная функция.

Ищем такие области. Заметим, что решения задачи штурма Лиувилля зависят от <math>\alpha = \sqrt{-\lambda}\varphi</math> -- перейдем к такой переменной. Зададим граничное условие на одной стороне сектора, условия сопряжения на линиях разрыва и проверим (переберем) различные значения <math>\alpha, \varkappa</math> на выполнение граничного условия
на правой стороне.

(Условия сопряжения дают связь между коэффицентами при <math>cos,sin</math> через композицию матриц растяжения и поворота, зависящих от <math>\alpha, \varkappa</math>).

== Вычислительное ядро алгоритма ==
Перебор параметров. Можно рассматривать вычислительное как обход дерева всех наборов значений параметров.

* Для первой подобласти фиксируется значение <math>\varkappa=1</math> и поддиапазон перебора значений <math>\alpha</math>
* Остальные значения перебираются в заданном диапазоне -- обход дерева всех наборов значений параметра (при заданном шаге по значениям).

== Макроструктура алгоритма ==
* Для каждого процесса из его номера вычисляется поддерево наборов значений для обхода.
* Каждым из процессов выполняется обход своего поддерева
* 0-ой процесс, закончив обход своего поддерева, собирает все результаты и сохраняет их в файл с уникальным именем

== Схема реализации последовательного алгоритма ==
В первой подобласти: зафиксируем <math>\varkappa=1</math>
Далее перебор значений остальных параметров.

== Последовательная сложность алгоритма ==
n = ЧИСЛО_ЛИНИЙ_РАЗРЫВА
k = ЧИСЛО_ЗНАЧЕНИЙ_В_ДИАПОЗОНЕ_ПЕРЕБОРА

СЛОЖНОСТЬ = <math>O(k^{2n})</math>

== Информационный граф ==
Это очень важный раздел описания. Именно здесь можно показать (увидеть) как устроена параллельная структура алгоритма, для чего приводится описание и изображение его информационного графа ([[глоссарий#Граф алгоритма|''графа алгоритма'']] <ref name="VVVVVV">Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с. </ref>). Для рисунков с изображением графа будут составлены рекомендации по их формированию, чтобы все информационные графы, внесенные в энциклопедию, можно было бы воспринимать и интерпретировать одинаково. Дополнительно можно привести полное параметрическое описание графа в терминах покрывающих функций <ref name="VVVVVV" />.

Интересных вариантов для отражения информационной структуры алгоритмов много. Для каких-то алгоритмов нужно показать максимально подробную структуру, а иногда важнее макроструктура. Много информации несут разного рода проекции информационного графа, выделяя его регулярные составляющие и одновременно скрывая несущественные детали. Иногда оказывается полезным показать последовательность в изменении графа при изменении значений внешних переменных (например, размеров матриц): мы часто ожидаем "подобное" изменение информационного графа, но это изменение не всегда очевидно на практике.

В целом, задача изображения графа алгоритма весьма нетривиальна. Начнем с того, что это потенциально бесконечный граф, число вершин и дуг которого определяется значениями внешних переменных, а они могут быть весьма и весьма велики. В такой ситуации, как правило, спасают упомянутые выше соображения подобия, делающие графы для разных значений внешних переменных "похожими": почти всегда достаточно привести лишь один граф небольшого размера, добавив, что графы для остальных значений будут устроены "точно также". На практике, увы, не всегда все так просто, и здесь нужно быть аккуратным.

Далее, граф алгоритма - это потенциально многомерный объект. Наиболее естественная система координат для размещения вершин и дуг информационного графа опирается на структуру вложенности циклов в реализации алгоритма. Если глубина вложенности циклов не превышает трех, то и граф размещается в привычном трехмерном пространстве, однако для более сложных циклических конструкций с глубиной вложенности 4 и больше необходимы специальные методы представления и изображения графов.

В данном разделе AlgoWiki могут использоваться многие интересные возможности, которые еще подлежат обсуждению: возможность повернуть граф при его отображении на экране компьютера для выбора наиболее удобного угла обзора, разметка вершин по типу соответствующим им операций, отражение [[глоссарий#Ярусно-параллельная форма графа алгоритма|''ярусно-параллельной формы графа'']] и другие. Но в любом случае нужно не забывать главную задачу данного раздела - показать информационную структуру алгоритма так, чтобы стали понятны все его ключевые особенности, особенности параллельной структуры, особенности множеств дуг, участки регулярности и, напротив, участки с недерминированной структурой, зависящей от входных данных.

На рис.1 показана информационная структура алгоритма умножения матриц, на рис.2 - информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей.

[[file:Fig1.svg|thumb|center|300px|Рис.1. Информационная структура алгоритма умножения матриц]]
[[file:Fig2.svg|thumb|center|300px|Рис.2. Информационная структура одного из вариантов алгоритма решения систем линейных алгебраических уравнений с блочно-двухдиагональной матрицей]]

== Ресурс параллелизма алгоритма ==
Так как структура алгоритма представляет собой дерево (с большим количеством потомков в каждом узле) -- алгоритм хорошо распараллеливается. Наблюдается линейная масштабируемость. Сбор и сохранение данных в конце почти не влиют на производительность.

== Входные и выходные данные алгоритма ==
Параметрами задачи являются: число областей непрерывности, диапазон и точность перебора <math>\varkappa, \alpha</math>, требуемая точность выполнения граничного условия.
Выходные данные: наборы <math>\varkappa, \alpha</math> -- с их помощью можно построить искомые области.

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

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

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

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

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

== Масштабируемость алгоритма и его реализации ==
Ключевым ограничением масштабируемости является сбор результатов одним процессом.

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

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

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

= Литература =
<references />

[[en:Description of algorithm properties and structure]]