Класс, опеделяющий вихревой след (пелену) More...

#include <Wake2D.h>

Inheritance diagram for VM2D::Wake:

Collaboration diagram for VM2D::Wake:

[legend]

Public Member Functions
	Wake (const World2D &W_)
	Конструктор инициализации

	~Wake ()
	Деструктор

void	Inside (const std::vector< Point2D > &newPos, Airfoil &afl, bool isMoves, const AirfoilGeometry &oldAfl)
	Проверка пересечения вихрями следа профиля при перемещении

void	Restruct ()
	Реструктуризация вихревого следа

int	RemoveFar ()
	Зануление далеко улетевших вихрей

size_t	RemoveZero ()
	Исключение нулевых и мелких вихрей

bool	MoveInside (const Point2D &newPos, const Point2D &oldPos, const Airfoil &afl, size_t &panThrough) const
	Проверка проникновения точки через границу профиля

bool	MoveInsideMovingBoundary (const Point2D &newPos, const Point2D &oldPos, const AirfoilGeometry &oldAfl, const Airfoil &afl, size_t &panThrough) const
	Проверка проникновения точки через границу профиля

void	GetPairs (int type)
	Поиск ближайшего соседа

void	GetPairsBS (int type)

void	GetPairsClosestNeib (int type)

void	GetPairsBH (int type)

int	Collaps (int type, int times)
	Коллапс вихрей

int	CollapsNew (int type, int times)

int	CollapsNewFast (int type, int times, std::vector< Vortex2D > &ri, std::vector< Vortex2D > &rj, std::vector< Point2D > &rnew, std::vector< std::pair< int, int > > &rindex)

void	ReadFromFile (const std::string &dir, const std::string &fileName)
	Считывание вихревого следа из файла

void	SaveKadrVtk (const std::string &filePrefix="Kadr") const
	Сохранение вихревого следа в файл .vtk.

Public Attributes
double	collapseRightBorderParameter
	абсцисса, правее которой происходит линейный (вправо) рост радиуса коллапса

double	collapseScaleParameter
	характерный масштаб, на котором происходит рост радиуса коллапса

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

std::vector< Vortex2D >	vtx
	Список вихревых элементов

Private Attributes
std::vector< int >	neighb
	Вектор потенциальных соседей для будущего коллапса

std::vector< int >	neighbNew

Detailed Description

Класс, опеделяющий вихревой след (пелену)

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

Version: 1.14

Date: 6 марта 2026 г.

Definition at line 62 of file Wake2D.h.

Constructor & Destructor Documentation

◆ Wake()

VM2D::Wake::Wake ( const World2D & W_ )

inline

Конструктор инициализации

Parameters

[in] W_ константная ссылка на решаемую задачу

Definition at line 76 of file Wake2D.h.

            : WakeDataBase(W_)
        {
            collapseRightBorderParameter = 0.0;
            collapseScaleParameter = 1.0;
        };

◆ ~Wake()

VM2D::Wake::~Wake ( )

inline

Деструктор

Definition at line 84 of file Wake2D.h.

84{ };

Member Function Documentation

◆ Collaps()

int Wake::Collaps	(	int	type,
		int	times
	)

Коллапс вихрей

Parameters

[in]	type	тип коллапса: 0 — без приоритета знаков 1 — коллапсировать только вихри разных знаков 2 — коллапсировать только вихри одного знака
[in]	times	число проходов алгоритма коллапса

Returns: число зануленных вихрей

Definition at line 476 of file Wake2D.cpp.

{
    int nHlop = 0; //общее число убитых вихрей
 
    //int loc_hlop = 0; //
 
    std::vector<bool> flag; //как только вихрь сколлапсировался  flag = 1
    for (int z = 0; z < times; ++z)
    {
 
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_PAIRS))   
        W.timerMerging.reset();
        W.timerMerging.start();
        //if (W.getPassport().numericalSchemes.velocityComputation.second == 0)
        {
            const_cast<Gpu&>(W.getCuda()).RefreshWake(3);
            
            double NeibStart = omp_get_wtime();
            GPUGetPairs(type);
            double NeibFinish = omp_get_wtime();
            std::cout << "GPU_direct_closest_neib = " << NeibFinish - NeibStart << std::endl;
        }
        W.timerMerging.stop();
 
        //else
        //{
        //  double NeibStart = omp_get_wtime();
        //  GetPairs(type);
        //  //GetPairsClosestNeib(type);
        //  double NeibFinish = omp_get_wtime();
        //  std::cout << "CPU_direct_closest_neib = " << NeibFinish - NeibStart << std::endl;                   
        //}
#else
        GetPairs(type);
#endif          
 
        
        //std::ofstream neibFile(W.getPassport().dir + "neib" + std::to_string(W.currentStep));
        //for (size_t q = 0; q < neighb.size(); ++q)
        //  neibFile << q << " " << neighb[q] << std::endl;
        //neibFile.close();
        
 
        //loc_hlop = 0;//число схлопнутых вихрей
//*
        flag.clear();
        flag.resize(vtx.size(), false);
 
        double sumAbsGam, iws;
        Point2D newPos;
 
        for (size_t vt = 0; vt + 1 < vtx.size(); ++vt)
        {
            Vortex2D& vtxI = vtx[vt];
 
            if (!flag[vt])
            {
                int ssd = neighb[vt];
 
                if ((ssd < 0) || (ssd >= flag.size()))
                    std::cout << "ssd = " << ssd << ", flag.size() = " << flag.size() << ", vtx.size() = " << vtx.size() << std::endl;
 
                if ((ssd != 0) && (!flag[ssd]))
                {
                    Vortex2D& vtxK = vtx[ssd];
 
                    flag[ssd] = true;
 
                    Vortex2D sumVtx;
                    sumVtx.g() = vtxI.g() + vtxK.g();
                    sumVtx.sigma() = std::max(vtxI.sigma(), vtxK.sigma());
 
                    switch (type)
                    {
                    case 0:
                    case 2:
                        sumAbsGam = fabs(vtxI.g()) + fabs(vtxK.g());
 
                        iws = sumAbsGam > 1e-10 ? 1.0 / sumAbsGam : 1.0;
 
                        sumVtx.r() = (vtxI.r() * fabs(vtxI.g()) + vtxK.r() * fabs(vtxK.g())) * iws;
                        break;
 
                    case 1:
                        sumVtx.r() = (fabs(vtxI.g()) > fabs(vtxK.g())) ? vtxI.r() : vtxK.r();
                        break;
                    }
 
                    bool fl_hit = true;
                    //double Ch1[2];
                    size_t hitpan = -1;
 
                    for (size_t afl = 0; afl < W.getNumberOfAirfoil(); ++afl)
                    {
                        //проверим, не оказался ли новый вихрь внутри контура
                        if (MoveInside(sumVtx.r(), vtxI.r(), W.getAirfoil(afl), hitpan) || MoveInside(sumVtx.r(), vtxK.r(), W.getAirfoil(afl), hitpan))
                            fl_hit = false;
                    }//for
 
                    if (fl_hit)
                    {
                        vtxI = sumVtx;
                        vtxK.g() = 0.0;
                        nHlop++;
                    }//if (fl_hit)
 
                }//if ((ssd!=0)&&(!flag[ssd]))
            }//if !flag[vt] 
        }//for vt
