Класс, определяющий тип обтекаемого профиля More...

#include <Airfoil2DRigid.h>

Inheritance diagram for VM2D::AirfoilRigid:

[legend]

Collaboration diagram for VM2D::AirfoilRigid:

[legend]

Public Member Functions
	AirfoilRigid (const World2D &W_, const size_t numberInPassport_)
	Конструктор

	AirfoilRigid (const Airfoil &afl)

virtual	~AirfoilRigid ()
	Деструктор

void	lightningTest ()
	Тест на "отвещенность".

	IFCUDA (mutable double *devRPtr)
	Указатель на девайсе, где хранятся вершины профиля

	IFCUDA (mutable double *devPsnPtr)
	Указатель на девайсе, где хранятся псевдонормали профиля

	IFCUDA (mutable double *devRhsPtr)
	Указатель на девайсе, где хранится правая часть (константная) матрицы

	IFCUDA (mutable double *devRhsLinPtr)
	Указатель на девайсе, где хранится правая часть (линейная) матрицы

	IFCUDA (mutable std::vector< double > tmpRhs)
	Указатель на хосте, где хранится временная часть матрицы, полученная с девайса

	IFCUDA (mutable double *devFreeVortexSheetPtr)
	Указатель на девайсе, где хранятся интенсивности (константные) свободного вихревого слоя на панелях

	IFCUDA (mutable double *devFreeVortexSheetLinPtr)
	Указатель на девайсе, где хранятся интенсивности (линейные) свободного вихревого слоя на панелях

	IFCUDA (mutable double *devAttachedVortexSheetPtr)
	Указатель на девайсе, где хранятся интенсивности (константные) присоединенного вихревого слоя на панелях

	IFCUDA (mutable double *devAttachedVortexSheetLinPtr)
	Указатель на девайсе, где хранятся интенсивности (линейные) присоединенного вихревого слоя на панелях

	IFCUDA (mutable double *devAttachedSourceSheetPtr)
	Указатель на девайсе, где хранятся интенсивности (константные) присоединенного слоя источников на панелях

	IFCUDA (mutable double *devAttachedSourceSheetLinPtr)
	Указатель на девайсе, где хранятся интенсивности (линейные) присоединенного слоя источников на панелях

	IFCUDA (mutable double *devMeanEpsOverPanelPtr)
	Указатель на девайсе, где хранятся средние eps на панелях

	IFCUDA (mutable double *devViscousStressesPtr)
	Указатель на девайсе, где хранится вектор (по панелям) для силы вязкого трения

	IFCUDA (mutable std::vector< double > tmpViscousStresses)
	Указатель на хосте, где хранится временная часть вектора (по панелям) для силы вязкого трения

bool	isAfter (size_t i, size_t j) const
	Проверка, идет ли вершина i следом за вершиной j.

void	CalcNrmTauLen ()
	Вычисление нормалей, касательных и длин панелей по текущему положению вершин

virtual void	Rotate (double alpha)
	Поворот профиля

virtual void	Scale (const Point2D &)
	Масштабирование профиля

virtual void	Move (const Point2D &dr)
	Перемещение профиля

virtual void	GetGabarits (double gap=0.02)
	Вычисляет габаритный прямоугольник профиля

bool	isInsideGabarits (const Point2D &r) const
	Определяет, находится ли точка с радиус-вектором \( \vec r \) внутри габаритного прямоугольника профиля

bool	isOutsideGabarits (const Point2D &r) const
	Определяет, находится ли точка с радиус-вектором \( \vec r \) вне габаритного прямоугольника профиля

virtual bool	IsPointInAirfoil (const Point2D &point) const
	Определяет, находится ли точка с радиус-вектором \( \vec r \) внутри профиля

virtual void	ReadFromFile (const std::string &dir)
	Считывание профиля из файла

virtual std::vector< double >	getA (size_t p, size_t i, const Airfoil &airfoil, size_t j) const
	Вычисление коэффициентов матрицы A для расчета влияния панели на панель

virtual void	calcIQ (size_t p, const Airfoil &otherAirfoil, std::pair< Eigen::MatrixXd, Eigen::MatrixXd > &matrPair) const
	Вычисление коэффициентов матрицы, состоящей из интегралов от (r-xi)/\|r-xi\|^2.

void	calcMeanEpsOverPanel ()
	Вычисление средних значений eps на панелях

virtual void	GetDiffVelocityI0I3ToSetOfPointsAndViscousStresses (const WakeDataBase &pointsDb, std::vector< double > &domainRadius, std::vector< double > &I0, std::vector< Point2D > &I3)
	Вычисление числителей и знаменателей диффузионных скоростей в заданном наборе точек, обусловленных геометрией профиля, и вычисление вязкого трения

virtual void	GetInfluenceFromVorticesToPanel (size_t panel, const Vortex2D *ptr, ptrdiff_t count, std::vector< double > &panelRhs) const
	Вычисление влияния части подряд идущих вихрей из вихревого следа на панель для правой части

virtual void	GetInfluenceFromSourcesToPanel (size_t panel, const Vortex2D *ptr, ptrdiff_t count, std::vector< double > &panelRhs) const
	Вычисление влияния части подряд идущих источников из области течения на панель для правой части

virtual void	GetInfluenceFromSourceSheetToVortex (size_t panel, const Vortex2D &vtx, Point2D &vel) const
	Вычисление влияния слоя источников конкретной прямолинейной панели на вихрь в области течения

virtual void	GetInfluenceFromVortexSheetToVortex (size_t panel, const Vortex2D &vtx, Point2D &vel) const
	Вычисление влияния вихревых слоев (свободный + присоединенный) конкретной прямолинейной панели на вихрь в области течения

virtual void	GetInfluenceFromVInfToPanel (std::vector< double > &vInfRhs) const
	Вычисление влияния набегающего потока на панель для правой части

const Point2D &	getR (size_t q) const
	Возврат константной ссылки на вершину профиля

Point2D &	setR (size_t q)
	Возврат ссылки на вершину профиля

const Point2D &	getV (size_t q) const
	Возврат константной ссылки на скорость вершины профиля

void	setV (const Point2D &vel)
	Установка постоянной скорости всех вершин профиля

void	setV (const std::vector< Point2D > &vel)
	Установка скоростей всех вершин профиля

size_t	getNumberOfPanels () const
	Возврат количества панелей на профиле

Public Attributes
const World2D &	W
	Константная ссылка на решаемую задачу

const size_t	numberInPassport
	Номер профиля в паспорте

double	m
	Масса профиля

double	J
	Полярный момент инерции профиля относительно центра масс

std::vector< std::vector< Point2D > >	possibleWays
	Возможные пути внутри профиля от точки (0, 0) к центрам всех панелей

std::vector< int >	wayToVertex
	Номера путей к вершинам

std::vector< double >	meanEpsOverPanel
	Средние значения Eps на панелях

std::vector< double >	viscousStress
	Нейросеть для коэффициентов I0 и I3 диффузионной скорости

Point2D	lowLeft
	Левый нижний угол габаритного прямоугольника профиля

Point2D	upRight
	Правый верхний угол габаритного прямоугольника профиля

std::vector< double >	gammaThrough
	Суммарные циркуляции вихрей, пересекших панели профиля на прошлом шаге

bool	inverse
	Признак разворота нормалей (для расчета внутренних течений)

std::vector< Point2D >	nrm
	Нормали к панелям профиля

std::vector< std::pair< Point2D, Point2D > >	psn
	Псевдонормали к панелям профиля

std::vector< Point2D >	tau
	Касательные к панелям профиля

std::vector< double >	len
	Длины панелей профиля

Point2D	rcm
	Положение центра масс профиля

double	phiAfl
	Поворот профиля

double	area
	Площадь профиля

Protected Attributes
std::vector< Point2D >	r_
	Координаты начал панелей

std::vector< Point2D >	v_
	Скорости начал панелей

Detailed Description

