VM2D::VirtualWake Class Reference

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

#include <VirtualWake2D.h>

Inheritance diagram for VM2D::VirtualWake:

Collaboration diagram for VM2D::VirtualWake:

Public Member Functions
	VirtualWake (const World2D &W_, const Boundary &bnd_)
	Конструктор инициализации
	~VirtualWake ()
	Деструктор
void	ReadFromFile (const std::string &dir, const std::string &fileName)
	Считывание вихревого следа из файла
void	SaveKadrVtk (const std::string &filePrefix="Kadr") const
	Сохранение вихревого следа в файл .vtk.

Public Attributes
const Boundary &	bnd
	Константная ссылка на границу, которой принадлежит данный виртуальный след
std::vector< Point2D >	vecHalfGamma
	Скорость вихрей виртуального следа конкретного профиля (равна Gamma/2) используется для расчета давления
std::vector< std::pair< size_t, size_t > >	aflPan
	Пара чисел: номер профиля и номер панели, на которой рожден виртуальный вихрь
const World2D &	W
	Константная ссылка на решаемую задачу
std::vector< Vortex2D >	vtx
	Список вихревых элементов

Detailed Description

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

Author

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

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

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

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

\Version 1.14

Date

6 марта 2026 г.

Definition at line 62 of file VirtualWake2D.h.

Constructor & Destructor Documentation

VirtualWake()

VM2D::VirtualWake::VirtualWake ( const World2D &  W_, const Boundary &  bnd_  )

inline

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

Parameters

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

Definition at line 81 of file VirtualWake2D.h.

            : WakeDataBase(W_), bnd(bnd_) { };

~VirtualWake()

VM2D::VirtualWake::~VirtualWake ( )

inline

Деструктор

Definition at line 85 of file VirtualWake2D.h.

{ };

Member Function Documentation

ReadFromFile()

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

inherited

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

Parameters

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

Definition at line 55 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);
        }
    }
    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();
                vtx.push_back(v);
            }
 
            wakeFile.close();
        }
    }
 
}//ReadFromFile(...)

Here is the call graph for this function:

SaveKadrVtk()

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

inherited

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

Definition at line 109 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::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)                                            
                        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.getTimers().stop("Save");
}

Here is the call graph for this function:

Member Data Documentation

aflPan

std::vector<std::pair<size_t, size_t> > VM2D::VirtualWake::aflPan

Пара чисел: номер профиля и номер панели, на которой рожден виртуальный вихрь

Definition at line 75 of file VirtualWake2D.h.

bnd

const Boundary& VM2D::VirtualWake::bnd

Константная ссылка на границу, которой принадлежит данный виртуальный след

Definition at line 69 of file VirtualWake2D.h.

vecHalfGamma

std::vector<Point2D> VM2D::VirtualWake::vecHalfGamma

Скорость вихрей виртуального следа конкретного профиля (равна Gamma/2) используется для расчета давления

Definition at line 72 of file VirtualWake2D.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 file:

• VM2D/VirtualWake2D/VirtualWake2D.h