//*/
    }//for z
 
    return nHlop;
}//Collaps(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollapsNew()

int Wake::CollapsNew	(	int	type,
		int	times
	)

Definition at line 592 of file Wake2D.cpp.

{
    int nHlop = 0; //общее число убитых вихрей
 
    const double& cSP = collapseScaleParameter;
    const double& cRBP = collapseRightBorderParameter;
 
    double maxG = W.getPassport().wakeDiscretizationProperties.maxGamma;
 
    //int loc_hlop = 0; // neigh
 
    std::vector<bool> flag; //как только вихрь сколлапсировался  flag = 1
    
    for (int z = 0; z < times; ++z)
    {
        //loc_hlop = 0;//число схлопнутых вихрей
 
        flag.clear();
        flag.resize(vtx.size(), false);
 
        double sumAbsGam, iws;
        Point2D newPos;
        
        for (size_t vt = 0; vt + 1 < vtx.size(); ++vt)
        {
            Vortex2D& vtxI = vtx[vt];
            if (!flag[vt])
            {           
 
                for (int s = 0; s < knbForRestruct; ++s)
                {
                    //int ssd = neighb[vt];
                    int ssd = neighbNew[vt * knbForRestruct + s];
                    if (ssd == 0)
                        continue;
 
                    Vortex2D& vtxK = vtx[ssd];
 
                    if (/*(ssd != 0) &&*/ (!flag[ssd])) //ssd==0 always true
                    {
                        
 
                        Vortex2D sumVtx;
                        sumVtx.g() = vtxI.g() + vtxK.g();
                        sumVtx.sigma() = std::max(vtxI.sigma(), vtxK.sigma());
 
                        switch (type)
                        {
                        case 0:
                        case 2:
                            sumAbsGam = fabs(vtxI.g()) + fabs(vtxK.g());
                            iws = sumAbsGam > 1e-10 ? 1.0 / sumAbsGam : 1.0;
                            sumVtx.r() = (vtxI.r() * fabs(vtxI.g()) + vtxK.r() * fabs(vtxK.g())) * iws;
                            break;
 
                        case 1:
                            sumVtx.r() = (fabs(vtxI.g()) > fabs(vtxK.g())) ? vtxI.r() : vtxK.r();
                            break;
                        }
 
                        bool fl_hit = true;
                        size_t hitpan = -1;
 
                        for (size_t afl = 0; afl < W.getNumberOfAirfoil(); ++afl)
                        {
                            //проверим, не оказался ли новый вихрь внутри контура
                            if (MoveInside(sumVtx.r(), vtxI.r(), W.getAirfoil(afl), hitpan) || MoveInside(sumVtx.r(), vtxK.r(), W.getAirfoil(afl), hitpan))
                            {
                                //std::cout << "HIT" << std::endl;
                                fl_hit = false;
                            }
                        }//for
 
                        if (fl_hit)
                        {
                            vtxI = sumVtx;
                            vtxK.g() = 0.0;
                            nHlop++;
                            flag[vt] = true;
                            flag[ssd] = true;
                        }//if (fl_hit)
 
                    }//if ((ssd!=0)&&(!flag[ssd]))
 
                    if (flag[vt])
                        break;
                }// for s
            }//if !flag[vt] 
        }//for vt
 
    }//for z
 
    return nHlop;
}//CollapsNew(...)

Here is the call graph for this function:

◆ CollapsNewFast()

int Wake::CollapsNewFast	(	int	type,
		int	times,
		std::vector< Vortex2D > &	ri,
		std::vector< Vortex2D > &	rj,
		std::vector< Point2D > &	rnew,
		std::vector< std::pair< int, int > > &	rindex
	)

Definition at line 688 of file Wake2D.cpp.

{
    int nHlop = 0; //общее число убитых вихрей
 
    const double& cSP = collapseScaleParameter;
    const double& cRBP = collapseRightBorderParameter;
 
    double maxG = W.getPassport().wakeDiscretizationProperties.maxGamma;
 
    //int loc_hlop = 0; // neigh
 
    std::vector<bool> flag; //как только вихрь сколлапсировался  flag = 1
 
    for (int z = 0; z < times; ++z)
    {
        //loc_hlop = 0;//число схлопнутых вихрей
 
        flag.clear();
        flag.resize(vtx.size(), false);
 
        double sumAbsGam, iws;
        Point2D newPos;
 
        for (size_t vt = 0; vt + 1 < vtx.size(); ++vt)
        {
            Vortex2D& vtxI = vtx[vt];
            if (!flag[vt])
            {
 
                for (int s = 0; s < knbForRestruct; ++s)
                {
                    //int ssd = neighb[vt];
                    int ssd = neighbNew[vt * knbForRestruct + s];
                    if (ssd == 0)
                        continue;
 
                    Vortex2D& vtxK = vtx[ssd];
 
                    if (/*(ssd != 0) &&*/ (!flag[ssd])) //ssd==0 always true
                    {
 
 
                        Vortex2D sumVtx;
                        sumVtx.g() = vtxI.g() + vtxK.g();
                        sumVtx.sigma() = std::max(vtxI.sigma(), vtxK.sigma());
 
                        switch (type)
                        {
                        case 0:
                        case 2:
                            sumAbsGam = fabs(vtxI.g()) + fabs(vtxK.g());
                            iws = sumAbsGam > 1e-10 ? 1.0 / sumAbsGam : 1.0;
                            sumVtx.r() = (vtxI.r() * fabs(vtxI.g()) + vtxK.r() * fabs(vtxK.g())) * iws;
                            break;
 
                        case 1:
                            sumVtx.r() = (fabs(vtxI.g()) > fabs(vtxK.g())) ? vtxI.r() : vtxK.r();
                            break;
                        }
 
                        bool fl_hit = true;
                        size_t hitpan = -1;
 
                        //for (size_t afl = 0; afl < W.getNumberOfAirfoil(); ++afl) //кол-во профилей
                        //{
                            ri.push_back(Vortex2D(vtxI.r(), vtxI.g(), vtxI.sigma()));
                            rj.push_back(Vortex2D(vtxK.r(), vtxK.g(), vtxK.sigma()));
                            rindex.push_back({ (int)vt, ssd });
                            rnew.push_back(sumVtx.r());                         
                            nHlop++;
                            flag[vt] = true;
                            flag[ssd] = true;
                            
                            //проверим, не оказался ли новый вихрь внутри контура
                            //if (MoveInside(sumVtx.r(), vtxI.r(), W.getAirfoil(afl), hitpan) || MoveInside(sumVtx.r(), vtxK.r(), W.getAirfoil(afl), hitpan))
                            //{
                            //  //std::cout << "HIT" << std::endl;
                            //  fl_hit = false;
                            //}
                        //}//for
 
                        //if (fl_hit)
                        //{
                        //  vtxI = sumVtx;
                        //  vtxK.g() = 0.0;
                        //  //nHlop++;
                        //  flag[vt] = true;
                        //  flag[ssd] = true;
                        //}//if (fl_hit)
 
                    }//if ((ssd!=0)&&(!flag[ssd]))
 
                    if (flag[vt])
                        break;
                }// for s
            }//if !flag[vt] 
        }//for vt
 
    }//for z
 
    return nHlop;
}//CollapsNew(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPairs()