Класс, определяющий тип обтекаемого профиля

Тип профиля:

профиль с прямолинейными панелями.

Author: Марчевский Илья Константинович; Сокол Ксения Сергеевна; Рятина Евгения Павловна; Колганова Александра Олеговна

Version: 1.14

Date: 6 марта 2026 г.

Definition at line 64 of file Airfoil2DRigid.h.

Constructor & Destructor Documentation

◆ AirfoilRigid() [1/2]

VM2D::AirfoilRigid::AirfoilRigid	(	const World2D &	W_,
		const size_t	numberInPassport_
	)

inline

Конструктор

Definition at line 70 of file Airfoil2DRigid.h.

71 :Airfoil(W_, numberInPassport_)

72 { };

VM2D::Airfoil::Airfoil

Airfoil(const World2D &W_, const size_t numberInPassport_)

Definition Airfoil2D.cpp:61

◆ AirfoilRigid() [2/2]

VM2D::AirfoilRigid::AirfoilRigid ( const Airfoil & afl )

inline

Definition at line 74 of file Airfoil2DRigid.h.

74: Airfoil(afl) {};

◆ ~AirfoilRigid()

virtual VM2D::AirfoilRigid::~AirfoilRigid ( )

inlinevirtual

Деструктор

Definition at line 77 of file Airfoil2DRigid.h.

77{ };

Member Function Documentation

◆ calcIQ()

void Airfoil::calcIQ	(	size_t	p,
		const Airfoil &	otherAirfoil,
		std::pair< Eigen::MatrixXd, Eigen::MatrixXd > &	matrPair
	)		const

virtualinherited

Вычисление коэффициентов матрицы, состоящей из интегралов от (r-xi)/|r-xi|^2.

Parameters

[in]	p	размерность матрицы-результата
[in]	otherAirfoil	константная ссылка на профиль, от которого рассчитывается влияние
[out]	matrPair	ссылка на пару матриц, выражающих взаимные влияния (касательные и нормальные) панелей профиля return соответствующий блок матрицы СЛАУ, вытянутый в линию

Definition at line 1225 of file Airfoil2D.cpp.

{
    bool self = (&otherAirfoil == this);
 
    size_t aflNSelf = numberInPassport;
    size_t aflNOther = otherAirfoil.numberInPassport;
 
    size_t npI;
    size_t npJ;
 
    numvector<double, 3> alpha, lambda;
 
    //auxillary vectors
    Point2D p1, s1, p2, s2, di, dj, i00, i01, i10, i11;
    numvector<Point2D, 3> v00, v11;
    numvector<Point2D, 2> v01, v10;
 
#pragma omp parallel for \
    default(none) \
    shared(otherAirfoil, self, aflNSelf, aflNOther, matrPair, p, IDPI, IQPI) \
    private(npI, npJ, alpha, lambda, p1, s1, p2, s2, di, dj, i00, i01, i10, i11, v00, v11, v01, v10) schedule(dynamic, DYN_SCHEDULE)
    for (int i = 0; i < (int)getNumberOfPanels(); ++i)
        for (int j = 0; j < (int)otherAirfoil.getNumberOfPanels(); ++j)
        {
            npI = getNumberOfPanels();
            npJ = otherAirfoil.getNumberOfPanels();
 
            if ((i == j) && self)
            {
 
                matrPair.first(i, j) = 0.0;
                matrPair.second(i, j) = 0.0;
 
                if (p == 2)
                {
                    matrPair.first(i, npJ + j) = 0.0;
                    matrPair.first(npI + i, j) = 0.0;
 
                    matrPair.second(i, npJ + j) = -IQPI;
                    matrPair.second(npI + i, j) = IQPI;
 
                    matrPair.first(npI + i, npJ + j) = 0.0;
                    matrPair.second(npI + i, npJ + j) = 0.0;
 
                }
                if (p > 2)
                    throw (-42);
            }//if i==j
            else
            {
                const Point2D& taui = tau[i];
                const Point2D& tauj = otherAirfoil.tau[j];
 
                p1 = getR(i + 1) - otherAirfoil.getR(j + 1);
                s1 = getR(i + 1) - otherAirfoil.getR(j);
                p2 = getR(i) - otherAirfoil.getR(j + 1);
                s2 = getR(i) - otherAirfoil.getR(j);
                di = getR(i + 1) - getR(i);
                dj = otherAirfoil.getR(j + 1) - otherAirfoil.getR(j);
 
                alpha = { \
                    (self && isAfter(j, i)) ? 0.0 : VMlib::Alpha(s2, s1), \
                    VMlib::Alpha(s2, p1), \
                    (self && isAfter(i, j)) ? 0.0 : VMlib::Alpha(p1, p2) \
                };
 
                lambda = { \
                    (self && isAfter(j, i)) ? 0.0 : VMlib::Lambda(s2, s1), \
                    VMlib::Lambda(s2, p1), \
                    (self && isAfter(i, j)) ? 0.0 : VMlib::Lambda(p1, p2) \
                };
 
                v00 = {
                    VMlib::Omega(s1, taui, tauj),
                    -VMlib::Omega(di, taui, tauj),
                    VMlib::Omega(p2, taui, tauj)
                };
 
                i00 = IDPI / len[i] * (-(alpha[0] * v00[0] + alpha[1] * v00[1] + alpha[2] * v00[2]).kcross() \
                    + (lambda[0] * v00[0] + lambda[1] * v00[1] + lambda[2] * v00[2]));
 
                matrPair.first(i, j) = i00 & nrm[i];
                matrPair.second(i, j) = i00 & taui;
 
 
                if (p == 2)
                {
                    v01 = {
                        0.5 / (dj.length()) * (((p1 + s1) & tauj) * VMlib::Omega(s1, taui, tauj) - s1.length2() * taui),
                        -0.5 * di.length() / dj.length() * VMlib::Omega(s1 + p2, tauj, tauj)
                    };
 
                    i01 = IDPI / len[i] * (-((alpha[0] + alpha[2]) * v01[0] + (alpha[1] + alpha[2]) * v01[1]).kcross() \
                        + ((lambda[0] + lambda[2]) * v01[0] + (lambda[1] + lambda[2]) * v01[1]) - 0.5 * di.length() * tauj);
 
                    matrPair.first(i, npJ + j) = i01 & nrm[i];
                    matrPair.second(i, npJ + j) = i01 & taui;
 
 
                    v10 = {
                        -0.5 / di.length() * (((s1 + s2) & taui) * VMlib::Omega(s1, taui, tauj) - s1.length2() * tauj),
                        0.5 * dj.length() / di.length() * VMlib::Omega(s1 + p2, taui, taui)
                    };
 
                    i10 = IDPI / len[i] * (-((alpha[0] + alpha[2]) * v10[0] + alpha[2] * v10[1]).kcross() \
                        + ((lambda[0] + lambda[2]) * v10[0] + lambda[2] * v10[1]) + 0.5 * dj.length() * taui);
 
                    matrPair.first(npI + i, j) = i10 & nrm[i];
                    matrPair.second(npI + i, j) = i10 & taui;
 
 
                    v11 = {
                        1.0 / (12.0 * di.length() * dj.length()) * (2.0 * (s1 & VMlib::Omega(s1 - 3.0 * p2, taui, tauj)) * VMlib::Omega(s1, taui, tauj) - s1.length2() * (s1 - 3.0 * p2)) - 0.25 * VMlib::Omega(s1, taui, tauj),
                        -di.length() / (12.0 * dj.length()) * VMlib::Omega(di, tauj, tauj),
                        -dj.length() / (12.0 * di.length()) * VMlib::Omega(dj, taui, taui)
                    };
 
                    i11 = IDPI / len[i] * (-((alpha[0] + alpha[2]) * v11[0] + (alpha[1] + alpha[2]) * v11[1] + alpha[2] * v11[2]).kcross()\
                        + (lambda[0] + lambda[2]) * v11[0] + (lambda[1] + lambda[2]) * v11[1] + lambda[2] * v11[2] \
                        + 1.0 / 12.0 * (dj.length() * taui + di.length() * tauj - 2.0 * VMlib::Omega(s1, taui, tauj)));
 
                    matrPair.first(npI + i, npJ + j) = i11 & nrm[i];
                    matrPair.second(npI + i, npJ + j) = i11 & taui;
                }
 
 
                if (p > 2)
                    throw (-42);
            }//else(i == j)
 
        }//for(...)
}//getIQ(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calcMeanEpsOverPanel()

