#include <Passport2D.h>

Inheritance diagram for VM2D::Passport:

Collaboration diagram for VM2D::Passport:

[legend]

Public Member Functions
	Passport (VMlib::LogStream &infoStream, const std::string &_problemName, const size_t _problemNumber, const std::string &_filePassport, const std::string &_mechanics, const std::string &_defaults, const std::string &_switchers, const std::vector< std::string > &vars)
	Конструктор

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

Public Attributes
std::string	airfoilsDir
	Каталог с файлами профилей

std::string	wakesDir
	Каталог с файлами вихревых следов

std::vector< AirfoilParams >	airfoilParams
	Список структур с параметрами профилей

bool	rotateForces
	Признак работы в "географической" системе координат

bool	calcCoefficients
	Признак вычисления коэффициентов вместо сил

double	rotateAngleVpPoints
	Угол поворота точек VP.

PhysicalProperties	physicalProperties
	Структура с физическими свойствами задачи

WakeDiscretizationProperties	wakeDiscretizationProperties
	Структура с параметрами дискретизации вихревого следа

NumericalSchemes	numericalSchemes
	Структура с используемыми численными схемами

std::string	dir
	Рабочий каталог задачи

std::string	problemName
	Название задачи

size_t	problemNumber
	Номер задачи

TimeDiscretizationProperties	timeDiscretizationProperties
	Структура с параметрами процесса интегрирования по времени

Protected Attributes
LogStream	info
	Поток для вывода логов и сообщений об ошибках

Private Member Functions
virtual void	GetAllParamsFromParser (std::istream &mainStream, std::istream &mechanicsStream, std::istream &defaultStream, std::istream &switcherStream, std::istream &varsStream) override
	Считывание всех параметров расчета из соответствующих потоков

virtual void	PrintAllParams () override
	Печать всех параметров расчета в поток логов

Detailed Description

\brief Класс, опеделяющий паспорт двумерной задачи

\author Марчевский Илья Константинович
\author Сокол Ксения Сергеевна
\author Рятина Евгения Павловна

Author: Колганова Александра Олеговна \Version 1.14

Date: 6 марта 2026 г.

Definition at line 251 of file Passport2D.h.

Constructor & Destructor Documentation

◆ Passport()

Passport::Passport	(	VMlib::LogStream &	infoStream,
		const std::string &	_problemName,
		const size_t	_problemNumber,
		const std::string &	_filePassport,
		const std::string &	_mechanics,
		const std::string &	_defaults,
		const std::string &	_switchers,
		const std::vector< std::string > &	vars
	)

Конструктор

Осуществляет чтение всех данных из соответствующих потоков, полностью инициализирует паспорт

Parameters

[in,out]	infoStream	базовый поток для вывода логов
[in]	_problemName	константная ссылка наназвание задачи
[in]	_problemNumber	номер (по счету) решаемой задачи
[in]	_filePassport	константная ссылка на файл (без пути) с паспортом задачи
[in]	_mechanics	константная ссылка на файл (c путем) со словарем механических систем
[in]	_defaults	константная ссылка на имя файла (с путем) с параметрами по умолчанию
[in]	_switchers	константная ссылка на имя файла (с путем) со значениями параметров-переключателей
[in]	vars	константная ссылка на список переменных, заданных в виде строк

Definition at line 69 of file Passport2D.cpp.

