VM2D::Passport Class Reference

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

#include <Passport2D.h>

Inheritance diagram for VM2D::Passport:

Collaboration diagram for VM2D::Passport:

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)
	Конструктор More...
virtual	~Passport ()
	Деструктор More...

Public Attributes
std::string	airfoilsDir
	Каталог с файлами профилей More...
std::string	wakesDir
	Каталог с файлами вихревых следов More...
std::vector< AirfoilParams >	airfoilParams
	Список структур с параметрами профилей More...
bool	geographicalAngles
	Признак работы в "географической" системе координат More...
bool	rotateForces
	Признак поворота вычисляемых сил в профильную систему координат More...
bool	calcCoefficients
	Признак вычисления коэффициентов вместо сил More...
double	rotateAngleVpPoints
	Угол поворота точек VP. More...
PhysicalProperties	physicalProperties
	Структура с физическими свойствами задачи More...
WakeDiscretizationProperties	wakeDiscretizationProperties
	Структура с параметрами дискретизации вихревого следа More...
NumericalSchemes	numericalSchemes
	Структура с используемыми численными схемами More...
std::string	dir
	Рабочий каталог задачи More...
std::string	problemName
	Название задачи More...
size_t	problemNumber
	Номер задачи More...
TimeDiscretizationProperties	timeDiscretizationProperties
	Структура с параметрами процесса интегрирования по времени More...

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

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

Detailed Description

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

Author

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

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

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

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

Date

14 января 2024 г.

Definition at line 258 of file Passport2D.h.

Constructor & Destructor Documentation

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 70 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, { "txt", "TXT"}) &&
        fileExistTest(defaultsFileFullName, info, { "txt", "TXT" }) &&
        fileExistTest(switchersFileFullName, info, { "txt", "TXT" }) &&
        fileExistTest(mechanicsFileFullName, info, { "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:

virtual VM2D::Passport::~Passport ( )

inlinevirtual

Деструктор

Definition at line 329 of file Passport2D.h.

{ };

Member Function Documentation

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 110 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);
    wakeDiscretizationProperties.eps2 = wakeDiscretizationProperties.eps* wakeDiscretizationProperties.eps;
    parser->get("epscol", wakeDiscretizationProperties.epscol);
    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);
    parser->get("velocityComputation", numericalSchemes.velocityComputation, &defaults::defaultVelocityComputation);
    //parser->get("wakeMotionIntegrator", numericalSchemes.wakeMotionIntegrator);
    parser->get("panelsType", numericalSchemes.panelsType, &defaults::defaultPanelsType);
    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:

void Passport::PrintAllParams ( )

overrideprivatevirtual

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

Implements VMlib::PassportGen.

Definition at line 383 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;
    info('-') << "velocityComputation = " << numericalSchemes.velocityComputation.first << std::endl;
    //info('-') << "wakeMotionIntegrator = " << numericalSchemes.wakeMotionIntegrator << std::endl;
    info('_') << "panelType = " << numericalSchemes.panelsType.first << 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('-') << "fileWake = " << wakeDiscretizationProperties.fileWake << std::endl;
    info('-') << "fileSource = " << wakeDiscretizationProperties.fileSource << std::endl;
}

Member Data Documentation

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

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

Definition at line 280 of file Passport2D.h.

std::string VM2D::Passport::airfoilsDir

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

Definition at line 274 of file Passport2D.h.

bool VM2D::Passport::calcCoefficients

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

Definition at line 289 of file Passport2D.h.

std::string VMlib::PassportGen::dir

inherited

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

Definition at line 118 of file PassportGen.h.

bool VM2D::Passport::geographicalAngles

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

Definition at line 283 of file Passport2D.h.

LogStream VMlib::PassportGen::info

mutableprotectedinherited

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

Definition at line 111 of file PassportGen.h.

NumericalSchemes VM2D::Passport::numericalSchemes

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

Definition at line 302 of file Passport2D.h.

PhysicalProperties VM2D::Passport::physicalProperties

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

Definition at line 296 of file Passport2D.h.

std::string VMlib::PassportGen::problemName

inherited

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

Definition at line 121 of file PassportGen.h.

size_t VMlib::PassportGen::problemNumber

inherited

Номер задачи

Definition at line 124 of file PassportGen.h.

double VM2D::Passport::rotateAngleVpPoints

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

Definition at line 292 of file Passport2D.h.

bool VM2D::Passport::rotateForces

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

Definition at line 286 of file Passport2D.h.

TimeDiscretizationProperties VMlib::PassportGen::timeDiscretizationProperties

inherited

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

Definition at line 127 of file PassportGen.h.

WakeDiscretizationProperties VM2D::Passport::wakeDiscretizationProperties

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

Definition at line 299 of file Passport2D.h.

std::string VM2D::Passport::wakesDir

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

Definition at line 277 of file Passport2D.h.

---

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

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