void Airfoil::calcMeanEpsOverPanel ( )

inherited

Вычисление средних значений eps на панелях

Definition at line 96 of file Airfoil2D.cpp.

{
    meanEpsOverPanel.clear();
    meanEpsOverPanel.resize(getNumberOfPanels());
 
 
    double midEps;
 
    const Boundary& bnd = W.getBoundary(numberInPassport);
    VortexesParams virtVortParams = W.getVelocity().virtualVortexesParams[numberInPassport];
 
    for (size_t i = 0; i < getNumberOfPanels(); ++i)
    {
        midEps = 0.0;
        for (int j = bnd.vortexBeginEnd[i].first; j < bnd.vortexBeginEnd[i].second; ++j)
            midEps += virtVortParams.epsastWake[j];
            //midEps += std::max(virtVortParams.epsastWake[j], 0.5 * len[i] / (bnd.vortexBeginEnd[i].second - bnd.vortexBeginEnd[i].first));
 
        midEps /= (bnd.vortexBeginEnd[i].second - bnd.vortexBeginEnd[i].first);
        meanEpsOverPanel[i] = midEps;
    }//for i
}//calcMeanEpsOverPanel()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcNrmTauLen()

void Airfoil::CalcNrmTauLen ( )

inherited

Вычисление нормалей, касательных и длин панелей по текущему положению вершин

Definition at line 1092 of file Airfoil2D.cpp.

{
    if (nrm.size() != r_.size())
    {
        nrm.resize(r_.size());
        psn.resize(r_.size());
        tau.resize(r_.size());
        len.resize(r_.size());
    }
 
    Point2D rpan;
 
    //считаем длины, касательные и нормали
#pragma omp parallel for private(rpan)
    for (int i = 0; i < (int)r_.size(); ++i)
    {
        rpan = (getR(i + 1) - getR(i));
        len[i] = rpan.length();
        tau[i] = rpan.unit();
        nrm[i] = { tau[i][1], -tau[i][0] };
    }
 
    //считаем псевдонормали
#pragma omp parallel for
    for (int i = 0; i < (int)r_.size(); ++i)
    {
        int next = (i == (int)r_.size() - 1 ? 0 : i + 1);
        int prev = (i == 0 ? (int)r_.size() - 1 : i - 1);
 
        psn[i] = std::make_pair( (nrm[prev] + nrm[i]).unit(), (nrm[i] + nrm[next]).unit() );
    }
 
    //закольцовываем
    //nrm.push_back(nrm[0]);
    //tau.push_back(tau[0]);
    //len.push_back(len[0]);
}//CalcNrmTauLen()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getA()

std::vector< double > Airfoil::getA	(	size_t	p,
		size_t	i,
		const Airfoil &	airfoil,
		size_t	j
	)		const

virtualinherited

Вычисление коэффициентов матрицы A для расчета влияния панели на панель

Parameters

[in]	p	размерность матрицы - результата
[in]	i	номер панели, на которую оказывается влияние
[in]	airfoil	константная ссылка на профиль, от которого рассчитывается влияние
[in]	j	номер влияющей панели return соответствующий блок матрицы СЛАУ, вытянутый в линию

Definition at line 1184 of file Airfoil2D.cpp.

{
    std::vector<double> res(p * p, 0.0);
 
    if ((i == j) && (&airfoil == this))
    {
        res[0] = 0.5 * (tau[i] ^ nrm[i]);
        if (p == 1)
            return res;
 
        res[3] = (1.0 / 12.0) * res[0];
        if (p == 2)
            return res;
 
        if (p > 2)
            throw (-42);
 
    }//if i==j
 
    const auto& miq = W.getIQ(numberInPassport, airfoil.numberInPassport);
 
    res[0] = miq.first(i, j);
 
    if (p == 1)
        return res;
 
    res[1] = miq.first(i, airfoil.getNumberOfPanels() + j);
    res[2] = miq.first(getNumberOfPanels() + i, j);
    res[3] = miq.first(getNumberOfPanels() + i, airfoil.getNumberOfPanels() + j);
 
    if (p == 2)
        return res;
 
    if (p > 2)
        throw (-42);
 
    //Хотя сюда никогда и не попадем
    return res;
}//getA(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDiffVelocityI0I3ToSetOfPointsAndViscousStresses()

void Airfoil::GetDiffVelocityI0I3ToSetOfPointsAndViscousStresses	(	const WakeDataBase &	pointsDb,
		std::vector< double > &	domainRadius,
		std::vector< double > &	I0,
		std::vector< Point2D > &	I3
	)

virtualinherited

Вычисление числителей и знаменателей диффузионных скоростей в заданном наборе точек, обусловленных геометрией профиля, и вычисление вязкого трения

Вычисляет диффузионные скорости в наборе точек, которые обусловленных геометрией профиля, и вычисляет вязкое трение

Parameters

[in]	pointsDb	константная ссылка на базу данных вихрей, в которых вычисляются скорости
[in]	domainRadius	ссылка на радиусы вихрей
[out]	I0	ссылка на вектор знаменателей диффузионных скоростей, которые приобретают точки из-за влияния геометрии профиля
[out]	I3	ссылка на вектор числителей диффузионных скоростей, которые приобретают точки из-за влияния геометрии профиля

Warning: Векторы I0, I3 — накапливаются!

Definition at line 495 of file Airfoil2D.cpp.