: PassportGen(infoStream, _problemName, _problemNumber, _filePassport, _mechanics, _defaults, _switchers, vars),
physicalProperties(timeDiscretizationProperties)
{
    std::string fileFullName = dir + _filePassport;
    std::string mechanicsFileFullName = _mechanics;
    std::string defaultsFileFullName = _defaults;
    std::string switchersFileFullName = _switchers;
 
    if (
        fileExistTest(fileFullName, info, true, { "txt", "TXT"}) &&
        fileExistTest(defaultsFileFullName, info, true, { "txt", "TXT" }) &&
        fileExistTest(switchersFileFullName, info, true, { "txt", "TXT" }) &&
        fileExistTest(mechanicsFileFullName, info, true, { "txt", "TXT" })
       )
    {
        std::string str = VMlib::StreamParser::VectorStringToString(vars);
        std::stringstream varsStream(str);
 
        std::stringstream mainStream;
        mainStream << VMlib::Preprocessor(fileFullName).resultString;
 
        std::stringstream mechanicsStream;
        mechanicsStream << VMlib::Preprocessor(mechanicsFileFullName).resultString;
 
        std::stringstream defaultsStream;
        defaultsStream << VMlib::Preprocessor(defaultsFileFullName).resultString;
 
        std::stringstream switchersStream;
        switchersStream << VMlib::Preprocessor(switchersFileFullName).resultString;
 
        GetAllParamsFromParser(mainStream, mechanicsStream, defaultsStream, switchersStream, varsStream);
 
        PrintAllParams();
    }
}

Here is the call graph for this function:

◆ ~Passport()

virtual VM2D::Passport::~Passport ( )

inlinevirtual

Деструктор

Definition at line 322 of file Passport2D.h.

322{ };

Member Function Documentation

◆ GetAllParamsFromParser()

void Passport::GetAllParamsFromParser	(	std::istream &	mainStream,
		std::istream &	mechanicsStream,
		std::istream &	defaultStream,
		std::istream &	switcherStream,
		std::istream &	varsStream
	)

overrideprivatevirtual

Считывание всех параметров расчета из соответствующих потоков

Parameters

[in]	mainStream	ссылка на основной поток
[in]	mechanicsStream	ссылка на поток со словарем механических систем
[in]	defaultStream	ссылка на поток с параметрами по умолчанию
[in]	switcherStream	ссылка на поток со значениями параметров-переключателей
[in]	varsStream	ссылка на поток с параметрами конкретной задачи и переменными

Todo:: Удалить в следующих версиях. Добавлено для совместимости со старым синтаксисом задания разгона потока

Implements VMlib::PassportGen.

Definition at line 108 of file Passport2D.cpp.

