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

#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, const std::vector< std::string > &paramList)
	Конструктор

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

void	GetReviseParamsFromParser (const Passport &newPassport, const std::vector< std::string > paramList)
	Считывание измененных параметров

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

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

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

std::string	fileFullName
	Имена файлов

std::string	mechanicsFileFullName

std::string	defaultsFileFullName

std::string	switchersFileFullName

std::vector< std::string >	varLine

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	GetParamsFromParser (std::istream &mainStream, std::istream &mechanicsStream, std::istream &defaultStream, std::istream &switcherStream, std::istream &varsStream, const std::vector< std::string > paramList) override
	Считывание всех параметров расчета из соответствующих потоков

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

Detailed Description

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

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

Version: 1.14

Date: 6 марта 2026 г.

Definition at line 255 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,
		const std::vector< std::string > &	paramList
	)

Конструктор

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

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)
{
    fileFullName = _filePassport;
    mechanicsFileFullName = _mechanics;
    defaultsFileFullName = _defaults;
    switchersFileFullName = _switchers;
    varLine = vars;
 
    bool readAll = ((paramList.size() == 1) && (paramList[0] == ""));
 
    
    VMlib::LogStream emptyStream;
    VMlib::LogStream& infoOrEmptyStream = readAll ? info : emptyStream;
 
    if (
        fileExistTest(fileFullName, infoOrEmptyStream, true, {"txt", "TXT"}) &&
        fileExistTest(defaultsFileFullName, infoOrEmptyStream, true, { "txt", "TXT" }) &&
        fileExistTest(switchersFileFullName, infoOrEmptyStream, true, { "txt", "TXT" }) &&
        fileExistTest(mechanicsFileFullName, infoOrEmptyStream, 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;
 
        
        GetParamsFromParser(mainStream, mechanicsStream, defaultsStream, switchersStream, varsStream, paramList);
        
        if (readAll)
            PrintAllParams();
        
    }
}

Here is the call graph for this function:

◆ ~Passport()

virtual VM2D::Passport::~Passport ( )

inlinevirtual

Деструктор

Definition at line 338 of file Passport2D.h.

338{ };

Member Function Documentation

◆ GetParamsFromParser()

void Passport::GetParamsFromParser	(	std::istream &	mainStream,
		std::istream &	mechanicsStream,
		std::istream &	defaultStream,
		std::istream &	switcherStream,
		std::istream &	varsStream,
		const std::vector< std::string >	paramList
	)

overrideprivatevirtual

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

Parameters

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

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

Implements VMlib::PassportGen.

Definition at line 118 of file Passport2D.cpp.

{
    auto UP = VMlib::StreamParser::UpperCase;
 
    bool readAll = ((paramList.size() == 1) && (paramList[0] == ""));
    std::vector<std::string> PR;
    for (const auto& s : paramList)
        PR.push_back(UP(s));
 
 
    auto ifUpdate = [&](const std::string& checkString) {return (readAll || std::count(PR.begin(), PR.end(), UP(checkString))); };
 
 
    // 1. Разбор паспорта в целом
 
    //создаем парсер и связываем его с нужным потоком
    std::unique_ptr<VMlib::StreamParser> parser;
    parser.reset(new VMlib::StreamParser(info, "parser", mainStream, defaultStream, switcherStream, varsStream));
 
    //считываем общие параметры
    if (readAll)    
        parser->get("rho", physicalProperties.rho); 
 
    if (ifUpdate("vInf") || ifUpdate("vRef"))
    {
        if (ifUpdate("vInf"))
            parser->get("vInf", physicalProperties.vInf);
 
        parser->get("vRef", physicalProperties.vRef, &defaults::defaultVRef, false);
 
        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();
        }
    }
 
 
    //Считывание схемы разгона потока
    if (readAll)
    {
        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);
            }
        }
    }
    
    if (readAll)
    {
        parser->get("nu", physicalProperties.nu);
 
        parser->get("timeStart", timeDiscretizationProperties.timeStart, &defaults::defaultTimeStart);
    }
    
    if (ifUpdate("timeStop"))
        parser->get("timeStop", timeDiscretizationProperties.timeStop);
    
    if (ifUpdate("dt"))
        parser->get("dt", timeDiscretizationProperties.dt);         
 
    if (ifUpdate("nameLength"))
        parser->get("nameLength", timeDiscretizationProperties.nameLength, &defaults::defaultNameLength);
 
    
    //Считывание схемы сохранения файлов Vtx
    if (ifUpdate("saveVtx"))
    {
        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
    if (ifUpdate("saveVP"))
    {
        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);
            }
        }
    }
 
    if (readAll)
    {
        parser->get("revisePassportStep", timeDiscretizationProperties.revisePassportStep, &defaults::defaultRevisePassportStep);
        parser->get("reviseParameters", timeDiscretizationProperties.reviseParameters, &defaults::defaultReviseParameters);
 
        const std::vector<std::string> varParams = { UP("nameLength"), UP("timeStop"), UP("dt"), UP("vInf"), UP("vRef"), UP("coefEpsAst"), UP("saveVtx"), UP("saveVP")};
        for (const auto& s : timeDiscretizationProperties.reviseParameters)
            if (std::count(varParams.begin(), varParams.end(), UP(s)) == 0)
            {
                info('e') << "Parameter \"" << s << "\" can not be changable (i.e., re-readable)!" << std::endl;
                exit(1);
            }
 
    }
 
    if (readAll)
    {
        parser->get("rotateVpPoints", rotateAngleVpPoints, &defaults::rotateAngleVpPoints);
        parser->get("saveVisStress", timeDiscretizationProperties.saveVisStress, &defaults::defaultSaveVisStress);
    }
 
    if (readAll)
    {
        double oldEpsilon;
        parser->get("eps", oldEpsilon, &defaults::defaultSigma0);
        if (oldEpsilon != 0)
        {
            info('e') << "Rename 'eps' parameter in passport file: 'eps' -> 'sigma0'" << std::endl;
            exit(1);
        }
 
 
        parser->get("sigma0", wakeDiscretizationProperties.sigma0, &defaults::defaultSigma0);
        
 
        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;
    }
 
    if (ifUpdate("coefEpsAst"))
        parser->get("coefEpsAst", wakeDiscretizationProperties.coefEpsAst, &defaults::defaultCoefEpsAst, readAll);
 
    if (readAll)
    {
        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);      
    }
 
    // 2. Разбор параметров профилей
    if (readAll)
    {
        std::vector<std::string> airfoil;
        parser->get("airfoil", airfoil, &defaults::defaultAirfoil);
 
        //определяем число профилей и организуем цикл по ним
        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
    }//readAll
}//GetAllParamsFromParser(...)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetReviseParamsFromParser()