{
    std::vector<double> selfI0;
    std::vector<Point2D> selfI3;
 
    std::vector<double> currViscousStress;
    currViscousStress.resize(r_.size(), 0.0);
 
 
    selfI0.resize(pointsDb.vtx.size(), 0.0);
    selfI3.resize(pointsDb.vtx.size(), { 0.0, 0.0 });
 
#pragma warning (push)
#pragma warning (disable: 4101)
    //Локальные переменные для цикла
    Point2D q, xi, xi_m, v0;
    double lxi, lxi_m, lenj_m;
 
    Point2D mn;
    int new_n;
    Point2D h;
 
    Point2D vec;
    double s, d;
 
    double vs;
    double iDDomRad, domRad, expon;
#pragma warning (pop)
 
#pragma omp parallel for \
    default(none) \
    shared(domainRadius, pointsDb, selfI0, selfI3, currViscousStress, PI) \
    private(xi, xi_m, lxi, lxi_m, lenj_m, v0, q, new_n, mn, h, d, s, vec, vs, expon, domRad, iDDomRad) schedule(dynamic, DYN_SCHEDULE)
    for (int i = 0; i < pointsDb.vtx.size(); ++i)
    {
        const Vortex2D& vtxI = pointsDb.vtx[i];
 
        domRad = std::max(domainRadius[i], W.getPassport().wakeDiscretizationProperties.getMinEpsAst());
        iDDomRad = 1.0 / domRad;
 
        for (size_t j = 0; j < r_.size(); ++j)
        {
            vs = 0.0;
            q = vtxI.r() - 0.5 * (getR(j) + getR(j + 1));
            vec = tau[j];
 
            s = q & vec;
            d = fabs(q & nrm[j]);
 
            if ((d < 50.0 * len[j]) && (fabs(s) < 50.0 * len[j]))
            {
                v0 = vec * len[j];
 
                if ((d > 5.0 * len[j]) || (fabs(s) > 5.0 * len[j]))
                {
                    xi = q * iDDomRad;
                    lxi = xi.length();
 
                    expon = exp(-lxi) * len[j];
                    mn = nrm[j] * expon;
 
                    //if (selfI0[i] != -PI * domRad)
                    //{
                        selfI0[i] += (xi & mn) * (lxi + 1.0) / (lxi * lxi);
                        selfI3[i] += mn;
                    //}
 
                    vs = vtxI.g() * expon / (PI * sqr(meanEpsOverPanel[j]));
                }
                else if ((d >= 0.1 * len[j]) || (fabs(s) > 0.5 * len[j]))
                {
                    vs = 0.0;
                    double den = (fabs(s) < 0.5 * len[j]) ? d : (fabs(s) + d - 0.5 * len[j]);
 
                    new_n = std::max(1, static_cast<int>(ceil(5.0 * len[j] / den)));
                    //new_n = 100;
                    h = v0 * (1.0 / new_n);
 
                    for (int m = 0; m < new_n; ++m)
                    {
                        xi_m = (vtxI.r() - (getR(j) + h * (m + 0.5))) * iDDomRad;
                        lxi_m = xi_m.length();
 
                        lenj_m = len[j] / new_n;
                        expon = exp(-lxi_m) * lenj_m;
 
                        mn = nrm[j] * expon;
                        //if (selfI0[i] != -PI * domRad)
                        {
                            selfI0[i] += (xi_m & mn) * (lxi_m + 1.0) / (lxi_m * lxi_m);
                            selfI3[i] += mn;
                        }
                        vs += expon;
                    }//for m
                    vs *= vtxI.g() / (PI * sqr(meanEpsOverPanel[j]));
                }
                else
                {
 
                    selfI0[i] += -PI * domRad;
                    double mnog = 2.0 * domRad * (1.0 - exp(-len[j] * iDDomRad / 2.0) * cosh(fabs(s) * iDDomRad));
                    selfI3[i] += nrm[j] * mnog;
                    vs = mnog * vtxI.g() / (PI * sqr(meanEpsOverPanel[j]));
                }
            }//if d<50 len 
 
#pragma omp atomic
            currViscousStress[j] += vs;
        }//for j
    }//for i
 
 
    if (&pointsDb == &(W.getWake()))
        for (size_t i = 0; i < viscousStress.size(); ++i)
        {
            viscousStress[i] += currViscousStress[i];
        }
 
    for (size_t i = 0; i < I0.size(); ++i)
    {
        domRad = std::max(domainRadius[i], W.getPassport().wakeDiscretizationProperties.getMinEpsAst());
 
        if (I0[i] != -PI * domRad)
        {
            if (selfI0[i] == -PI * domRad)
            {
                I0[i] = selfI0[i];
                I3[i] = selfI3[i];
            }
            else
            {
                I0[i] += selfI0[i];
                I3[i] += selfI3[i];
            }
        }
    }
}; //GetDiffVelocityI0I3ToSetOfPointsAndViscousStresses(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetGabarits()

void Airfoil::GetGabarits ( double gap = 0.02 )

virtualinherited

Вычисляет габаритный прямоугольник профиля

Заполняет значения полей lowLeft и upRight по габаритному прямоугольнику профиля с учетом зазора

Parameters

[in] gap относительная величина зазора в долях от размера габаритного прямоугольника (по умолчанию 0.02, что соответствует 2 %)

Definition at line 1072 of file Airfoil2D.cpp.

{
    lowLeft = { 1E+10, 1E+10 };
    upRight = { -1E+10, -1E+10 };
 
    for (size_t i = 0; i < r_.size(); ++i)
    {
        lowLeft[0] = std::min(lowLeft[0], r_[i][0]);
        lowLeft[1] = std::min(lowLeft[1], r_[i][1]);
 
        upRight[0] = std::max(upRight[0], r_[i][0]);
        upRight[1] = std::max(upRight[1], r_[i][1]);
    }
 
    Point2D size = upRight - lowLeft;
    lowLeft -= size * gap;
    upRight += size * gap;
}//GetGabarits(...)

Here is the caller graph for this function:

◆ GetInfluenceFromSourceSheetToVortex()

void Airfoil::GetInfluenceFromSourceSheetToVortex	(	size_t	panel,
		const Vortex2D &	vtx,
		Point2D &	vel
	)		const

virtualinherited

Вычисление влияния слоя источников конкретной прямолинейной панели на вихрь в области течения

Parameters

[in]	panel	номер панели профиля, от которой считается влияние
[in]	vtx	ссылка на вихрь
[out]	vel	ссылка на вектор полученной скорости

Definition at line 1371 of file Airfoil2D.cpp.

{
    W.getBoundary(numberInPassport).GetInfluenceFromSourceSheetAtRectPanelToVortex(panel, vtx, vel);
}//GetInfluenceFromSourceSheetToVortex(...)

Here is the call graph for this function:

◆ GetInfluenceFromSourcesToPanel()

void Airfoil::GetInfluenceFromSourcesToPanel	(	size_t	panel,
		const Vortex2D *	ptr,
		ptrdiff_t	count,
		std::vector< double > &	panelRhs
	)		const

virtualinherited

Вычисление влияния части подряд идущих источников из области течения на панель для правой части

Вычисляет влияния части подряд идущих источников из области течения на панель для правой части

Parameters

[in]	panel	номер панели профиля, на которую считается влияние
[in]	ptr	указатель на начало диапазона источников
[in]	count	длина диапазона источников
[out]	panelRhs	ссылка на вектор полученного влияния для правой части СЛАУ для конкретной панели

Definition at line 1365 of file Airfoil2D.cpp.

{
    W.getBoundary(numberInPassport).GetInfluenceFromSourcesToRectPanel(panel, ptr, count, panelRhs);
}//GetInfluenceFromSourcesToPanel(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInfluenceFromVInfToPanel()

void Airfoil::GetInfluenceFromVInfToPanel ( std::vector< double > & vInfRhs ) const

virtualinherited

Вычисление влияния набегающего потока на панель для правой части

Вычисляет влияния набегающего потока на панель для правой части

Parameters

[out] vInfRhs ссылка на вектор полученного влияния для правой части СЛАУ для всех панелей профиля

Definition at line 1382 of file Airfoil2D.cpp.

{
    W.getBoundary(numberInPassport).GetInfluenceFromVInfToRectPanel(vInfRhs);
}//GetInfluenceFromVInfToPanel(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInfluenceFromVortexSheetToVortex()

void Airfoil::GetInfluenceFromVortexSheetToVortex	(	size_t	panel,
		const Vortex2D &	vtx,
		Point2D &	vel
	)		const

virtualinherited

Вычисление влияния вихревых слоев (свободный + присоединенный) конкретной прямолинейной панели на вихрь в области течения

Parameters

[in]	panel	номер панели профиля, от которой считается влияние
[in]	vtx	ссылка на вихрь
[out]	vel	ссылка на вектор полученной скорости

Definition at line 1377 of file Airfoil2D.cpp.

{
    W.getBoundary(numberInPassport).GetInfluenceFromVortexSheetAtRectPanelToVortex(panel, vtx, vel);
}//GetInfluenceFromVortexSheetToVortex(...)

Here is the call graph for this function:

◆ GetInfluenceFromVorticesToPanel()

void Airfoil::GetInfluenceFromVorticesToPanel	(	size_t	panel,
		const Vortex2D *	ptr,
		ptrdiff_t	count,
		std::vector< double > &	panelRhs
	)		const

virtualinherited

Вычисление влияния части подряд идущих вихрей из вихревого следа на панель для правой части

Вычисляет влияния части подряд идущих вихрей из вихревого следа на панель для правой части

Parameters

[in]	panel	номер панели профиля, на которую считается влияние
[in]	ptr	указатель на начало диапазона вихрей
[in]	count	длина диапазона вихрей
[out]	panelRhs	ссылка на вектор полученного влияния для правой части СЛАУ для конкретной панели

Definition at line 1358 of file Airfoil2D.cpp.