{   
    // 1. Разбор паспорта в целом
 
    //создаем парсер и связываем его с нужным потоком
    std::unique_ptr<VMlib::StreamParser> parser;
    parser.reset(new VMlib::StreamParser(info, "parser", mainStream, defaultStream, switcherStream, varsStream));
            
    //считываем общие параметры
    parser->get("rho", physicalProperties.rho);
    parser->get("vInf", physicalProperties.vInf);
    parser->get("vRef", physicalProperties.vRef, &defaults::defaultVRef);
 
    if (physicalProperties.vRef == 0.0)
    {
        if (physicalProperties.vInf.length() == 0.0)
        {
            info('e') << "Reference velocity should be non-zero!" << std::endl;
            exit(1);
        }
        physicalProperties.vRef = physicalProperties.vInf.length();
    }
 
    //Считывание схемы разгона потока
    {
        std::pair<std::pair<std::string, int>, std::string> velAccel;
        bool defParamAccelVel = parser->get("accelVel", velAccel, &defaults::defaultVelAccel);
        if (velAccel.first.second != -1)
        {
            physicalProperties.typeAccel = velAccel.first;
            std::stringstream sstr(velAccel.second);
            std::istream& istr(sstr);
 
            std::unique_ptr<VMlib::StreamParser> parserAccel;
 
            parserAccel.reset(new VMlib::StreamParser(info, "parserAccel", istr, defaultStream, switcherStream, varsStream));
            bool defParamTime = parserAccel->get("timeAccel", physicalProperties.timeAccel, &defaults::defaultTimeAccel, false);
            parserAccel->get("_DEFVAR_0", physicalProperties.timeAccel, &physicalProperties.timeAccel, defParamAccelVel && !defParamTime);
        }
        else
        {
            info('e') << "Velocity acceleration scheme <" << velAccel.first.first << "> is unknown" << std::endl;
            exit(1);
        }
 
        if (!defParamAccelVel)
            parser->get("timeAccel", physicalProperties.timeAccel, &defaults::defaultTimeAccel);
        else
        {
            double tempTimeAccel;
            if (parser->get("timeAccel", tempTimeAccel, &defaults::defaultTimeAccel, false))
            {
                info('e') << "timeAccel parameter is set twice!" << std::endl;
                exit(1);
            }
        }
    }
    
    
    parser->get("nu", physicalProperties.nu);
 
    parser->get("timeStart", timeDiscretizationProperties.timeStart, &defaults::defaultTimeStart);
    parser->get("timeStop", timeDiscretizationProperties.timeStop);
    parser->get("dt", timeDiscretizationProperties.dt);
    parser->get("nameLength", timeDiscretizationProperties.nameLength, &defaults::defaultNameLength);
    
    
    //Считывание схемы сохранения файлов Vtx
    std::pair<std::pair<std::string, int>, std::string> saveVtx;
    bool defParamSaveVtx = parser->get("saveVt?", saveVtx, &defaults::defaultSaveVtx);
    if (saveVtx.first.second != -1)
    {
        timeDiscretizationProperties.fileTypeVtx = saveVtx.first;
        std::stringstream sstr(saveVtx.second);
        std::istream& istr(sstr);
 
        std::unique_ptr<VMlib::StreamParser> parserSaveVtx;
 
        parserSaveVtx.reset(new VMlib::StreamParser(info, "parserSaveVtx", istr, defaultStream, switcherStream, varsStream));
        parserSaveVtx->get("_DEFVAR_0", timeDiscretizationProperties.saveVtxStep, &defaults::defaultSaveVtxStep, defParamSaveVtx);
    }
    else
    {
        std::stringstream ss;
        ss << saveVtx.first.first;
        int step;
        ss >> step;
        if (!ss.fail())
        {
            timeDiscretizationProperties.fileTypeVtx = defaults::defaultSaveVtx.first;
            timeDiscretizationProperties.saveVtxStep = step;
        }
        else
        {
            info('e') << "Vtx file type <" << saveVtx.first.first << "> is unknown" << std::endl;
            exit(1);
        }
    }
    
    
    //Считывание схемы сохранения файлов VP
    std::pair<std::pair<std::string, int>, std::string> saveVP;
    bool defParamSaveVP = parser->get("saveVP", saveVP, &defaults::defaultSaveVP);
    if (saveVP.first.second != -1)
    {
        timeDiscretizationProperties.fileTypeVP = saveVP.first;
        std::stringstream sstr(saveVP.second);
        std::istream& istr(sstr);
 
        std::unique_ptr<VMlib::StreamParser> parserSaveVP;
 
        parserSaveVP.reset(new VMlib::StreamParser(info, "parserSaveVP", istr, defaultStream, switcherStream, varsStream));
        parserSaveVP->get("_DEFVAR_0", timeDiscretizationProperties.saveVPstep, &defaults::defaultSaveVPstep, defParamSaveVP);
    }
    else
    {
        std::stringstream ss;
        ss << saveVP.first.first;
        int step;
        ss >> step;
        if (!ss.fail())
        {
            timeDiscretizationProperties.fileTypeVP = defaults::defaultSaveVP.first;
            timeDiscretizationProperties.saveVPstep = step;
        }
        else
        {
            info('e') << "VP file type <" << saveVP.first.first << "> is unknown" << std::endl;
            exit(1);
        }
    }
 
    parser->get("rotateVpPoints", rotateAngleVpPoints, &defaults::rotateAngleVpPoints);
    
    
    parser->get("saveVisStress", timeDiscretizationProperties.saveVisStress, &defaults::defaultSaveVisStress);
 
 
    parser->get("eps", wakeDiscretizationProperties.eps, &defaults::defaultEps);
    wakeDiscretizationProperties.eps2 = wakeDiscretizationProperties.eps* wakeDiscretizationProperties.eps;
    parser->get("epscol", wakeDiscretizationProperties.epscol, &defaults::defaultEpsCol);
    parser->get("distFar", wakeDiscretizationProperties.distFar, &defaults::defaultDistFar);
    parser->get("delta", wakeDiscretizationProperties.delta, &defaults::defaultDelta);
    parser->get("vortexPerPanel", wakeDiscretizationProperties.minVortexPerPanel, &defaults::defaultVortexPerPanel);
    parser->get("maxGamma", wakeDiscretizationProperties.maxGamma, &defaults::defaultMaxGamma);
    if (wakeDiscretizationProperties.maxGamma == 0.0)
        wakeDiscretizationProperties.maxGamma = 1e+10;
    
    parser->get("linearSystemSolver", numericalSchemes.linearSystemSolver, &defaults::defaultLinearSystemSolver);
    if (numericalSchemes.linearSystemSolver.second == 1 || numericalSchemes.linearSystemSolver.second == 2)
        parser->get("gmresEps", numericalSchemes.gmresEps);
 
    if (numericalSchemes.linearSystemSolver.second == 2) 
    {
        parser->get("fastGmresTheta", numericalSchemes.gmresTheta);
        parser->get("fastGmresMultipoleOrder", numericalSchemes.gmresMultipoleOrder);
    }
 
    parser->get("velocityComputation", numericalSchemes.velocityComputation, &defaults::defaultVelocityComputation);
 
    if (numericalSchemes.velocityComputation.second == 1)
    {
        parser->get("nbodyTheta", numericalSchemes.nbodyTheta);
        parser->get("nbodyMultipoleOrder", numericalSchemes.nbodyMultipoleOrder);
    }
 
    //parser->get("wakeMotionIntegrator", numericalSchemes.wakeMotionIntegrator);
    parser->get("boundaryConditionSatisfaction", numericalSchemes.boundaryCondition, &defaults::defaultBoundaryCondition);
    
    parser->get("airfoilsDir", airfoilsDir, &defaults::defaultAirfoilsDir);
    parser->get("wakesDir",    wakesDir,    &defaults::defaultWakesDir);
 
    parser->get("fileWake", wakeDiscretizationProperties.fileWake, &defaults::defaultFileWake);
    parser->get("fileSource", wakeDiscretizationProperties.fileSource, &defaults::defaultFileSource);
 
    //Для обдува ветром, когда углы считаются по компасу
    //parser->get("geographicalAngles", geographicalAngles, &defaults::defaultGeographicalAngles);
    //if (geographicalAngles && (physicalProperties.vInf[1] != 0.0))
    //{
    //  info('e') << "For geographical angles vInf should be horizontal; now vInf = " << physicalProperties.vInf << "." << std::endl;
    //  exit(1);
    //}
 
    parser->get("rotateForces", rotateForces, &defaults::defaultRotateForces);
    parser->get("calcCoefficients", calcCoefficients, &defaults::defaultCalcCoefficients);
 
    std::vector<std::string> airfoil;
    parser->get("airfoil", airfoil, &defaults::defaultAirfoil);
 
    // 2. Разбор параметров профилей
 
    //определяем число профилей и организуем цикл по ним
    size_t nAirfoil = airfoil.size();
    //*(defaults::defaultPinfo) << "Number of airfoils = " << nAirfoil << endl;
    for (size_t i = 0; i < nAirfoil; ++i) 
    {
        //делим имя файла + выражение в скобках на 2 подстроки
        std::pair<std::string, std::string> airfoilLine = VMlib::StreamParser::SplitString(info, airfoil[i], false);
 
        AirfoilParams prm;
        //первая подстрока - имя файла
        prm.fileAirfoil = airfoilLine.first;
 
        //вторую подстроку разделяем на вектор из строк по запятым, стоящим вне фигурных скобок     
        std::vector<std::string> vecAirfoilLineSecond = VMlib::StreamParser::StringToVector(airfoilLine.second, '{', '}');
                
        //создаем парсер и связываем его с параметрами профиля
        std::stringstream aflStream(VMlib::StreamParser::VectorStringToString(vecAirfoilLineSecond));
        std::unique_ptr<VMlib::StreamParser> parserAirfoil;
 
        parserAirfoil.reset(new VMlib::StreamParser(info, "airfoil parser", aflStream, defaultStream, switcherStream, varsStream));
 
        //считываем нужные параметры с учетом default-значений
        parserAirfoil->get("nPanels", prm.requiredNPanels, &defaults::defaultRequiredNPanels);
 
        parserAirfoil->get("basePoint", prm.basePoint, &defaults::defaultBasePoint);
        
        std::vector<double> tmpScale, defaultTmpScale = { defaults::defaultScale[0], defaults::defaultScale[1] };
        
        parserAirfoil->get("scale", tmpScale, &defaultTmpScale);
        switch (tmpScale.size())
        {
        case 1:
            prm.scale[0] = prm.scale[1] = tmpScale[0];
            break;
        case 2:
            prm.scale[0] = tmpScale[0];
            prm.scale[1] = tmpScale[1];
            break;
        default:
            info('e') << "Error in _scale_ value for airfoil" << std::endl;
            exit(1);
        }       
        //parserAirfoil->get("scale", prm.scalexy, &defaults::defaultScale);
        
        
        parserAirfoil->get("angle", prm.angle, &defaults::defaultAngle);
        prm.angle *= PI / 180.0;
 
        parserAirfoil->get("chord", prm.chord, &defaults::defaultChord);
 
        parserAirfoil->get("addedMass", prm.addedMass, &defaults::defaultAddedMass);
 
 
        parserAirfoil->get("inverse", prm.inverse, &defaults::defaultInverse);      
        parserAirfoil->get("mechanicalSystem", prm.mechanicalSystem, &defaults::defaultMechanicalSystem);
 
        if (prm.mechanicalSystem == defaults::defaultMechanicalSystem)
        {
            prm.mechanicalSystemType = 0;
            prm.mechanicalSystemParameters = "";
        }
        else
        {
            std::unique_ptr<VMlib::StreamParser> parserMechanicsList;
            std::unique_ptr<VMlib::StreamParser> parserSwitchers;
            parserMechanicsList.reset(new VMlib::StreamParser(info, "mechanical parser", mechanicsStream, defaultStream, switcherStream, varsStream, { prm.mechanicalSystem }));
            parserSwitchers.reset(new VMlib::StreamParser(info, "switchers parser" ,switcherStream));
 
            std::string mechString;
 
            parserMechanicsList->get(prm.mechanicalSystem, mechString);
            
            //делим тип мех.системы + выражение в скобках (ее параметры) на 2 подстроки
            std::pair<std::string, std::string> mechanicsLine = VMlib::StreamParser::SplitString(info, mechString);
 
            std::string mechTypeAlias = mechanicsLine.first;
            parserSwitchers->get(mechTypeAlias, prm.mechanicalSystemType);
 
            //вторую подстроку разделяем на вектор из строк по запятым, стоящим вне фигурных скобок     
            std::vector<std::string> vecMechLineSecond = VMlib::StreamParser::StringToVector(mechanicsLine.second, '{', '}');
            prm.mechanicalSystemParameters = VMlib::StreamParser::VectorStringToString(vecMechLineSecond);
        }
 
        //отправляем считанные параметры профиля в структуру данных паспорта 
        airfoilParams.push_back(prm);
 
    } //for i
}//GetAllParamsFromParser(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAllParams()