void Passport::GetReviseParamsFromParser	(	const Passport &	newPassport,
		const std::vector< std::string >	paramList
	)

Считывание измененных параметров

Definition at line 479 of file Passport2D.cpp.

{
    auto UP = VMlib::StreamParser::UpperCase;
 
    bool readAll = ((paramList.size() == 1) && (paramList[0] == ""));
    std::vector<std::string> PR;
    for (const auto& s : paramList)
        PR.push_back(UP(s));
 
 
    auto ifUpdate = [&](const std::string& checkString) {return (readAll || std::count(PR.begin(), PR.end(), UP(checkString))); };
 
    if (ifUpdate("nameLength") && (this->timeDiscretizationProperties.nameLength != newPassport.timeDiscretizationProperties.nameLength))
    {
        this->timeDiscretizationProperties.nameLength = newPassport.timeDiscretizationProperties.nameLength;
        info('i') << "updated nameLength = " << timeDiscretizationProperties.nameLength << std::endl;
    }
    
    if (ifUpdate("timeStop") && (timeDiscretizationProperties.timeStop != newPassport.timeDiscretizationProperties.timeStop))
    {
        timeDiscretizationProperties.timeStop = newPassport.timeDiscretizationProperties.timeStop;
        info('i') << "updated timeStop = " << timeDiscretizationProperties.timeStop << std::endl;
    }
 
    if (ifUpdate("dt") && (timeDiscretizationProperties.dt != newPassport.timeDiscretizationProperties.dt))
    {
        timeDiscretizationProperties.dt = newPassport.timeDiscretizationProperties.dt;
        info('i') << "updated dt = " << timeDiscretizationProperties.dt << std::endl;
    }
 
    if (ifUpdate("vInf") && (physicalProperties.vInf != newPassport.physicalProperties.vInf))
    {
        physicalProperties.vInf = newPassport.physicalProperties.vInf;      
        info('i') << "updated vInf = " << physicalProperties.vInf << std::endl;
        
        if (physicalProperties.vRef != newPassport.physicalProperties.vRef)
        {
            physicalProperties.vRef = newPassport.physicalProperties.vRef;
            info('i') << "updated vRef = " << physicalProperties.vRef << std::endl;
        }
    }
 
    if (ifUpdate("vRef") && (physicalProperties.vRef != newPassport.physicalProperties.vRef))
    {
        physicalProperties.vRef = newPassport.physicalProperties.vRef;
        info('i') << "updated vRef = " << physicalProperties.vRef << std::endl; 
    }
 
    if (ifUpdate("coefEpsAst") && (wakeDiscretizationProperties.coefEpsAst != newPassport.wakeDiscretizationProperties.coefEpsAst))
    {
        wakeDiscretizationProperties.coefEpsAst = newPassport.wakeDiscretizationProperties.coefEpsAst;
        info('i') << "updated coefEpsAst = " << wakeDiscretizationProperties.coefEpsAst << std::endl;
    }
 
 
    if (ifUpdate("saveVtx") &&
        (timeDiscretizationProperties.fileTypeVtx != newPassport.timeDiscretizationProperties.fileTypeVtx || timeDiscretizationProperties.saveVtxStep != newPassport.timeDiscretizationProperties.saveVtxStep))
    {
        timeDiscretizationProperties.fileTypeVtx = newPassport.timeDiscretizationProperties.fileTypeVtx;
        timeDiscretizationProperties.saveVtxStep = newPassport.timeDiscretizationProperties.saveVtxStep;
 
        info('-') << "updated saveVtx = " << timeDiscretizationProperties.fileTypeVtx.first << "( " << timeDiscretizationProperties.saveVtxStep << " )" << std::endl;       
    }
 
    if (ifUpdate("saveVP") &&
        (timeDiscretizationProperties.fileTypeVP != newPassport.timeDiscretizationProperties.fileTypeVP || timeDiscretizationProperties.saveVPstep != newPassport.timeDiscretizationProperties.saveVPstep))
    {
        timeDiscretizationProperties.fileTypeVP = newPassport.timeDiscretizationProperties.fileTypeVP;
        timeDiscretizationProperties.saveVPstep = newPassport.timeDiscretizationProperties.saveVPstep;
 
        info('-') << "updated saveVtx = " << timeDiscretizationProperties.fileTypeVP.first << "( " << timeDiscretizationProperties.saveVPstep << " )" << std::endl;
    }
 
}//GetReviseParamsFromParser

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 562 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('-') << "revisePassportStep = " << timeDiscretizationProperties.revisePassportStep << std::endl;
    info('-') << "reviseParameters = {";
    for (const auto& s : timeDiscretizationProperties.reviseParameters)
        info('-') << s << "";
    info('-') << "}" << std::endl;
        
    info('-') << "saveVisStress = " << timeDiscretizationProperties.saveVisStress << std::endl;
    info('-') << "sigma0 = " << wakeDiscretizationProperties.sigma0 << std::endl;   
    info('-') << "epscol = " << wakeDiscretizationProperties.epscol << std::endl;
    info('-') << "coefEpsAst = " << wakeDiscretizationProperties.coefEpsAst << 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 279 of file Passport2D.h.

