Passport2D.cpp

Go to the documentation of this file.

/*--------------------------------*- VM2D -*-----------------*---------------*\
| ##  ## ##   ##  ####  #####   |                            | Version 1.14   |
| ##  ## ### ### ##  ## ##  ##  |  VM2D: Vortex Method       | 2026/03/06     |
| ##  ## ## # ##    ##  ##  ##  |  for 2D Flow Simulation    *----------------*
|  ####  ##   ##   ##   ##  ##  |  Open Source Code                           |
|   ##   ##   ## ###### #####   |  https://www.github.com/vortexmethods/VM2D  |
|                                                                             |
| Copyright (C) 2017-2026 I. Marchevsky, K. Sokol, E. Ryatina, A. Kolganova   |
*-----------------------------------------------------------------------------*
| File name: Passport2D.cpp                                                   |
| Info: Source code of VM2D                                                   |
|                                                                             |
| This file is part of VM2D.                                                  |
| VM2D is free software: you can redistribute it and/or modify it             |
| under the terms of the GNU General Public License as published by           |
| the Free Software Foundation, either version 3 of the License, or           |
| (at your option) any later version.                                         |
|                                                                             |
| VM2D is distributed in the hope that it will be useful, but WITHOUT         |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       |
| FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License       |
| for more details.                                                           |
|                                                                             |
| You should have received a copy of the GNU General Public License           |
| along with VM2D.  If not, see <http://www.gnu.org/licenses/>.               |
\*---------------------------------------------------------------------------*/
 
 
#include "Passport2D.h"
 
#include "Preprocessor.h"
#include "StreamParser.h"
 
using namespace VM2D;
 
 
 
// Функция-множитель, позволяющая моделировать разгон
double PhysicalProperties::accelCft(double currentTime) const
{
    switch (typeAccel.second)
    {
    case 0: //импульсный старт
        return 1.0;
    case 1: //разгон потока по линейному закону
        return (currentTime < timeAccel) ? (currentTime / timeAccel) : 1.0;
    case 2: //разгон потока по косинусоиде
        return (currentTime < timeAccel) ? 0.5 * (1.0 - cos(PI * currentTime / timeAccel)) : 1.0;
    }
 
    return 1.0;
}//accelCft()
 
 
 
 
//Конструктор
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)
: 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();
        
    }
}
 
 
//Считывание всех параметров расчета из соответствующих потоков
void Passport::GetParamsFromParser
(
    std::istream& mainStream,
    std::istream& mechanicsStream,
    std::istream& defaultStream,
    std::istream& switcherStream,
    std::istream& varsStream,
    const std::vector<std::string> paramList
)
{
    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("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 (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(...)
 
 
 
 
void Passport::GetReviseParamsFromParser
(
    const Passport& newPassport,
    const std::vector<std::string> paramList
)
{
    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("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
 
 
 
 
//Печать всех параметров расчета в поток логов
void Passport::PrintAllParams()
{
    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('-') << "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;
}//PrintAllParams()