void Passport::PrintAllParams ( )

overrideprivatevirtual

Печать всех параметров расчета в поток логов

Implements VMlib::PassportGen.

Definition at line 398 of file Passport2D.cpp.

{
    const std::string str = "passport info: ";
 
    info('i') << "--- Passport info ---" << std::endl;
    info('-') << "rho = " << physicalProperties.rho << std::endl;
    info('-') << "vInf = " << physicalProperties.vInf << std::endl;
    info('-') << "vRef = " << physicalProperties.vRef << std::endl;
    info('-') << "velAccel = " << physicalProperties.typeAccel.first << "( " << physicalProperties.timeAccel << " )" << std::endl;
 
    info('-') << "nu = " << physicalProperties.nu << std::endl;
    info('-') << "timeStart = " << timeDiscretizationProperties.timeStart << std::endl;
    info('-') << "timeStop = " << timeDiscretizationProperties.timeStop << std::endl;
    info('-') << "dt = " << timeDiscretizationProperties.dt << std::endl;
    info('-') << "nameLength = " << timeDiscretizationProperties.nameLength << std::endl;
    info('-') << "saveVtx = " << timeDiscretizationProperties.fileTypeVtx.first << "( " << timeDiscretizationProperties.saveVtxStep << " )" << std::endl;
    info('-') << "saveVP = " << timeDiscretizationProperties.fileTypeVP.first << "( " << timeDiscretizationProperties.saveVPstep << " )" << std::endl;
    info('-') << "saveVisStress = " << timeDiscretizationProperties.saveVisStress << std::endl;
    info('-') << "eps = " << wakeDiscretizationProperties.eps << std::endl;
    info('-') << "eps2 = " << wakeDiscretizationProperties.eps2 << std::endl;
    info('-') << "epscol = " << wakeDiscretizationProperties.epscol << std::endl;
    info('-') << "distFar = " << wakeDiscretizationProperties.distFar << std::endl;
    info('-') << "delta = " << wakeDiscretizationProperties.delta << std::endl;
    info('-') << "vortexPerPanel = " << wakeDiscretizationProperties.minVortexPerPanel << std::endl;
    info('-') << "maxGamma = " << ((wakeDiscretizationProperties.maxGamma == 1e+10) ? 0.0 : wakeDiscretizationProperties.maxGamma) << std::endl;
    info('-') << "linearSystemSolver = " << numericalSchemes.linearSystemSolver.first << std::endl;
    if (numericalSchemes.linearSystemSolver.second == 1 || numericalSchemes.linearSystemSolver.second == 2)
    {
        info('-') << "gmresEps = " << numericalSchemes.gmresEps << std::endl;
        if (numericalSchemes.linearSystemSolver.second == 2)
        {
            info('-') << "gmresTheta = " << numericalSchemes.gmresTheta << std::endl;
            info('-') << "gmresMultipoleOrder = " << numericalSchemes.gmresMultipoleOrder << std::endl;
        }
    }
 
    info('-') << "velocityComputation = " << numericalSchemes.velocityComputation.first << std::endl;
    if (numericalSchemes.velocityComputation.second == 1)
    {
        info('-') << "nbodyTheta = " << numericalSchemes.nbodyTheta << std::endl;
        info('-') << "nbodyMultipoleOrder = " << numericalSchemes.nbodyMultipoleOrder << std::endl;
    }
 
    //info('-') << "wakeMotionIntegrator = " << numericalSchemes.wakeMotionIntegrator << std::endl;
    info('_') << "boundaryCondition = " << numericalSchemes.boundaryCondition.first << std::endl;
    
    info('-') << "airfoilsDir = " << airfoilsDir << std::endl;
    info('-') << "wakesDir = " << wakesDir << std::endl;
 
    //Для обдува ветром, когда углы считаются по компасу
    //info('-') << "geographicalAngles = " << geographicalAngles << std::endl;
    info('-') << "rotateForces = " << rotateForces << std::endl;
    info('-') << "calcCoefficients = " << calcCoefficients << std::endl;
    info('-') << "rotateVpPoints = " << rotateAngleVpPoints << std::endl;
 
 
 
    info('-') << "number of airfoils = " << airfoilParams.size() << std::endl;
    for (size_t q = 0; q < airfoilParams.size(); ++q)
    {
        info('_') << "airfoil[" << q << "]_file = " << airfoilParams[q].fileAirfoil << std::endl;
        info('_') << "airfoil[" << q << "]_requiredNPanels = " << airfoilParams[q].requiredNPanels << std::endl;
        info('_') << "airfoil[" << q << "]_basePoint = " << airfoilParams[q].basePoint << std::endl;
        info('_') << "airfoil[" << q << "]_scale = " << airfoilParams[q].scale << std::endl;
        info('_') << "airfoil[" << q << "]_angle = " << airfoilParams[q].angle << std::endl;
        info('_') << "airfoil[" << q << "]_chord = " << airfoilParams[q].chord << std::endl;
        info('_') << "airfoil[" << q << "]_inverse = " << (airfoilParams[q].inverse ? "true": "false") << std::endl;
        info('_') << "airfoil[" << q << "]_mechanicalSystem = " << airfoilParams[q].mechanicalSystem << std::endl;
        info('_') << "airfoil[" << q << "]_addedMass = " << airfoilParams[q].addedMass << std::endl;
    }
 
    info('-') << "fileWake = " << wakeDiscretizationProperties.fileWake << std::endl;
    info('-') << "fileSource = " << wakeDiscretizationProperties.fileSource << std::endl;
}