{
    W.getBoundary(numberInPassport).GetInfluenceFromVorticesToRectPanel(panel, ptr, count, panelRhs);
}//GetInfluenceFromVorticesToPanel(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getNumberOfPanels()

size_t VM2D::AirfoilGeometry::getNumberOfPanels ( ) const

inlineinherited

Возврат количества панелей на профиле

Returns: количество панелей на профиле

Definition at line 163 of file Airfoil2D.h.

163{ return r_.size(); };

Here is the caller graph for this function:

◆ getR()

const Point2D & VM2D::AirfoilGeometry::getR ( size_t q ) const

inlineinherited

Возврат константной ссылки на вершину профиля

Организовано "зацикливание" в сторону увеличения индекса, т.е. getR[size()] = getR[0];

Это позволяет удобно обращаться к getR(i) и getR(i+1) как к началу и концу i-й панели

Parameters

[in] q номер вершины профиля return константную ссылку на вершину профиля

Definition at line 113 of file Airfoil2D.h.

        {
            return (q < r_.size()) ? r_[q] : r_[0];
        };

Here is the caller graph for this function:

◆ getV()

const Point2D & VM2D::AirfoilGeometry::getV ( size_t q ) const

inlineinherited

Возврат константной ссылки на скорость вершины профиля

Организовано "зацикливание" в сторону увеличения индекса, т.е. getV[size()] = getV[0];

Это позволяет удобно обращаться к getV(i) и getV(i+1) как к скоростям начала и конца i-й панели

Parameters

[in] q номер вершины профиля return константную ссылку на скорость вершины профиля

Definition at line 137 of file Airfoil2D.h.

        {
            return (q < v_.size()) ? v_[q] : v_[0];
        };

Here is the caller graph for this function:

◆ IFCUDA() [1/14]

VM2D::Airfoil::IFCUDA ( mutable double * devAttachedSourceSheetLinPtr )

inherited

Указатель на девайсе, где хранятся интенсивности (линейные) присоединенного слоя источников на панелях

◆ IFCUDA() [2/14]

VM2D::Airfoil::IFCUDA ( mutable double * devAttachedSourceSheetPtr )

inherited

Указатель на девайсе, где хранятся интенсивности (константные) присоединенного слоя источников на панелях

◆ IFCUDA() [3/14]

VM2D::Airfoil::IFCUDA ( mutable double * devAttachedVortexSheetLinPtr )

inherited

Указатель на девайсе, где хранятся интенсивности (линейные) присоединенного вихревого слоя на панелях

◆ IFCUDA() [4/14]

VM2D::Airfoil::IFCUDA ( mutable double * devAttachedVortexSheetPtr )

inherited

Указатель на девайсе, где хранятся интенсивности (константные) присоединенного вихревого слоя на панелях

◆ IFCUDA() [5/14]

VM2D::Airfoil::IFCUDA ( mutable double * devFreeVortexSheetLinPtr )

inherited

Указатель на девайсе, где хранятся интенсивности (линейные) свободного вихревого слоя на панелях

◆ IFCUDA() [6/14]

VM2D::Airfoil::IFCUDA ( mutable double * devFreeVortexSheetPtr )

inherited

Указатель на девайсе, где хранятся интенсивности (константные) свободного вихревого слоя на панелях

◆ IFCUDA() [7/14]

VM2D::Airfoil::IFCUDA ( mutable double * devMeanEpsOverPanelPtr )

inherited

Указатель на девайсе, где хранятся средние eps на панелях

◆ IFCUDA() [8/14]

VM2D::Airfoil::IFCUDA ( mutable double * devPsnPtr )

inherited

Указатель на девайсе, где хранятся псевдонормали профиля

◆ IFCUDA() [9/14]

VM2D::Airfoil::IFCUDA ( mutable double * devRhsLinPtr )

inherited

Указатель на девайсе, где хранится правая часть (линейная) матрицы

◆ IFCUDA() [10/14]

VM2D::Airfoil::IFCUDA ( mutable double * devRhsPtr )

inherited

Указатель на девайсе, где хранится правая часть (константная) матрицы

◆ IFCUDA() [11/14]

VM2D::Airfoil::IFCUDA ( mutable double * devRPtr )

inherited

Указатель на девайсе, где хранятся вершины профиля

◆ IFCUDA() [12/14]

VM2D::Airfoil::IFCUDA ( mutable double * devViscousStressesPtr )

inherited

Указатель на девайсе, где хранится вектор (по панелям) для силы вязкого трения

◆ IFCUDA() [13/14]

VM2D::Airfoil::IFCUDA ( mutable std::vector< double > tmpRhs )

inherited

Указатель на хосте, где хранится временная часть матрицы, полученная с девайса

◆ IFCUDA() [14/14]

VM2D::Airfoil::IFCUDA ( mutable std::vector< double > tmpViscousStresses )

inherited

Указатель на хосте, где хранится временная часть вектора (по панелям) для силы вязкого трения

◆ isAfter()

bool Airfoil::isAfter	(	size_t	i,
		size_t	j
	)		const

inherited

Проверка, идет ли вершина i следом за вершиной j.

Parameters

[in]	i	проверяемая вершина
[in]	j	контрольная вершина

Returns: true, если i-я вершина следует зп j-й в порядке обхода профиля

Definition at line 76 of file Airfoil2D.cpp.

{
    return ((i == j + 1) || (i == 0 && j == r_.size() - 1));
}//isAfter(...)

Here is the caller graph for this function:

◆ isInsideGabarits()

bool Airfoil::isInsideGabarits ( const Point2D & r ) const

inherited

Определяет, находится ли точка с радиус-вектором \( \vec r \) внутри габаритного прямоугольника профиля

Parameters

[in] r константная ссылка на текущее положение точки

Returns: true, если точка внутри габаритного прямоугольника

Definition at line 83 of file Airfoil2D.cpp.

{
    return (r[0] <= upRight[0] && (r[0] >= lowLeft[0] && r[1] >= lowLeft[1] && r[1] <= upRight[1]));
}//isInsideGabarits(...)

◆ isOutsideGabarits()

bool Airfoil::isOutsideGabarits ( const Point2D & r ) const

inherited

Определяет, находится ли точка с радиус-вектором \( \vec r \) вне габаритного прямоугольника профиля

Parameters

[in] r константная ссылка на текущее положение точки

Returns: true, если точка вне габаритного прямоугольника

Definition at line 90 of file Airfoil2D.cpp.

{
    return (r[0] > upRight[0] || (r[0] < lowLeft[0] || r[1] < lowLeft[1] || r[1] > upRight[1]));
}//isOutsideGabarits(...)

Here is the caller graph for this function:

◆ IsPointInAirfoil()

bool Airfoil::IsPointInAirfoil ( const Point2D & point ) const

virtualinherited

Определяет, находится ли точка с радиус-вектором \( \vec r \) внутри профиля

Parameters

[in] point константная ссылка на текущее положение точки

Returns: true, если точка внутри профиля

Definition at line 1052 of file Airfoil2D.cpp.

{
    double sumAngle = 0.0;
 
    Point2D v1, v2;
 
    for (size_t i = 0; i < r_.size(); ++i)
    {
        v1 = getR(i) - point;
        v2 = getR(i + 1) - point;
        sumAngle += atan2(v1 ^ v2, v1 & v2);
    }
 
    if (fabs(sumAngle) < 0.1)
        return false;
    else
        return true;
}//IsPointInAirfoil(...)

Here is the call graph for this function:

◆ lightningTest()

void Airfoil::lightningTest ( )

inherited

Тест на "отвещенность".

Definition at line 120 of file Airfoil2D.cpp.

