VM2D::Wake Class Reference

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

#include <Wake2D.h>

Inheritance diagram for VM2D::Wake:

Collaboration diagram for VM2D::Wake:

Public Member Functions
	Wake (const World2D &W_)
	Конструктор инициализации More...
	~Wake ()
	Деструктор More...
void	Inside (const std::vector< Point2D > &newPos, Airfoil &afl, bool isMoves, const Airfoil &oldAfl)
	Проверка пересечения вихрями следа профиля при перемещении More...
void	Restruct ()
	Реструктуризация вихревого следа More...
int	RemoveFar ()
	Зануление далеко улетевших вихрей More...
size_t	RemoveZero ()
	Исключение нулевых и мелких вихрей More...
bool	MoveInside (const Point2D &newPos, const Point2D &oldPos, const Airfoil &afl, size_t &panThrough)
	Проверка проникновения точки через границу профиля More...
bool	MoveInsideMovingBoundary (const Point2D &newPos, const Point2D &oldPos, const Airfoil &oldAfl, const Airfoil &afl, size_t &panThrough)
	Проверка проникновения точки через границу профиля More...
void	GetPairs (int type)
	Поиск ближайшего соседа More...
void	GetPairsBS (int type)
void	GetPairsBH (int type)
int	Collaps (int type, int times)
	Коллапс вихрей More...
int	CollapsNew (int type, int times)
void	ReadFromFile (const std::string &dir, const std::string &fileName)
	Считывание вихревого следа из файла More...
void	SaveKadrVtk (const std::string &filePrefix="Kadr") const
	Сохранение вихревого следа в файл .vtk. More...

Public Attributes
double	collapseRightBorderParameter
	абсцисса, правее которой происходит линейный (вправо) рост радиуса коллапса More...
double	collapseScaleParameter
	характерный масштаб, на котором происходит рост радиуса коллапса More...
const World2D &	W
	Константная ссылка на решаемую задачу More...
std::vector< Vortex2D >	vtx
	Список вихревых элементов More...

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

Static Private Attributes
static const int	knb = 2

Detailed Description

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

Author

Марчевский Илья Константинович

Сокол Ксения Сергеевна

Рятина Евгения Павловна

Колганова Александра Олеговна 1.12

Date

14 января 2024 г.

Definition at line 59 of file Wake2D.h.

Constructor & Destructor Documentation

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

inline

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

Parameters

[in]

W_

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

Definition at line 73 of file Wake2D.h.

            : WakeDataBase(W_) 
        {
        };

VM2D::Wake::~Wake ( )

inline

Деструктор

Definition at line 79 of file Wake2D.h.

{ };

Here is the call graph for this function:

Member Function Documentation

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

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

Parameters

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

Returns

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

Definition at line 412 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))   
        
        if (W.getPassport().numericalSchemes.velocityComputation.second == 0)
        {
            const_cast<Gpu&>(W.getCuda()).RefreshWake(3);
            GPUGetPairs(type);
        }
        else
            GetPairs(type);
#else
        GetPairs(type);
#endif      

        //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])
            {
                //std::cout << "A" << std::endl;

                int ssd = neighb[vt];
                
                //std::cout << "B" << std::endl;

                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]))
                {
                    //std::cout << "C0" << std::endl;

                    Vortex2D& vtxK = vtx[ssd];

                    //std::cout << "C" << std::endl;

                    flag[ssd] = true;

                    Vortex2D sumVtx;
                    sumVtx.g() = vtxI.g() + vtxK.g();

                    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;

                    //std::cout << "D" << std::endl;

                    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

                    //std::cout << "E" << std::endl;

                    if (fl_hit)
                    {
                        vtxI = sumVtx;
                        vtxK.g() = 0.0;
                        nHlop++;
                    }//if (fl_hit)

                    //std::cout << "F" << std::endl;

                }//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:

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