Here is the caller graph for this function:

Member Data Documentation

◆ airfoilParams

std::vector<AirfoilParams> VM2D::Passport::airfoilParams

Список структур с параметрами профилей

Definition at line 273 of file Passport2D.h.

◆ airfoilsDir

std::string VM2D::Passport::airfoilsDir

Каталог с файлами профилей

Definition at line 267 of file Passport2D.h.

◆ calcCoefficients

bool VM2D::Passport::calcCoefficients

Признак вычисления коэффициентов вместо сил

Definition at line 282 of file Passport2D.h.

◆ dir

std::string VMlib::PassportGen::dir

inherited

Рабочий каталог задачи

Definition at line 122 of file PassportGen.h.

◆ info

LogStream VMlib::PassportGen::info

mutableprotectedinherited

Поток для вывода логов и сообщений об ошибках

Definition at line 115 of file PassportGen.h.

◆ numericalSchemes

NumericalSchemes VM2D::Passport::numericalSchemes

Структура с используемыми численными схемами

Definition at line 295 of file Passport2D.h.

◆ physicalProperties

PhysicalProperties VM2D::Passport::physicalProperties

Структура с физическими свойствами задачи

Definition at line 289 of file Passport2D.h.

◆ problemName

std::string VMlib::PassportGen::problemName