{
    if (W.getPassport().timeDiscretizationProperties.saveVPstep > 0)
    {
 
        //Тестируем на "освещенность"
        wayToVertex.clear();
        wayToVertex.resize(getNumberOfPanels(), -1);
 
        for (size_t i = 0; i < getNumberOfPanels(); ++i)
        {
            const Point2D& dest = 0.5 * (getR(i) + getR(i + 1));
 
            bool flag = false;
            int wayNumber = -1;
            size_t j;
 
            do
            {
                flag = false;
                ++wayNumber;
                j = 0;
                for (; j < getNumberOfPanels(); ++j)
                {
                    const Point2D& aflRj = getR(j);
                    const Point2D& aflRj1 = getR(j + 1);
 
                    auto check = [aflRj, aflRj1](const Point2D& start, const Point2D& finish)
                        {
                            return ((((aflRj - start) ^ (finish - start)) * ((aflRj1 - start) ^ (finish - start)) <= 0) && \
                                (((start - aflRj) ^ (aflRj1 - aflRj)) * ((finish - aflRj) ^ (aflRj1 - aflRj)) <= 0));
                        };
 
                    if (i == j)
                        continue;
 
                    for (size_t q = 0; (!flag) && (q < ((wayNumber == 0) ? 1 : possibleWays[wayNumber - 1].size() + 1)); ++q)
                    {
                        Point2D start = ((q == 0) ? rcm : possibleWays[wayNumber - 1][q - 1]);
                        Point2D finish = (wayNumber == 0 || q == possibleWays[wayNumber - 1].size()) ? dest : possibleWays[wayNumber - 1][q];
 
                        flag = (/*flag ||*/ check(start, finish));
                    }
 
                    if (flag)
                        break;
                }//for j
 
                if (j == getNumberOfPanels())
                {
                    wayToVertex[i] = wayNumber;
                    break;
                }
            } while ((wayToVertex[i] == -1) && (wayNumber < possibleWays.size()));
 
            if (wayToVertex[i] == -1)
            {
                std::cout << "Possible way to vertex inside airfoil not found" << std::endl;
                std::cout << "!!!" << std::endl;
                std::cout << "dest = " << 0.5 * (getR(i) + getR(i + 1)) << std::endl;
                std::cout << "j = " << j << std::endl;
                //std::cout << "q = " << q << ", path[q] = " << path[q] << std::endl;
                //std::cout << "i = " << i << std::endl;
                std::cout << "rcm = " << rcm << std::endl;
                std::cout << "possibleWays.size() = " << possibleWays.size() << std::endl;
 
                for (size_t w = 0; w < possibleWays.size(); ++w)
                {
                    std::cout << "Possible way # " << w << std::endl;
                    for (size_t p = 0; p < possibleWays[w].size(); ++p)
                    {
                        std::cout << possibleWays[w][p] << " ";
                    }
                    std::cout << std::endl;
                }
 
 
                std::ofstream airfoilFileStep(W.getPassport().dir + "afl" + std::to_string(W.getCurrentStep()));
                for (size_t s = 0; s < getNumberOfPanels(); ++s)
                    airfoilFileStep << getR(s)[0] << " " << getR(s)[1] << "\n";
                airfoilFileStep.close();
 
                //exit(767);
            }
        }//for i
    }
}//lightningTest()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Move()

void Airfoil::Move ( const Point2D & dr )

virtualinherited

Перемещение профиля

Плоскопараллельно перемещает профиль на вектор \( \overrightarrow{dr} \)

Parameters

[in] dr константная ссылка на вектор перемещения

Definition at line 1131 of file Airfoil2D.cpp.

{
    for (size_t i = 0; i < r_.size(); ++i)
        r_[i] += dr;
    rcm += dr;
 
    for (size_t q = 0; q < possibleWays.size(); ++q)
        for (Point2D& pts : possibleWays[q])
            pts += dr;
 
    CalcNrmTauLen();
    GetGabarits();
}//Move(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReadFromFile()

void Airfoil::ReadFromFile ( const std::string & dir )

virtualinherited

Считывание профиля из файла

Считывание геометрии профиля из файла, вычисление всех прочих параметров профиля
После загрузки из файла профиль поворачивается на нужный угол и масштабируется на нужный коэффициент

Warning: Сейчас масса, момент инерции и скорости вершин зануляются.

Parameters

[in] dir константная ссылка на строку — имя каталога, где лежит cчитываемый файл

Definition at line 212 of file Airfoil2D.cpp.