Definition at line 521 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, r2, r2test;
        Point2D newPos;

        for (size_t vt = 0; vt + 1 < vtx.size(); ++vt)
        {
            Vortex2D& vtxI = vtx[vt];
            if (!flag[vt])
            {
                for (int s = 0; s < knb - 1; ++s)
                {
                    int ssd = neighbNew[vt * (knb - 1) + s];
                    Vortex2D& vtxK = vtx[ssd];

                    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 раза для коллапса вихрей разных знаков         

                    bool keyGamma = false;
                    switch (type)
                    {
                    case 0:
                        keyGamma = (fabs(vtxI.g() * vtxK.g()) != 0.0) && (fabs(vtxI.g() + vtxK.g()) < sqr(mnog) * maxG);
                        break;
                    case 1:
                        keyGamma = (vtxI.g() * vtxK.g() < 0.0);
                        break;
                    case 2:
                        keyGamma = (vtxI.g() * vtxK.g() > 0.0) && (fabs(vtxI.g() + vtxK.g()) < sqr(mnog) * maxG);
                        break;
                    }

                    if ((r2 < r2test) && (keyGamma))
                    {
                        if ((ssd != 0) && (!flag[ssd]))
                        {
                            flag[ssd] = true;

                            Vortex2D sumVtx;
                            sumVtx.g() = vtxI.g() + vtxK.g();

                            switch (type)
                            {
                            case 0:
                            case 2:
                                sumAbsGam = fabs(vtxI.g()) + fabs(vtxK.g());

                                if (sumAbsGam > 1e-10)
                                    sumVtx.r() = (vtxI.r() * fabs(vtxI.g()) + vtxK.r() * fabs(vtxK.g())) * (1.0 / sumAbsGam);
                                else
                                    sumVtx.r() = 0.5 * (vtxI.r() + vtxK.r());                                                   

                                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))
                                    fl_hit = false;
                            }//for

                            if (fl_hit)
                            {
                                vtxI = sumVtx;
                                vtxK.g() = 0.0;
                                nHlop++;
                                flag[vt] = true;
                            }//if (fl_hit)

                        }//if ((ssd!=0)&&(!flag[ssd]))
                    }

                    if (flag[vt])
                        break;
                }// for s
            }//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:

void Wake::GetPairs

(

int

type

)

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

Parameters

[in]

type

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

Definition at line 317 of file Wake2D.cpp.