◆ airfoilsDir

std::string VM2D::Passport::airfoilsDir

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

Definition at line 273 of file Passport2D.h.

◆ calcCoefficients

bool VM2D::Passport::calcCoefficients

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

Definition at line 297 of file Passport2D.h.

◆ defaultsFileFullName

std::string VM2D::Passport::defaultsFileFullName

Definition at line 284 of file Passport2D.h.

◆ dir

std::string VMlib::PassportGen::dir

inherited

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

Definition at line 129 of file PassportGen.h.

◆ fileFullName

std::string VM2D::Passport::fileFullName

Имена файлов

Definition at line 282 of file Passport2D.h.

◆ info

LogStream VMlib::PassportGen::info

mutableprotectedinherited

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

Definition at line 122 of file PassportGen.h.

◆ mechanicsFileFullName

std::string VM2D::Passport::mechanicsFileFullName

Definition at line 283 of file Passport2D.h.

◆ numericalSchemes

NumericalSchemes VM2D::Passport::numericalSchemes

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

Definition at line 310 of file Passport2D.h.

◆ physicalProperties

PhysicalProperties VM2D::Passport::physicalProperties

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

Definition at line 304 of file Passport2D.h.

◆ problemName

std::string VMlib::PassportGen::problemName

inherited

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

Definition at line 132 of file PassportGen.h.

◆ problemNumber

size_t VMlib::PassportGen::problemNumber

inherited

Номер задачи

Definition at line 135 of file PassportGen.h.

◆ rotateAngleVpPoints

double VM2D::Passport::rotateAngleVpPoints

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

Definition at line 300 of file Passport2D.h.

◆ rotateForces

bool VM2D::Passport::rotateForces

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

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

Definition at line 294 of file Passport2D.h.

◆ switchersFileFullName

std::string VM2D::Passport::switchersFileFullName

Definition at line 285 of file Passport2D.h.

◆ timeDiscretizationProperties

TimeDiscretizationProperties VMlib::PassportGen::timeDiscretizationProperties

inherited

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

Definition at line 138 of file PassportGen.h.

◆ varLine

std::vector<std::string> VM2D::Passport::varLine

Definition at line 286 of file Passport2D.h.

◆ wakeDiscretizationProperties

WakeDiscretizationProperties VM2D::Passport::wakeDiscretizationProperties

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

Definition at line 307 of file Passport2D.h.

◆ wakesDir

std::string VM2D::Passport::wakesDir

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

Definition at line 276 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

◆ GetParamsFromParser()

◆ GetReviseParamsFromParser()

◆ PrintAllParams()

Member Data Documentation

◆ airfoilParams

◆ airfoilsDir

◆ calcCoefficients

◆ defaultsFileFullName

◆ dir

◆ fileFullName

◆ info

◆ mechanicsFileFullName

◆ numericalSchemes

◆ physicalProperties

◆ problemName

◆ problemNumber

◆ rotateAngleVpPoints

◆ rotateForces

◆ switchersFileFullName

◆ timeDiscretizationProperties

◆ varLine

◆ wakeDiscretizationProperties

◆ wakesDir