{
    const AirfoilParams& param = W.getPassport().airfoilParams[numberInPassport];
    std::string filename = dir + param.fileAirfoil;
    std::ifstream airfoilFile;
 
    if (fileExistTest(filename, W.getInfo(), true, { "txt", "TXT" }))
    {
        std::stringstream airfoilFile(VMlib::Preprocessor(filename).resultString);
 
        VMlib::StreamParser airfoilParser(W.getInfo(), "airfoil file parser", airfoilFile);
 
        m = 0.0; //TODO
        J = 0.0; //TODO
        rcm = { 0.0, 0.0 }; //TODO
        phiAfl = 0.0;
 
        inverse = param.inverse;
 
 
 
        //*
 
        //Проверяем отсутствие "задвоенных" подряд идущих точек
        //airfoilParser.get("r", r_);
        std::vector<Point2D> rFromFile;
        airfoilParser.get("r", rFromFile);
 
        if (rFromFile.size() > 0)
        {
            if (param.requiredNPanels <= rFromFile.size()) {
 
                r_.reserve(rFromFile.size());
                r_.push_back(rFromFile[0]);
                for (size_t i = 1; i < rFromFile.size(); ++i)
                    if ((rFromFile[i] - rFromFile[i - 1]).length2() > 1e-12)
                        r_.push_back(rFromFile[i]);
 
                //Если первая совпадает с последней, то убираем последнюю
                if ((r_.back() - r_.front()).length2() < 1e-12)
                    r_.resize(r_.size() - 1);
            }
            else
            {
                W.getInfo('e') << "Airfoil shape is given explicitely, it can not be automatically split!" << std::endl;
                exit(200);
            }
        }
        else
        {
            std::vector<GeomPoint> geomFromFile;
 
            airfoilParser.get("geometry", geomFromFile);
 
            if ((geomFromFile.front() - geomFromFile.back()).length2() < 1e-12)
                geomFromFile.resize(geomFromFile.size() - 1);
 
            size_t reqN = param.requiredNPanels;
 
            std::vector<double> L(geomFromFile.size());
            double totalLength = 0.0;
            std::vector<size_t> nc = {};
            std::vector<size_t> ni = {};
 
            for (size_t i = 0; i < geomFromFile.size(); ++i)
            {
                const Point2D& p1 = geomFromFile[i];
                const Point2D& p2 = geomFromFile[(i + 1) % geomFromFile.size()];
 
                L[i] = (p2 - p1).length();
                totalLength += L[i];
            }
 
            /*
            Point2D p1, p2, p3, cc, dd;
            double ie = 0;
            int numOfDivPnt = 12;
            double alpha;
            double rscale = 0.1;
            std::vector<Point2D> pnt(numOfDivPnt);
            std::vector<Point2D> newGeom(numOfDivPnt * geomFromFile.size());
 
            for (size_t i = 0; i < geomFromFile.size(); ++i)
            {
                p1 = (i == 0 ? geomFromFile[(int)geomFromFile.size() - 1].r : geomFromFile[i - 1].r);
                p2 = geomFromFile[i].r;
                p3 = geomFromFile[(i + 1) % geomFromFile.size()].r;
 
                Point2D dc = (p1 - p2).unit() + (p3 - p2).unit();
                ie = dc.dist2To(dc.proj(p1 - p2));
                if (ie < 1e-3) ie = 0;
 
                alpha = (PI - acos(((p3 - p2) & (p1 - p2)) / (sqrt(((p3 - p2) & (p3 - p2)) * ((p1 - p2) & (p1 - p2)))))) / (numOfDivPnt - 1);
 
                cc = p2 + (rscale * ie) * dc;
 
                dd = p2 + (cc - p2).proj(p1 - p2) - cc;
                for (int j = 0; j < numOfDivPnt; ++j)
                    newGeom[i * numOfDivPnt + j] = cc + dd.rotated(j * alpha);
            }
            */
 
            //Ищем первый сплайн
            size_t i = 0;
            std::vector<size_t> splineStart, splineFinish;
 
            while (i < geomFromFile.size())
            {
                while (i < geomFromFile.size() && !(geomFromFile[i].type == "c"))
                    ++i;
 
                if (i < geomFromFile.size())
                {
                    splineStart.push_back(i);
                    ++i;
                    //ищем второй конец
                    while (i < geomFromFile.size() && !(geomFromFile[i].type == "c"))
                        ++i;
 
                    splineFinish.push_back(i);
                }
            }
 
            if ((splineStart.size() > 0) && (splineStart[0] != 0))
                splineFinish.back() = splineStart[0];
 
            if (reqN == 0)
            {
                r_.reserve(geomFromFile.size());
                for (size_t i = 0; i < geomFromFile.size(); ++i)
                    r_.push_back(geomFromFile[i]);
            }
            else
            {
                double hRef = totalLength / reqN;
 
                std::vector<int> nPanels;
 
                bool cyclic = (splineStart.size() == 0);
 
                if (cyclic)
                {
                    splineStart.push_back(0);
                    splineFinish.push_back(geomFromFile.size());
                }
 
                for (size_t s = 0; s < splineStart.size(); ++s)
                {
                    //Сплайн                
                    std::vector<double> T, X, Y;
 
                    size_t splineLegs = splineFinish[s] - splineStart[s];
                    if (splineFinish[s] <= splineStart[s])
                        splineLegs += geomFromFile.size();
 
                    T.reserve(splineLegs + 1);
                    X.reserve(T.size());
                    Y.reserve(T.size());
 
                    double tbuf = 0.0;
 
                    for (size_t i = splineStart[s]; i <= splineStart[s] + splineLegs; ++i)
                    {
                        const Point2D& pt = geomFromFile[i % geomFromFile.size()];
 
                        T.push_back(tbuf);
                        X.push_back(pt[0]);
                        Y.push_back(pt[1]);
 
                        if ((i == splineStart[s]) && (splineFinish[s] - splineStart[s] == 1))
                        {
                            double halfL = (i < geomFromFile.size()) ? 0.5 * L[i] : 0.5 * (geomFromFile.front() - geomFromFile.back()).length();
                            tbuf += halfL;
                            T.push_back(tbuf);
                            Point2D nextPt = geomFromFile[(i + 1) % geomFromFile.size()];
 
                            X.push_back(0.5 * (pt[0] + nextPt[0]));
                            Y.push_back(0.5 * (pt[1] + nextPt[1]));
 
                            tbuf += halfL;
                        }
                        else
                            tbuf += (i < geomFromFile.size()) ? L[i] : (geomFromFile.front() - geomFromFile.back()).length();
                    }
 
                    tk::spline s1, s2;
                    if (cyclic)
                    {
                        s1.set_boundary(tk::spline::cyclic);
                        s2.set_boundary(tk::spline::cyclic);
                    }
                    else
                    {
                        s1.set_boundary(tk::spline::second_deriv, 0.0, tk::spline::second_deriv, 0.0);
                        s2.set_boundary(tk::spline::second_deriv, 0.0, tk::spline::second_deriv, 0.0);
                    }
 
                    s1.set_points(T, X);
                    s2.set_points(T, Y);
 
                    int NumberOfPanelsSpline = (int)ceil(T.back() / hRef);
                    double hSpline = T.back() / NumberOfPanelsSpline;
 
                    for (int i = 0; i < NumberOfPanelsSpline; ++i)
                        r_.push_back({ s1(hSpline * i), s2(hSpline * i) });
 
                    nPanels.push_back(NumberOfPanelsSpline);
 
                }
            }
        }//else geometry
 
        if (r_.size() == 0)
        {
            W.getInfo('e') << "No points on airfoil contour!" << std::endl;
            exit(200);
        }
 
        if (inverse)
            std::reverse(r_.begin(), r_.end());
 
        v_.resize(0);
        for (size_t q = 0; q < r_.size(); ++q)
            v_.push_back({ 0.0, 0.0 });
 
 
        int nPossibleWays;
        int defaultNPossibleWays = 0;
        airfoilParser.get("nPossibleWays", nPossibleWays, &defaultNPossibleWays, false);
 
        possibleWays.resize(nPossibleWays);
        for (int q = 0; q < nPossibleWays; ++q)
            airfoilParser.get("possibleWay" + std::to_string(q + 1), possibleWays[q]);
 
        //определяем начальные габаритные размеры
        auto xMinMax = std::minmax_element(r_.begin(), r_.end(), Point2D::cmp<'x'>);
        auto yMinMax = std::minmax_element(r_.begin(), r_.end(), Point2D::cmp<'y'>);
 
        W.getNonConstPassport().airfoilParams[numberInPassport].initialGab = \
            { Point2D({ (*xMinMax.first)[0], (*yMinMax.first)[1] }), Point2D({ (*xMinMax.second)[0], (*yMinMax.second)[1] }) };
 
        Move(param.basePoint);
        Scale(param.scale);
 
        double rotationAngle = param.angle;
 
        //Для обдува ветром, когда углы считаются по компасу
        //if (W.getPassport().geographicalAngles)
        //  rotationAngle = -param.angle - 0.5 * PI;
 
        Rotate(-rotationAngle);
        //в конце Rotate нормали, касательные и длины вычисляются сами
 
        std::string fname = W.getPassport().dir + "/airfoil-" + std::to_string(numberInPassport) + ".pfl";
        //if (!fileExistTest(fname, W.getInfo()))
        {
            std::ofstream of(fname);
            for (size_t i = 0; i < r_.size(); ++i)
                of << r_[i][0] << " " << r_[i][1] << std::endl;
            of.close();
        }
 
 
        gammaThrough.clear();
        gammaThrough.resize(r_.size(), 0.0);
 
        //Вычисляем площадь
        area = 0.0;
        for (size_t q = 0; q < r_.size(); ++q)
        {
            const Point2D& cntq = 0.5 * (getR(q) + getR(q + 1));
            const Point2D& drq = getR(q + 1) - getR(q);
            area += (cntq[0] * drq[1] - cntq[1] * drq[0]);
        }
        area *= 0.5;
        area = fabs(area);
 
        lightningTest();
    }
}//ReadFromFile(...)

Here is the call graph for this function:

◆ Rotate()

void Airfoil::Rotate ( double alpha )

virtualinherited

Поворот профиля

Поворачивает профиль на угол \( \alpha \) вокруг центра масс

Parameters

[in] alpha угол поворота против часовой стрелки в радианах

Definition at line 1146 of file Airfoil2D.cpp.

{
    phiAfl += alpha;
    nummatrix<double, 2, 2> rotMatrix = { { cos(alpha), -sin(alpha) }, { sin(alpha), cos(alpha) } };
 
    for (size_t i = 0; i < r_.size(); ++i)
        r_[i] = rcm + (rotMatrix & (r_[i] - rcm));
 
    for (size_t q = 0; q < possibleWays.size(); ++q)
        for (Point2D& pts : possibleWays[q])
        {
            Point2D oldPts = pts;
            pts = rcm + (rotMatrix & (oldPts - rcm));
        }
 
    CalcNrmTauLen();
    GetGabarits();
}//Rotate(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scale()

void Airfoil::Scale ( const Point2D & )

virtualinherited

Масштабирование профиля

Масштабирует профиль в factor раз относительно центра масс

Parameters

[in] factor масштабный коэффициент

Definition at line 1167 of file Airfoil2D.cpp.

{
    for (size_t i = 0; i < r_.size(); ++i)
        r_[i] = rcm + Point2D{ factor[0] * (r_[i] - rcm)[0], factor[1] * (r_[i] - rcm)[1] };
 
    for (size_t q = 0; q < possibleWays.size(); ++q)
        for (Point2D& pts : possibleWays[q])
        {
            Point2D oldPts = pts;
            pts = rcm + Point2D{ factor[0] * (oldPts - rcm)[0], factor[1] * (oldPts - rcm)[1] };
        }
 
    CalcNrmTauLen();
    GetGabarits();
}//Scale(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setR()