void Wake::GetPairs ( int type )

Поиск ближайшего соседа

Parameters

[in]

type

тип коллапса:

0 — без приоритета знаков
1 — коллапсировать только вихри разных знаков
2 — коллапсировать только вихри одного знака

Definition at line 319 of file Wake2D.cpp.

{
    GetPairsBS(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPairsBH()

void VM2D::Wake::GetPairsBH ( int type )

◆ GetPairsBS()

void Wake::GetPairsBS ( int type )

Todo:: Доделать

Definition at line 325 of file Wake2D.cpp.

{
    neighb.resize(vtx.size(), 0);
    
    Point2D Ri, Rk;
 
    double maxG = W.getPassport().wakeDiscretizationProperties.maxGamma;
 
#pragma omp parallel for default(none) shared(type, maxG) schedule(dynamic, DYN_SCHEDULE)
    for (int i = 0; i < vtx.size(); ++i)
    {
        neighb[i] = 0;
        int s = i;
        const Vortex2D& vtxI = vtx[i];  
 
        bool found = false;
 
        double r2, r2test;
 
        const double& cSP = collapseScaleParameter;
        const double& cRBP = collapseRightBorderParameter;
 
        while ( (!found) && ( s + 1 < (int)vtx.size() ) )
        {
            s++;
            const Vortex2D& vtxK = vtx[s];
 
            r2 = dist2(vtxI.r(), vtxK.r());
 
            //линейное увеличение радиуса коллапса                  
            double mnog = std::max(1.0, /* 2.0 * */ (vtxI.r()[0] - cRBP) / cSP);
 
            r2test = sqr( W.getPassport().wakeDiscretizationProperties.epscol * mnog );
 
            if (type == 1)
                r2test *= 4.0; //Увеличение радиуса коллапса в 2 раза для коллапса вихрей разных знаков         
 
            if (r2 < r2test)
            {
                switch (type)
                {
                    case 0:
                        found = ( vtxI.g()*vtxK.g() != 0.0) && (fabs(vtxI.g() + vtxK.g()) < sqr(mnog) * maxG);
                        break;
                    case 1:
                        found = (vtxI.g()*vtxK.g() < 0.0);
                        break;
                    case 2:
                        found = (vtxI.g()*vtxK.g() > 0.0) && (fabs(vtxI.g() + vtxK.g()) < sqr(mnog) * maxG); 
                        break;
                }
            }//if r2 < r2_test
        }//while
 
        if (found)
            neighb[i] = s;
    }//for locI 
}//GetPairsBS(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPairsClosestNeib()

void Wake::GetPairsClosestNeib ( int type )

Definition at line 386 of file Wake2D.cpp.

{
    neighb.resize(vtx.size(), 0);
 
    Point2D Ri, Rk;
 
    double maxG = W.getPassport().wakeDiscretizationProperties.maxGamma;
 
#pragma omp parallel for default(none) shared(type, maxG) schedule(dynamic, DYN_SCHEDULE)
    for (int i = 0; i < vtx.size(); ++i)
    {
        neighb[i] = 0;
        int s = i;
        const Vortex2D& vtxI = vtx[i];
 
        bool found = false;
 
        double r2, r2test = 1e+10;
 
        const double& cSP = collapseScaleParameter;
        const double& cRBP = collapseRightBorderParameter;
 
        while (/*(!found) &&*/ (s + 1 < (int)vtx.size()))
        {
            s++;
            const Vortex2D& vtxK = vtx[s];
 
            r2 = dist2(vtxI.r(), vtxK.r());
 
            if (r2 < r2test)
            {
                r2test = r2;
                neighb[i] = s;
            }//if r2 < r2_test
        }//while        
            
    }//for locI 
}//GetPairsClosestNeib(...)

Here is the call graph for this function:

◆ Inside()

void Wake::Inside	(	const std::vector< Point2D > &	newPos,
		Airfoil &	afl,
		bool	isMoves,
		const AirfoilGeometry &	oldAfl
	)

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

Исполняется сразу для всех вихрей в пелене, осуществляет проверку для отдельного профиля
Вихри, попавшие внутрь профиля, получают нулевую циркуляцию, а их "бывшая" циркуляция передается в вектор gammaThrough в структуру данных профиля

Parameters

[in]	newPos	константная ссылка на вектор из новых положений вихрей в вихревом следе
[in]	isMoves	признак того, что профиль подвижный
[in]	oldAfl	константная ссылка контролируемый профиль до перемещения (используется, если у профиля стоит признак того, что он движется)
[in,out]	afl	ссылка на контролируемый профиль (происходит изменение afl->gammaThrough)

Definition at line 274 of file Wake2D.cpp.

{
    std::vector<double> gamma;
    gamma.resize(afl.getNumberOfPanels(), 0.0);
 
    std::vector<int> through;
    through.resize(vtx.size(), -1);
 
//#pragma omp parallel for default(none) shared(afl, oldAfl, isMoves, through, newPos) 
    for (int i = 0; i < (int)vtx.size(); ++i)
    {       
        size_t minN;
 
        bool crit = isMoves ? MoveInsideMovingBoundary(newPos[i], vtx[i].r(), oldAfl, afl, minN) : MoveInside(newPos[i], vtx[i].r(), afl, minN);
        
        if (crit)
            through[i] = (int)minN;
    }//for i    
 
 
    //std::stringstream sss;
    //sss << "through_" << W.currentStep;
    //std::ofstream of(W.getPassport().dir + "dbg/" + sss.str());
    //for (size_t i = 0; i < gamma.size(); ++i)
    //  of << gamma[i] << std::endl;
    //of.close();
 
    //std::stringstream sss;
    //sss << "through_" << W.currentStep;
    //std::ofstream of(W.getPassport().dir + "dbg/" + sss.str());
    //for (size_t i = 0; i < gamma.size(); ++i)
    //  of << through[i] << std::endl;
    //of.close();
 
    for (size_t q = 0; q < through.size(); ++q)
    if (through[q] > -1)
    {
        gamma[through[q]] += vtx[q].g();
        vtx[q].g() = 0.0;
    }
 
    afl.gammaThrough = gamma;   
}//Inside(...)

Here is the call graph for this function:

◆ MoveInside()

bool Wake::MoveInside	(	const Point2D &	newPos,
		const Point2D &	oldPos,
		const Airfoil &	afl,
		size_t &	panThrough
	)		const

Проверка проникновения точки через границу профиля

Parameters

[in]	newPos	константная ссылка на смещенное (новое) положение
[in]	oldPos	константная ссылка на несмещенное (старое) положение
[in]	afl	константная ссылка на контролируемый профиль
[out]	panThrough	номер "протыкаемой" панели return признак пересечения профиля

Definition at line 63 of file Wake2D.cpp.

{
    //const double porog_r = 1e-12;
    
    //double minDist = 1.0E+10; //расстояние до пробиваемой панели
    panThrough = -1;
 
    //проверка габ. прямоугольника
    
    if (afl.isOutsideGabarits(newPos) && afl.isOutsideGabarits(oldPos))
    { 
        ++W.gabb;
        return false;
    }
 
    //если внутри габ. прямоугольника - проводим контроль
    bool hit = false;
 
    
    for (size_t j = 0; j < afl.getNumberOfPanels(); ++j)
    {
        const Point2D& aflRj = afl.getR(j);
        const Point2D& aflRj1 = afl.getR(j + 1);
 
        ++W.checkPan;
 
        if ((((aflRj - oldPos) ^ (newPos - oldPos)) * ((aflRj1 - oldPos) ^ (newPos - oldPos)) <= 0) && \
            (((oldPos - aflRj) ^ (aflRj1 - aflRj)) * ((newPos - aflRj) ^ (aflRj1 - aflRj)) <= 0))
        {
            hit = true;
            panThrough = j;                     
            break;
        }
    }//for j
 
 
    
    if (hit)
        ++W.check01;
    else
        ++W.check02;
 
    return hit;
}//MoveInside(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MoveInsideMovingBoundary()

bool Wake::MoveInsideMovingBoundary	(	const Point2D &	newPos,
		const Point2D &	oldPos,
		const AirfoilGeometry &	oldAfl,
		const Airfoil &	afl,
		size_t &	panThrough
	)		const

Проверка проникновения точки через границу профиля

Parameters

[in]	newPos	константная ссылка на смещенное (новое) положение вихря
[in]	oldPos	константная ссылка на несмещенное (старое) положение вихря
[in]	oldAfl	константная ссылка на состояние контролируемого профиля до перемещения
[in]	afl	константная ссылка на контролируемый профиль
[out]	panThrough	номер "протыкаемой" панели return признак пересечения профиля

Todo:: сравнить производительности двух inside-ов

Definition at line 179 of file Wake2D.cpp.

{
    panThrough = -1;
 
 
    //проверка габ. прямоугольника
    if (!afl.inverse && afl.isOutsideGabarits(newPos) && afl.isOutsideGabarits(oldPos))
        return false;
 
    bool hit = false;
 
    double angle = 0;
    double cs, sn;
 
    double dist2 = 1000000000.0;
 
    for (size_t i = 0; i < afl.getNumberOfPanels(); ++i)
    {
        Point2D v1, v2, vv;
        v1 = afl.getR(i) - newPos;
                        
        v2 = afl.getR(i + 1) - newPos;
                        
        vv = afl.getR(i + 1) - afl.getR(i);
 
        double dst = v1.length2() + v2.length2();
        if (dst < dist2)
        {
            dist2 = dst;
            panThrough = i;
        }
 
        cs = v1 & v2;
        sn = v1 ^ v2;
        
        angle += atan2(sn, cs);
    }//for i
 
    hit = ((angle > 3.14) || (angle < -3.14));
    
    if (afl.inverse)
        hit = !hit;
 
    return hit;
}//MoveInsideMovingBoundary(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReadFromFile()

void WakeDataBase::ReadFromFile	(	const std::string &	dir,
		const std::string &	fileName
	)

inherited

Считывание вихревого следа из файла

Parameters

[in]	dir	константная ссылка на строку, задающую каталог, где лежит файл с вихревым следом
[in]	fileName	константная ссылка на строку, задающую имя файла с вихревым следом

Definition at line 56 of file WakeDataBase2D.cpp.

{
    std::string filename = dir + fileName;
    std::ifstream wakeFile, testFile;
    
    char firstChar = '/', secondChar = '*';
 
    if (fileExistTest(filename, W.getInfo(), true, { "txt", "TXT" }))
    {       
        testFile.open(filename);
        testFile >> firstChar;
        testFile >> secondChar;
 
        //std::cout << "CHARS: " << firstChar << " " << secondChar << std::endl;
        testFile.close();
    }
 
 
    //Считывание из словаря
    if (firstChar == '/' && secondChar == '*')
    {
        if (fileExistTest(filename, W.getInfo(), true, { "txt", "TXT" }))
        {
            std::stringstream wakeFile(VMlib::Preprocessor(filename).resultString);
 
            VMlib::LogStream XXX;
            VMlib::StreamParser wakeParser(XXX, "vortex wake file parser", wakeFile);
 
            wakeParser.get("vtx", vtx);
 
            for (auto& v : vtx)
                v.sigma() = W.getPassport().wakeDiscretizationProperties.sigma0;
 
        }
    }
    else
    {
        //Считывание из обычного текстового файла
        if (fileExistTest(filename, W.getInfo(), true, { "txt", "TXT" }))
        {
            wakeFile.open(filename);
            int nnn;
            wakeFile >> nnn;
            vtx.reserve(nnn);
            for (int i = 0; i < nnn; ++i)
            {
                Vortex2D v;
                wakeFile >> v.r()[0] >> v.r()[1] >> v.g();              
                v.sigma() = W.getPassport().wakeDiscretizationProperties.sigma0;
                vtx.push_back(v);
            }
 
            wakeFile.close();
        }
    }
 
}//ReadFromFile(...)

Here is the call graph for this function:

◆ RemoveFar()

int Wake::RemoveFar ( )

Зануление далеко улетевших вихрей

Returns: число вихрей в дальнем следе, которые занулены

Todo:: Пока профиль 1, расстояние от его центра; сделать от самого правого профиля

Definition at line 793 of file Wake2D.cpp.

{
    int nFar = 0;
    double distFar2 = sqr(W.getPassport().wakeDiscretizationProperties.distFar);
    Point2D zerovec = { 0.0, 0.0 };
#pragma omp parallel for default(none) shared(distFar2, zerovec) reduction(+:nFar)
    for (int i = 0; i <static_cast<int>(vtx.size()); ++i)
    {
        if (dist2(vtx[i].r(), zerovec) > distFar2)
        {
            vtx[i].g() = 0.0;
            nFar++; 
        }
    }
 
    return nFar;
}//RemoveFar()

Here is the call graph for this function:

◆ RemoveZero()

size_t Wake::RemoveZero ( )

Исключение нулевых и мелких вихрей

Returns: число исключенных вихрей

Definition at line 813 of file Wake2D.cpp.

{
    const double porog_g = 1e-15;
 
    std::vector<Vortex2D/*, VM2D::MyAlloc<VMlib::Vortex2D>*/> newWake;
 
    newWake.reserve(vtx.size());
 
    for (size_t q = 0; q < vtx.size(); ++q)
    if (fabs(vtx[q].g()) > porog_g)
        newWake.push_back(vtx[q]);
 
    size_t delta = vtx.size() - newWake.size();
 
    newWake.swap(vtx);
 
    return delta;
}//RemoveZero()

◆ Restruct()

void Wake::Restruct ( )

Реструктуризация вихревого следа

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

Definition at line 836 of file Wake2D.cpp.

{
    W.getTimers().start("Restr");   
 
    if (W.getPassport().wakeDiscretizationProperties.epscol > 0)
    {
        double timePreKnn = -omp_get_wtime();
 
        // Определение параметров, отвечающих за увеличение радиуса коллапса
        std::vector<double> rightBorder, horizSpan;
        rightBorder.reserve(W.getNumberOfAirfoil());
        horizSpan.reserve(W.getNumberOfAirfoil());
 
        for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
        {
 
            rightBorder.emplace_back(W.getAirfoil(q).upRight[0]);
            horizSpan.emplace_back(W.getAirfoil(q).upRight[0] - W.getAirfoil(q).lowLeft[0]);
        }
 
        if (W.getNumberOfAirfoil() > 0)
        {
            W.getNonConstWake().collapseRightBorderParameter = *std::max_element(rightBorder.begin(), rightBorder.end());
            W.getNonConstWake().collapseScaleParameter = *std::max_element(horizSpan.begin(), horizSpan.end());
        }
        else
        {
            W.getNonConstWake().collapseRightBorderParameter = 0.0;
            W.getNonConstWake().collapseScaleParameter = 1.0;
        }
#if defined(__CUDACC__) || defined(USE_CUDA)
        W.getNonConstCuda().setCollapseCoeff(W.getWake().collapseRightBorderParameter, W.getWake().collapseScaleParameter);
#endif 
        
        timePreKnn += omp_get_wtime();
 
        //std::cout << "timePreKnn = " << timePreKnn * 1000 << " ms" << std::endl;
        
 
 
 
        bool useFastCollapseAlgorithm = false;
#if defined(__CUDACC__) || defined(USE_CUDA)        
        if (W.getPassport().numericalSchemes.velocityComputation.second == 1)
            useFastCollapseAlgorithm = true;
#endif 
 
        if (!useFastCollapseAlgorithm)
        {
            //CPU/GPU - прямой алгоритм
            //double timeCollaps = -omp_get_wtime();
            Collaps(0, 1);
            //Collaps(1, 1);
            //Collaps(2, 1);
            //timeCollaps += omp_get_wtime();
            //std::cout << "timeCollaps = " << timeCollaps * 1000 << " ms" << std::endl;
        }
        else
        {
            //быстрый алгоритм
            for (int collapsStep = 0; collapsStep < 1; ++collapsStep)
            {
                //ttB = -omp_get_wtime();
 
                double timeResize = -omp_get_wtime();
                neighbNew.resize(vtx.size() * knbForRestruct);
                timeResize += omp_get_wtime();
 
                //std::cout << "timeResize = " << timeResize * 1000 << " ms" << std::endl;
 
                const double& cSP = collapseScaleParameter;
                const double& cRBP = collapseRightBorderParameter;
                const double& maxG = W.getPassport().wakeDiscretizationProperties.maxGamma;
                const double& epsCol = W.getPassport().wakeDiscretizationProperties.epscol;
 
#ifndef USE_CUDA
                //CPU
                std::vector<std::vector<std::pair<double, size_t>>> initdist(vtx.size());
                for (auto& d : initdist)
                    d.resize(2 * knbForRestruct, { -1.0, -1 });
                double timeKnn = -omp_get_wtime();
                WakekNNnewForCollaps(vtx, knbForRestruct, initdist, cSP, cRBP, maxG, epsCol, collapsStep);//CPU
                timeKnn += omp_get_wtime();
                //std::cout << "Time_Knn_CPU = " << timeKnn * 1000 << " ms" << std::endl;
#else           
                double timeAlloc = -omp_get_wtime();
                std::vector<std::pair<double, size_t>> initdistcuda(knbForRestruct * vtx.size());  //CUDA
                timeAlloc += omp_get_wtime();
                //std::cout << "timeAlloc = " << timeAlloc * 1000 << " ms" << std::endl;
 
                double timeKnn = -omp_get_wtime();
                W.getNonConstCuda().RefreshWake(5);
 
                W.timerMerging.reset();
                W.timerMerging.start();
                //Построение дерева для вихрей
                BHcu::CudaTreeInfo knnTree(W.getCuda().blocks, tree_T::contr, object_T::point4, scheme_T::noScheme, false);
                knnTree.MemoryAllocate((int)W.getCuda().n_CUDA_wake);
                knnTree.Update((int)W.getWake().vtx.size(), W.getWake().devVtxPtr);
                knnTree.Build();
 
                Point2D minr, maxr;
 
                cudaMemcpy(&minr, knnTree.minrD, sizeof(Point2D), cudaMemcpyDeviceToHost);
                cudaMemcpy(&maxr, knnTree.maxrD, sizeof(Point2D), cudaMemcpyDeviceToHost);
 
 
                kNNcuda<knbForRestruct>(minr, maxr, W.getCuda().blocks, vtx, initdistcuda, vecForKnn, cSP, cRBP, maxG, epsCol, collapsStep);                             //CUDA
                W.timerMerging.stop();
                timeKnn += omp_get_wtime();
                //std::cout << "Time_Knn_GPU = " << timeKnn * 1000 << " ms" << std::endl;
#endif          
 
                double timeCopy = -omp_get_wtime();
#pragma omp parallel for
                for (int i = 0; i < vtx.size(); ++i)
                {
#ifndef USE_CUDA
                    for (int j = 0; j < knbForRestruct; ++j)
                        neighbNew[i * knbForRestruct + j] = (int)initdist[i][j].second;
#else
                    for (int j = 0; j < knbForRestruct; ++j)
                        neighbNew[i * knbForRestruct + j] = (int)initdistcuda[i * knbForRestruct + j].second;
#endif
                }
                timeCopy += omp_get_wtime();
                //std::cout << "timeCopy = " << timeCopy * 1000 << " ms" << std::endl;
 
                //
                //std::ofstream initdistFile(W.getPassport().dir + "initdist-GPU" + std::to_string(W.currentStep));
                //for (int i = 0; i < vtx.size(); ++i)
                //{
                //  initdistFile << i;
                //  for (int k = 0; k < knb; ++k)
                //      initdistFile << " " << neighbNew[i * (knb)+k] << " " << (vtx[i].r() - vtx[neighbNew[i * (knb)+k]].r()).length();
                //  initdistFile << std::endl;
                //  
                //  //for (int k = 0; k < knb; ++k)
                //      //initdistFile << " " << neighbNew[i * (knb)+k] << " " << vtx[neighbNew[i * (knb)+k]].g() << " " << (vtx[neighbNew[i * (knb)+k]].r() - vtx[i].r()).length() << "; ";                    
                //  //initdistFile << std::endl;
                //}
                //initdistFile.close();
                //
 
 
                double timeReserve = -omp_get_wtime();
                std::vector<Vortex2D> ri, rj;
                std::vector<Point2D> rnew;
                std::vector<std::pair<int, int>> rindex;
                ri.reserve(vtx.size());
                rj.reserve(vtx.size());
                rnew.reserve(vtx.size());
 
                rindex.reserve(vtx.size());
                timeReserve += omp_get_wtime();
                //std::cout << "timeReserve = " << timeReserve * 1000 << " ms" << std::endl;
 
 
#ifdef  USE_CUDA
            //поиск пар для объединения         
                int nHlop = CollapsNewFast(0, 1, ri, rj, rnew, rindex); //тут заполняются ri, rj, rnew, rindex
 
                //формирование траекторий объединямых вихрей
                std::vector<std::pair<Point2D, Point2D>> segments(2 * ri.size());
                for (size_t i = 0; i < ri.size(); ++i)
                {
                    segments[2 * i + 0].first = ri[i];
                    segments[2 * i + 0].second = rnew[i];
 
                    segments[2 * i + 1].first = rj[i];
                    segments[2 * i + 1].second = rnew[i];
                }
 
                //контроль протыкания
                std::vector<int> hit(segments.size());
                if (ri.size() > 0)
                {
                    double* devSegments_ptr;
 
                    cudaMalloc(&devSegments_ptr, segments.size() * sizeof(double) * 4);
                    cudaMemcpy(devSegments_ptr, segments.data(), segments.size() * sizeof(double) * 4, cudaMemcpyHostToDevice);
 
                    W.timerInside.start();
                    auto& cntrTreeSeg = *W.getCuda().cntrTreeSegment;
                    cntrTreeSeg.MemoryAllocate((int)W.getCuda().n_CUDA_wake);
                    cntrTreeSeg.UpdatePanelGeometry((int)segments.size(), (double4*)devSegments_ptr);
                    cntrTreeSeg.Build();
 
                    BHcu::treePanelsSegmentsIntersectionCalculationWrapper(*W.getNonConstCuda().auxTreePnl, cntrTreeSeg,
                        W.getWake().devNearestPanelPtr);
 
                    W.timerInside.stop();
 
                    cudaMemcpy(hit.data(), W.getWake().devNearestPanelPtr, segments.size() * sizeof(int), cudaMemcpyDeviceToHost);
                    cudaFree(devSegments_ptr);
                }//if ri.size() > 0
 
                for (size_t i = 0; i < ri.size(); ++i)
                {
                    if (hit[2 * i + 0] == -1 && hit[2 * i + 1] == -1)
                    {
                        vtx[rindex[i].first].r() = rnew[i];
                        vtx[rindex[i].first].g() += vtx[rindex[i].second].g();
                        vtx[rindex[i].first].sigma() = std::max(vtx[rindex[i].first].sigma(), vtx[rindex[i].second].sigma());
 
                        vtx[rindex[i].second].g() = 0.0;
                    }
                }
 
#else
                double timeCollaps;
                //CollapsNew(0, 1);
                timeCollaps = -omp_get_wtime();
                int nHlop = CollapsNewFast(0, 1, ri, rj, rnew, rindex);
 
                timeCollaps += omp_get_wtime();
 
                size_t hitA, hitB;
                bool ifInside;
#pragma omp parallel for private (hitA, hitB, ifInside)
                for (int i = 0; i < (int)ri.size(); ++i)
                {
                    ifInside = false;
                    for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                    {
                        MoveInside(rnew[i], ri[i], W.getAirfoil(q), hitA);
                        MoveInside(rnew[i], rj[i], W.getAirfoil(q), hitB);
                        if ((hitA != size_t(-1)) || (hitB != size_t(-1)))
                            ifInside = true;
                    }
                    if (!ifInside)
                    {
                        vtx[rindex[i].first].r() = rnew[i];
                        vtx[rindex[i].first].g() += vtx[rindex[i].second].g();
                        vtx[rindex[i].first].sigma() = std::max(vtx[rindex[i].first].sigma(), vtx[rindex[i].second].sigma());
 
                        vtx[rindex[i].second].g() = 0.0;
 
                    }
                }
#endif
            }
        }
    
    }
    double timeRemove = -omp_get_wtime();
    RemoveFar();
    RemoveZero();
    timeRemove += omp_get_wtime();
    //std::cout << "timeRemove = " << timeRemove * 1000 << std::endl;
 
    W.getTimers().stop("Restr");
//*
//  std::cout << "Pre-knn time = " << timePreKnn * 1000.0 << " ms" << std::endl;
//  std::cout << "Pre-knn resize time = " << timeResize * 1000.0 << " ms" << std::endl;
//  std::cout << "Time_Knn_GPU = " << timeKnn * 1000 << " ms" << std::endl;
//  std::cout << "Post-knn copy time = " << timeCopy * 1000.0 << " ms" << std::endl;
//  std::cout << "Reserve_time = " << timeReserve * 1000 << " ms" << std::endl;
//  std::cout << "Collaps_time = " << timeCollaps * 1000 << " ms" << std::endl;
//  std::cout << "Copy2_time = " << timeCopy2 * 1000 << " ms" << std::endl;
//  std::cout << "Ray_time = " << timeRay * 1000 << " ms" << std::endl;
//  std::cout << "Collaps2_time = " << timeCollaps2 * 1000 << " ms" << std::endl;
//  std::cout << "Remove_time = " << timeRemove * 1000 << " ms" << std::endl;
    
 
//*/
}

Here is the call graph for this function:

◆ SaveKadrVtk()

void WakeDataBase::SaveKadrVtk ( const std::string & filePrefix = "Kadr" ) const

inherited

Сохранение вихревого следа в файл .vtk.

Definition at line 115 of file WakeDataBase2D.cpp.

{
    W.getTimers().start("Save");
    
    if (W.ifDivisible(W.getPassport().timeDiscretizationProperties.saveVtxStep))
    {       
        std::ofstream outfile;
        size_t numberNonZero = 0;
 
        if (vtx.size() > 0)
            numberNonZero += vtx.size();
        else
            for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                numberNonZero += W.getAirfoil(q).getNumberOfPanels();
        VMlib::CreateUserDirectory(W.getPassport().dir, "snapshots");
 
        if (W.getPassport().timeDiscretizationProperties.fileTypeVtx.second == 0) //text format vtk
        {
            std::string fname = VMlib::fileNameStep(filePrefix, W.getPassport().timeDiscretizationProperties.nameLength, W.getCurrentStep(), "vtk");
            outfile.open(W.getPassport().dir + "snapshots/" + fname);
 
            outfile << "# vtk DataFile Version 2.0\n";
            outfile << "VM2D VTK result: " << (W.getPassport().dir + "snapshots/" + fname).c_str() << " saved " << VMlib::CurrentDataTime() << '\n';
            outfile << "ASCII\n";
            outfile << "DATASET UNSTRUCTURED_GRID\n";
            outfile << "POINTS " << numberNonZero << " float\n";
 
            
            if (vtx.size() > 0)
                for (auto& v : vtx)
                {
                    const Point2D& r = v.r();
                    outfile << r[0] << " " << r[1] << " " << "0.0\n";
                }//for v        
            else            
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                    for (size_t s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                    {
                        const Point2D& r = W.getAirfoil(q).getR(s);
                        outfile << r[0] << " " << r[1] << " " << "0.0\n";
                    }
 
            outfile << "CELLS " << numberNonZero << " " << 2 * numberNonZero << '\n';
            for (size_t i = 0; i < numberNonZero; ++i)
                outfile << "1 " << i << '\n';
 
            outfile << "CELL_TYPES " << numberNonZero << '\n';
            for (size_t i = 0; i < numberNonZero; ++i)
                outfile << "1\n";
 
            outfile << '\n';
            outfile << "POINT_DATA " << numberNonZero << '\n';
            outfile << "SCALARS Gamma float 1\n";
            outfile << "LOOKUP_TABLE default\n";
 
            if (vtx.size() > 0)
                for (auto& v : vtx)
                    outfile << v.g() << '\n';
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                    for (size_t s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)                                            
                        outfile << "0.0\n";                 
                        
            outfile << "SCALARS Sigma float 1\n";
            outfile << "LOOKUP_TABLE default\n";
 
            if (vtx.size() > 0)
                for (auto& v : vtx)
                    outfile << v.sigma() << '\n';
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                    for (size_t s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                        outfile << "0.0\n";
 
#ifdef TURB
            outfile << "SCALARS nut float 1\n";
            outfile << "LOOKUP_TABLE default\n";
 
            if (vtx.size() > 0)
                for (auto& v : vtx)
                    outfile << sqr(v.sigma() / 4.48) / W.getPassport().timeDiscretizationProperties.dt - W.getPassport().physicalProperties.nu << '\n';
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                    for (size_t s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                        outfile << "0.0\n";
#endif
 
 
            outfile.close();
        }//if fileType = text
        else if (W.getPassport().timeDiscretizationProperties.fileTypeVtx.second == 1) //binary format vtk
        {
            //Тест способа хранения чисел
            uint16_t x = 0x0001;
            bool littleEndian = (*((uint8_t*)&x));
            const char eolnBIN[] = "\n";
 
            std::string fname = VMlib::fileNameStep(filePrefix, W.getPassport().timeDiscretizationProperties.nameLength, W.getCurrentStep(), "vtk");
            outfile.open(W.getPassport().dir + "snapshots/" + fname, std::ios::out | std::ios::binary);
 
            outfile << "# vtk DataFile Version 3.0" << "\r\n" << "VM2D VTK result: " << (W.getPassport().dir + "snapshots/" + fname).c_str() << " saved " << VMlib::CurrentDataTime() << eolnBIN;
            outfile << "BINARY" << eolnBIN;
            outfile << "DATASET UNSTRUCTURED_GRID" << eolnBIN << "POINTS " << numberNonZero << " " << "float" << eolnBIN;
 
            if (vtx.size() > 0)
            {
                Eigen::VectorXf rData = Eigen::VectorXf::Zero(vtx.size() * 3);
                for (size_t i = 0; i < vtx.size(); ++i)
                {
                    rData(3 * i) = (float)(vtx[i].r())[0];
                    rData(3 * i + 1) = (float)(vtx[i].r())[1];
                }//for i
 
                if (littleEndian)
                    for (int i = 0; i < vtx.size() * 3; ++i)
                        VMlib::SwapEnd(rData(i));
                outfile.write(reinterpret_cast<char*>(rData.data()), vtx.size() * 3 * sizeof(float));                   
            }
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                {
                    Eigen::VectorXf rData = Eigen::VectorXf::Zero(W.getAirfoil(q).getNumberOfPanels() * 3);
                    for (size_t s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                    {
                        rData(3 * s) = (float)(W.getAirfoil(q).getR(s))[0];
                        rData(3 * s + 1) = (float)(W.getAirfoil(q).getR(s))[1];
                    }//for i
 
                    if (littleEndian)
                        for (int i = 0; i < W.getAirfoil(q).getNumberOfPanels() * 3; ++i)
                            VMlib::SwapEnd(rData(i));
                    outfile.write(reinterpret_cast<char*>(rData.data()), W.getAirfoil(q).getNumberOfPanels() * 3 * sizeof(float));
                }
 
            // CELLS
            std::vector<int> cells(2 * numberNonZero);
            for (size_t i = 0; i < numberNonZero; ++i)
            {
                cells[2 * i] = 1;
                cells[2 * i + 1] = (int)i;
            }
 
            std::vector<int> cellsTypes;
            cellsTypes.resize(numberNonZero, 1);
 
            if (littleEndian)
            {
                for (int i = 0; i < numberNonZero * 2; ++i)
                    VMlib::SwapEnd(cells[i]);
 
                for (int i = 0; i < numberNonZero; ++i)
                    VMlib::SwapEnd(cellsTypes[i]);
            }
 
            outfile << eolnBIN << "CELLS " << numberNonZero << " " << numberNonZero * 2 << eolnBIN;
            outfile.write(reinterpret_cast<char*>(cells.data()), numberNonZero * 2 * sizeof(int));
            outfile << eolnBIN << "CELL_TYPES " << numberNonZero << eolnBIN;
            outfile.write(reinterpret_cast<char*>(cellsTypes.data()), numberNonZero * sizeof(int));
 
            //gammas
            outfile << eolnBIN << "POINT_DATA " << numberNonZero << eolnBIN;
            outfile << eolnBIN << "SCALARS Gamma " << "float" << " 1" << eolnBIN;
            outfile << "LOOKUP_TABLE default" << eolnBIN;           
 
            if (vtx.size() > 0)
            {
                Eigen::VectorXf pData = Eigen::VectorXf::Zero(numberNonZero);
                for (int s = 0; s < vtx.size(); ++s)
                    pData(s) = (float)vtx[s].g();
                
                if (littleEndian)
                    for (int i = 0; i < vtx.size(); ++i)
                        VMlib::SwapEnd(pData(i));
                outfile.write(reinterpret_cast<char*>(pData.data()), vtx.size() * sizeof(float));
            }
            else            
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                {
                    Eigen::VectorXf pData = Eigen::VectorXf::Zero(W.getAirfoil(q).getNumberOfPanels());
                    for (int s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                        pData(s) = 0;
 
                    if (littleEndian)
                        for (int i = 0; i < W.getAirfoil(q).getNumberOfPanels(); ++i)
                            VMlib::SwapEnd(pData(i));
                    outfile.write(reinterpret_cast<char*>(pData.data()), W.getAirfoil(q).getNumberOfPanels() * sizeof(float));                  
                }
            
            outfile << eolnBIN;
 
 
            //sigmas
            outfile << eolnBIN << "SCALARS Sigma " << "float" << " 1" << eolnBIN;
            outfile << "LOOKUP_TABLE default" << eolnBIN;
 
            if (vtx.size() > 0)
            {
                Eigen::VectorXf pData = Eigen::VectorXf::Zero(numberNonZero);
                for (int s = 0; s < vtx.size(); ++s)
                    pData(s) = (float)vtx[s].sigma();
 
                if (littleEndian)
                    for (int i = 0; i < vtx.size(); ++i)
                        VMlib::SwapEnd(pData(i));
                outfile.write(reinterpret_cast<char*>(pData.data()), vtx.size() * sizeof(float));
            }
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                {
                    Eigen::VectorXf pData = Eigen::VectorXf::Zero(W.getAirfoil(q).getNumberOfPanels());
                    for (int s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                        pData(s) = 0;
 
                    if (littleEndian)
                        for (int i = 0; i < W.getAirfoil(q).getNumberOfPanels(); ++i)
                            VMlib::SwapEnd(pData(i));
                    outfile.write(reinterpret_cast<char*>(pData.data()), W.getAirfoil(q).getNumberOfPanels() * sizeof(float));
                }
 
            outfile << eolnBIN;
 
#ifdef TURB
            //nut
            outfile << eolnBIN << "SCALARS nut " << "float" << " 1" << eolnBIN;
            outfile << "LOOKUP_TABLE default" << eolnBIN;
 
            if (vtx.size() > 0)
            {
                Eigen::VectorXf pData = Eigen::VectorXf::Zero(numberNonZero);
                for (int s = 0; s < vtx.size(); ++s)
                    pData(s) = (float)(sqr(vtx[s].sigma() / 4.48) / W.getPassport().timeDiscretizationProperties.dt - W.getPassport().physicalProperties.nu);;
 
                if (littleEndian)
                    for (int i = 0; i < vtx.size(); ++i)
                        VMlib::SwapEnd(pData(i));
                outfile.write(reinterpret_cast<char*>(pData.data()), vtx.size() * sizeof(float));
            }
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                {
                    Eigen::VectorXf pData = Eigen::VectorXf::Zero(W.getAirfoil(q).getNumberOfPanels());
                    for (int s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                        pData(s) = 0;
 
                    if (littleEndian)
                        for (int i = 0; i < W.getAirfoil(q).getNumberOfPanels(); ++i)
                            VMlib::SwapEnd(pData(i));
                    outfile.write(reinterpret_cast<char*>(pData.data()), W.getAirfoil(q).getNumberOfPanels() * sizeof(float));
                }
 
            outfile << eolnBIN;
#endif
 
 
            outfile.close();
        }//if binary
 
        if (W.getPassport().timeDiscretizationProperties.fileTypeVtx.second == 2) //csv
        {
            std::string fname = VMlib::fileNameStep(filePrefix, W.getPassport().timeDiscretizationProperties.nameLength, W.getCurrentStep(), "csv");
            outfile.open(W.getPassport().dir + "snapshots/" + fname);
 
            outfile << "point,x,y,G,S";
#ifdef TURB
            outfile << ",nut";
#endif
            outfile << '\n';
 
            int counter = 0;
 
            if (vtx.size() > 0)
                for (auto& v : vtx)
                {
                    outfile << counter++ << "," << v.r()[0] << "," << v.r()[1] << "," << v.g() << "," << v.sigma();
#ifdef TURB
                    outfile << "," << sqr(v.sigma() / 4.48) / W.getPassport().timeDiscretizationProperties.dt - W.getPassport().physicalProperties.nu;
#endif
                    outfile << '\n';
                }
            else
                for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
                    for (size_t s = 0; s < W.getAirfoil(q).getNumberOfPanels(); ++s)
                    {
                        const Point2D& r = W.getAirfoil(q).getR(s);
                        outfile << counter++ << "," << r[0] << "," << r[1] << "," << "0.0" << "," << "0.0";
#ifdef TURB
                        outfile << "," << 0.0;
#endif  
                        outfile << '\n';
                    }
            outfile.close();
        }//if fileType = text
 
    }
 
    W.getTimers().stop("Save");
}//SaveKadrVtk()

Here is the call graph for this function:

Member Data Documentation

◆ collapseRightBorderParameter

double VM2D::Wake::collapseRightBorderParameter

абсцисса, правее которой происходит линейный (вправо) рост радиуса коллапса

Definition at line 161 of file Wake2D.h.

◆ collapseScaleParameter

double VM2D::Wake::collapseScaleParameter

характерный масштаб, на котором происходит рост радиуса коллапса

Definition at line 164 of file Wake2D.h.

◆ neighb

std::vector<int> VM2D::Wake::neighb

private

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

Definition at line 66 of file Wake2D.h.

◆ neighbNew

std::vector<int> VM2D::Wake::neighbNew

private

Definition at line 69 of file Wake2D.h.

◆ vtx

std::vector<Vortex2D> VM2D::WakeDataBase::vtx

inherited

Список вихревых элементов

Definition at line 81 of file WakeDataBase2D.h.

◆ W

const World2D& VM2D::WakeDataBase::W

inherited

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

Definition at line 71 of file WakeDataBase2D.h.

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

VM2D/Wake2D/Wake2D.h
VM2D/Wake2D/Wake2D.cpp

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Wake()

◆ ~Wake()

Member Function Documentation

◆ Collaps()

◆ CollapsNew()

◆ CollapsNewFast()

◆ GetPairs()

◆ GetPairsBH()

◆ GetPairsBS()

◆ GetPairsClosestNeib()

◆ Inside()

◆ MoveInside()

◆ MoveInsideMovingBoundary()

◆ ReadFromFile()

◆ RemoveFar()

◆ RemoveZero()

◆ Restruct()

◆ SaveKadrVtk()

Member Data Documentation

◆ collapseRightBorderParameter

◆ collapseScaleParameter

◆ neighb

◆ neighbNew

◆ vtx

◆ W