inherited

Название задачи

Definition at line 125 of file PassportGen.h.

◆ problemNumber

size_t VMlib::PassportGen::problemNumber

inherited

Номер задачи

Definition at line 128 of file PassportGen.h.

◆ rotateAngleVpPoints

double VM2D::Passport::rotateAngleVpPoints

Угол поворота точек VP.

Definition at line 285 of file Passport2D.h.

◆ rotateForces

bool VM2D::Passport::rotateForces

Признак работы в "географической" системе координат

Признак поворота вычисляемых сил в профильную систему координат

Definition at line 279 of file Passport2D.h.

◆ timeDiscretizationProperties

TimeDiscretizationProperties VMlib::PassportGen::timeDiscretizationProperties

inherited

Структура с параметрами процесса интегрирования по времени

Definition at line 131 of file PassportGen.h.

◆ wakeDiscretizationProperties

WakeDiscretizationProperties VM2D::Passport::wakeDiscretizationProperties

Структура с параметрами дискретизации вихревого следа

Definition at line 292 of file Passport2D.h.

◆ wakesDir

std::string VM2D::Passport::wakesDir

Каталог с файлами вихревых следов

Definition at line 270 of file Passport2D.h.

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

VM2D/Passport2D/Passport2D.h
VM2D/Passport2D/Passport2D.cpp

Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Passport()

◆ ~Passport()

Member Function Documentation

◆ GetAllParamsFromParser()

◆ PrintAllParams()

Member Data Documentation

◆ airfoilParams

◆ airfoilsDir

◆ calcCoefficients

◆ dir

◆ info

◆ numericalSchemes

◆ physicalProperties

◆ problemName

◆ problemNumber

◆ rotateAngleVpPoints

◆ rotateForces

◆ timeDiscretizationProperties

◆ wakeDiscretizationProperties

◆ wakesDir