Point2D & VM2D::AirfoilGeometry::setR ( size_t q )

inlineinherited

Возврат ссылки на вершину профиля

Организовано "зацикливание" в сторону увеличения индекса, т.е. getR[size()] = getR[0];

Это позволяет удобно обращаться к getR(i) и getR(i+1) как к началу и концу i-й панели

Parameters

[in] q номер вершины профиля return ссылку на вершину профиля

Definition at line 125 of file Airfoil2D.h.

        {
            return (q < r_.size()) ? r_[q] : r_[0];
        };

Here is the caller graph for this function:

◆ setV() [1/2]

void VM2D::AirfoilGeometry::setV ( const Point2D & vel )

inlineinherited

Установка постоянной скорости всех вершин профиля

Parameters

[in] vel константная ссылка на величину устанавливаемой скорости

Definition at line 145 of file Airfoil2D.h.

        {
            v_.clear();
            v_.resize(r_.size(), vel);
        }

Here is the caller graph for this function:

◆ setV() [2/2]

void VM2D::AirfoilGeometry::setV ( const std::vector< Point2D > & vel )

inlineinherited

Установка скоростей всех вершин профиля

Parameters

[in] vel константная ссылка на вектор величин скоростей вершин профиля

Definition at line 154 of file Airfoil2D.h.

        {
            v_.clear();
            v_.insert(v_.end(), vel.begin(), vel.end());
        }

Member Data Documentation

◆ area

double VM2D::AirfoilGeometry::area

inherited

Площадь профиля

Definition at line 103 of file Airfoil2D.h.

◆ gammaThrough

std::vector<double> VM2D::Airfoil::gammaThrough

inherited

Суммарные циркуляции вихрей, пересекших панели профиля на прошлом шаге

Используются в правой части системы, чтобы компенсировать вихри, проникшие в профиль

Definition at line 276 of file Airfoil2D.h.

◆ inverse

bool VM2D::AirfoilGeometry::inverse

inherited

Признак разворота нормалей (для расчета внутренних течений)

Definition at line 76 of file Airfoil2D.h.

◆ J

double VM2D::Airfoil::J

inherited

Полярный момент инерции профиля относительно центра масс

Definition at line 196 of file Airfoil2D.h.

◆ len

std::vector<double> VM2D::AirfoilGeometry::len

inherited

Длины панелей профиля

Definition at line 94 of file Airfoil2D.h.

◆ lowLeft

Point2D VM2D::Airfoil::lowLeft

inherited

Левый нижний угол габаритного прямоугольника профиля

Definition at line 270 of file Airfoil2D.h.

◆ m

double VM2D::Airfoil::m

inherited

Масса профиля

Definition at line 193 of file Airfoil2D.h.

◆ meanEpsOverPanel

std::vector<double> VM2D::Airfoil::meanEpsOverPanel

inherited

Средние значения Eps на панелях

Definition at line 209 of file Airfoil2D.h.

◆ nrm

std::vector<Point2D> VM2D::AirfoilGeometry::nrm

inherited

Нормали к панелям профиля

Нормали задаются внешними, нормированными на единицу

Definition at line 81 of file Airfoil2D.h.

◆ numberInPassport

const size_t VM2D::Airfoil::numberInPassport

inherited

Номер профиля в паспорте

Definition at line 188 of file Airfoil2D.h.

◆ phiAfl

double VM2D::AirfoilGeometry::phiAfl

inherited

Поворот профиля

Definition at line 100 of file Airfoil2D.h.

◆ possibleWays

std::vector<std::vector<Point2D> > VM2D::Airfoil::possibleWays

inherited

Возможные пути внутри профиля от точки (0, 0) к центрам всех панелей

Definition at line 199 of file Airfoil2D.h.

◆ psn

std::vector<std::pair<Point2D, Point2D> > VM2D::AirfoilGeometry::psn

inherited

Псевдонормали к панелям профиля

Псевдонормали к началу и концу панели, нормированные на единицу

Definition at line 86 of file Airfoil2D.h.

◆ r_

std::vector<Point2D> VM2D::AirfoilGeometry::r_

protectedinherited

Координаты начал панелей

Definition at line 69 of file Airfoil2D.h.

◆ rcm

Point2D VM2D::AirfoilGeometry::rcm

inherited

Положение центра масс профиля

Definition at line 97 of file Airfoil2D.h.

◆ tau

std::vector<Point2D> VM2D::AirfoilGeometry::tau

inherited

Касательные к панелям профиля

Касательные соответствуют обходу профиля против часовой стрелки, задаются нормированными на единицу

Definition at line 91 of file Airfoil2D.h.

◆ upRight

Point2D VM2D::Airfoil::upRight

inherited

Правый верхний угол габаритного прямоугольника профиля

Definition at line 271 of file Airfoil2D.h.

◆ v_

std::vector<Point2D> VM2D::AirfoilGeometry::v_

protectedinherited

Скорости начал панелей

Definition at line 72 of file Airfoil2D.h.

◆ viscousStress

std::vector<double> VM2D::Airfoil::viscousStress

inherited

Нейросеть для коэффициентов I0 и I3 диффузионной скорости

Касательные напряжения на панелях профиля

Definition at line 268 of file Airfoil2D.h.

◆ W

const World2D& VM2D::Airfoil::W

inherited

Константная ссылка на решаемую задачу

Definition at line 185 of file Airfoil2D.h.

◆ wayToVertex

std::vector<int> VM2D::Airfoil::wayToVertex

inherited

Номера путей к вершинам

Definition at line 202 of file Airfoil2D.h.

The documentation for this class was generated from the following file:

VM2D/Airfoil2D/Airfoil2DRigid.h

Public Member Functions

Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AirfoilRigid() [1/2]

◆ AirfoilRigid() [2/2]

◆ ~AirfoilRigid()

Member Function Documentation

◆ calcIQ()

◆ calcMeanEpsOverPanel()

◆ CalcNrmTauLen()

◆ getA()

◆ GetDiffVelocityI0I3ToSetOfPointsAndViscousStresses()

◆ GetGabarits()

◆ GetInfluenceFromSourceSheetToVortex()

◆ GetInfluenceFromSourcesToPanel()

◆ GetInfluenceFromVInfToPanel()

◆ GetInfluenceFromVortexSheetToVortex()

◆ GetInfluenceFromVorticesToPanel()

◆ getNumberOfPanels()

◆ getR()

◆ getV()

◆ IFCUDA() [1/14]

◆ IFCUDA() [2/14]

◆ IFCUDA() [3/14]

◆ IFCUDA() [4/14]

◆ IFCUDA() [5/14]

◆ IFCUDA() [6/14]

◆ IFCUDA() [7/14]

◆ IFCUDA() [8/14]

◆ IFCUDA() [9/14]

◆ IFCUDA() [10/14]

◆ IFCUDA() [11/14]

◆ IFCUDA() [12/14]

◆ IFCUDA() [13/14]

◆ IFCUDA() [14/14]

◆ isAfter()

◆ isInsideGabarits()

◆ isOutsideGabarits()

◆ IsPointInAirfoil()

◆ lightningTest()

◆ Move()

◆ ReadFromFile()

◆ Rotate()

◆ Scale()

◆ setR()

◆ setV() [1/2]

◆ setV() [2/2]

Member Data Documentation

◆ area

◆ gammaThrough

◆ inverse

◆ J

◆ len

◆ lowLeft

◆ m

◆ meanEpsOverPanel

◆ nrm

◆ numberInPassport

◆ phiAfl

◆ possibleWays

◆ psn

◆ r_

◆ rcm

◆ tau

◆ upRight

◆ v_

◆ viscousStress

◆ W

◆ wayToVertex