{
    GetPairsBS(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void VM2D::Wake::GetPairsBH

(

int

type

)

Here is the caller graph for this function:

void Wake::GetPairsBS

(

int

type

)

Todo:

Доделать

Definition at line 323 of file Wake2D.cpp.

{
    neighb.resize(0);
    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)
    {
        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 (mnog > 1.0)    
            //  r2test = sqr(0.005*cSP);            

            if (r2 < r2test)
            {
                switch (type)
                {
                    case 0:
                        found = ( fabs(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:

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

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

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

Parameters

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

Definition at line 279 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();

    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:

Here is the caller graph for this function:

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

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

Parameters

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

Definition at line 66 of file Wake2D.cpp.

{
    //const double porog_r = 1e-12;
    
    //double minDist = 1.0E+10; //расстояние до пробиваемой панели
    panThrough = -1;

    //проверка габ. прямоугольника
    if (afl.isOutsideGabarits(newPos) && afl.isOutsideGabarits(oldPos))
        return false;

    //если внутри габ. прямоугольника - проводим контроль
    bool hit = false;

    //std::pair<double, double> gabPointX = std::minmax(newPos[0], oldPos[0]);
    //std::pair<double, double> gabPointY = std::minmax(newPos[1], oldPos[1]);

    //std::pair<double, double> gabPanelX, gabPanelY;

    //Проверка на пересечение
    //double r0 = 0, r1 = 0, r2 = 0, r3 = 0;

    //int cnt = 0;
    for (size_t j = 0; j < afl.getNumberOfPanels(); ++j)
    {
        const Point2D& aflRj = afl.getR(j);
        const Point2D& aflRj1 = afl.getR(j + 1);

//      gabPanelX = std::minmax(aflRj[0], aflRj1[0]);
//      gabPanelY = std::minmax(aflRj[1], aflRj1[1]);

//      if ((gabPointX.second >= gabPanelX.first) && (gabPanelX.second >= gabPointX.first) && (gabPointY.second >= gabPanelY.first) && (gabPanelY.second >= gabPointY.first))
//      {
            if ((((aflRj - oldPos) ^ (newPos - oldPos)) * ((aflRj1 - oldPos) ^ (newPos - oldPos)) <= 0) && \
                (((oldPos - aflRj) ^ (aflRj1 - aflRj)) * ((newPos - aflRj) ^ (aflRj1 - aflRj)) <= 0))
            {
                hit = true;
                panThrough = j;
                break;
            }
//      }
//      else { ++cnt; }
    }//for j

//  std::cout << cnt << std::endl;

    return hit;
}//MoveInside(...)

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Parameters

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

Todo:

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

Definition at line 185 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:

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;
    
    if (fileExistTest(filename, W.getInfo(), { "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);
    }
}//ReadFromFile(...)

Here is the call graph for this function:

Here is the caller graph for this function:

int Wake::RemoveFar

(

)

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

Returns

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

Todo:

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

Definition at line 635 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:

Here is the caller graph for this function:

size_t Wake::RemoveZero

(

)

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

Returns

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

Definition at line 655 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()

Here is the caller graph for this function:

void Wake::Restruct

(

)

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

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

Definition at line 685 of file Wake2D.cpp.

{
    W.getTimestat().timeRestruct.first += 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 
    

    


    //CPU/GPU - прямой алгоритм
    //Collaps(1, 1); 
    //Collaps(2, 1); 
    

    //*
    //быстрый алгоритм
    for (int collapsStep = 1; collapsStep <= 2; ++collapsStep)
    {
#if defined(USE_CUDA)
#define knnGPU
#endif

        neighbNew.resize(vtx.size() * (knb - 1));
    
        if (vtx.size() > 2 * knb)
        {
#ifndef knnGPU      
            //CPU
            std::vector<std::vector<std::pair<double, size_t>>> initdist(vtx.size());
            for (auto& d : initdist)
                d.resize(2 * knb, { -1.0, -1 });

            WakekNN(vtx, knb, initdist);//CPU
#else       
            std::vector<std::pair<double, size_t>> initdistcuda(knb * vtx.size(), { -1.0, -1 });  //CUDA
            kNNcuda(vtx, knb, initdistcuda, vecForKnn);                                           //CUDA
#endif      

            for (int i = 0; i < vtx.size(); ++i)
            {
#ifndef knnGPU  
                neighbNew[i] = (int)initdist[i][1].second;
#else
                for (int j = 0; j < knb - 1; ++j)
                    neighbNew[i * (knb - 1) + j] = (int)initdistcuda[(i * knb) + (j + 1)].second;
#endif
            }
        }
        
        CollapsNew(collapsStep, 1);

    }

//*/
    
    RemoveFar();
    RemoveZero();

    W.getTimestat().timeRestruct.second += omp_get_wtime();
}//Restruct()

Here is the call graph for this function:

Here is the caller graph for this function:

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

inherited

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

Definition at line 73 of file WakeDataBase2D.cpp.

{
    W.getTimestat().timeSaveKadr.first += omp_get_wtime();

    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::CreateDirectory(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" << std::endl;
            outfile << "VM2D VTK result: " << (W.getPassport().dir + "snapshots/" + fname).c_str() << " saved " << VMlib::CurrentDataTime() << std::endl;
            outfile << "ASCII" << std::endl;
            outfile << "DATASET UNSTRUCTURED_GRID" << std::endl;
            outfile << "POINTS " << numberNonZero << " float" << std::endl;

            if (vtx.size() > 0)
                for (auto& v : vtx)
                {
                    const Point2D& r = v.r();
                    outfile << r[0] << " " << r[1] << " " << "0.0" << std::endl;
                }//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" << std::endl;
                    }

            outfile << "CELLS " << numberNonZero << " " << 2 * numberNonZero << std::endl;
            for (size_t i = 0; i < numberNonZero; ++i)
                outfile << "1 " << i << std::endl;

            outfile << "CELL_TYPES " << numberNonZero << std::endl;
            for (size_t i = 0; i < numberNonZero; ++i)
                outfile << "1" << std::endl;

            outfile << std::endl;
            outfile << "POINT_DATA " << numberNonZero << std::endl;
            outfile << "SCALARS Gamma float 1" << std::endl;
            outfile << "LOOKUP_TABLE default" << std::endl;

            if (vtx.size() > 0)
                for (auto& v : vtx)
                    outfile << v.g() << std::endl;
            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 << "0.0" << std::endl;
                    }

            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;
            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 " << std::endl;

            int counter = 0;
            if (vtx.size() > 0)
                for (auto& v : vtx)                                 
                    outfile << counter++ << "," << v.r()[0] << "," << v.r()[1] << "," << v.g() << std::endl;                
            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" << std::endl;
                    }
            outfile.close();
        }//if fileType = text

    }

    W.getTimestat().timeSaveKadr.second += omp_get_wtime();
}

Member Data Documentation

double VM2D::Wake::collapseRightBorderParameter

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

Definition at line 152 of file Wake2D.h.

double VM2D::Wake::collapseScaleParameter

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

Definition at line 155 of file Wake2D.h.

const int VM2D::Wake::knb = 2

staticprivate

Definition at line 65 of file Wake2D.h.

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

private

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

Definition at line 63 of file Wake2D.h.

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

private

Definition at line 66 of file Wake2D.h.

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

inherited

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

Definition at line 76 of file WakeDataBase2D.h.

const World2D& VM2D::WakeDataBase::W

inherited

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

Definition at line 69 of file WakeDataBase2D.h.

---

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

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