defs.h

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: defs.h                                                           |
| 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/>.               |
\*---------------------------------------------------------------------------*/
 
 
#ifndef DEFS_H
#define DEFS_H
 
#if defined(_WIN32)
    #include <direct.h>
#endif
 
#include <fstream>
#include <sys/stat.h>
#include <sys/types.h>
 
#include <ctime>
#include <iostream>
#include <list>
 
#include "Eigen/Dense"
 
#include "Gpudefs.h"
#include "LogStream.h"
 
#include "Vortex2D.h"
#include "v3D.h"
#include "PairInt.h"
 
 
#define DYN_SCHEDULE 20
   
enum class PointType { wake, wakeVP, sheetGam, sourceWake, source };
 
typedef std::pair<double, double> timePeriod;
 
const double PI = 3.1415926535897932384626433832795;
 
const double IDPI = 0.1591549430918953357688837633725;
 
const double DPI = 6.2831853071795864769252867665590;
 
const double IQPI = 0.07957747154594766788444188168626;
 
const double QPI = 12.566370614359172953850573533118;
 
namespace defaults
{
    const double defaultTimeStart = 0.0;
 
    const std::pair<std::pair<std::string, int>, std::string> defaultVelAccel = { {"RampLin", 1}, "" };
    const double defaultTimeAccel = 0.0;
    
    const std::pair<std::pair<std::string, int>, std::string> defaultSaveVP = { {"text", 0}, "" };
    const int defaultSaveVPstep = 0;
 
    const std::pair<std::pair<std::string, int>, std::string> defaultSaveVtx = { {"text", 0}, "" };
    const int defaultSaveVtxStep = 100;
 
    const int defaultSaveVisStress = 0;
 
    const int defaultRevisePassportStep = 10;
    const std::vector<std::string> defaultReviseParameters = { "nameLength", "timeStop", "dt", "vInf", "vRef", "saveVtx", "saveVP" };
 
    const int defaultNameLength = 5;
 
    const double defaultSigma0 = 0.0; //значит, рассчитать его по длине панелей как половину средней длины панелей
 
    const double defaultEpsCol = 0.0; //значит, рассчитать его как 2/3 eps
 
    const double defaultDistFar = 20.0;
 
    const double defaultDelta = 1.e-6;
 
    const int defaultVortexPerPanel = 1;
 
    const double defaultMaxGamma = 0.0;
        
    const double defaultVRef = 0.0;
 
    const size_t defaultRequiredNPanels = 0;
 
    const std::pair<std::string, int> defaultBoundaryCondition = { "boundaryConstantLayerAver", 1 };
 
    const std::pair<std::string, int> defaultLinearSystemSolver = { "linearSystemGauss", 0 };
 
    const std::pair<std::string, int> defaultVelocityComputation{ "velocityBarnesHut", 1 };
 
    //const bool defaultGeographicalAngles = false; //Для обдува ветром, когда углы считаются по компасу
 
    const bool defaultRotateForces = false;
 
    const bool defaultCalcCoefficients = false;
 
    const double rotateAngleVpPoints = 0;
 
    const std::string defaultAirfoilsDir = "../settings/airfoils/";
    const std::string defaultBodiesDir = "../settings/bodies/";
 
    const std::string defaultWakesDir = "../settings/wakes/";
 
    const std::vector<std::string> defaultFileAirfoil({});
    const std::vector<std::string> defaultFileBody({});
 
    const std::string defaultFileWake("");
 
    const std::string defaultFileSource("");
 
    const std::vector<std::string> defaultAirfoil({});
    const std::vector<std::string> defaultBody({});
 
    const VMlib::Point2D defaultBasePoint = { 0.0, 0.0 };
    const VMlib::v3D defaultBasePoint3D = { 0.0, 0.0, 0.0 };
    
    const Point2D defaultScale = { 1.0, 1.0 };
 
    const double defaultAngle = 0.0;
 
    const double defaultChord = 0.0;
 
    const Point2D defaultAddedMass = { 0.0, 0.0 };
    
    const bool defaultInverse = false;
    
    const int defaultMechanicalSystemType = 0;
    const std::string defaultMechanicalSystem = "";
 
    const std::string defaultPspFile = "passport";
 
    const int defaultNp = 1;
 
    const std::string defaultCopyPath = "";
 
    static std::ostream* defaultQueueLogStream = &std::cout;
 
    static std::ostream* defaultWorld2DLogStream = &std::cout;
    
    static bool defaultAddMass = false;
    static v3D defaultAddMassVcm = { 0.0, 0.0, 0.0 };
    static v3D defaultAddMassWcm = { 0.0, 0.0, 0.0 };
 
    static Point2D defaultInitDisplacement = { 0.0, 0.0 };
    static double defaultInitAngularDisplacement = 0.0;
    static Point2D defaultInitVelocity = {0.0, 0.0};
    static double defaultInitAngularVelocity = 0.0;
 
} //namespace defaults
 
 
namespace VMlib
{
 
    std::string CurrentDataTime();
 
 
    void PrintLogoToStream(std::ostream& str);
 
    void PrintUniversalLogoToStream(std::ostream& str);
 
 
    void PrintLogoToTextFile(std::ofstream& str, const std::string& fileName, const std::string& descr);
 
 
    void PrintHeaderToTextFile(std::ofstream& str, const std::string& header);
 
 
    template <typename T>
    std::ostream& operator<< (std::ostream& _stream, const std::vector<T>& _vec)
    {
        size_t n = _vec.size();
        _stream << "{ ";
        if (n > 0)
        {
            for (size_t j = 0; j < n - 1; ++j)
                _stream << _vec[j] << ", ";
            _stream << _vec[n - 1];
        }
        _stream << " }";
        return _stream;
    }//operator<<(...)
 
 
    inline std::ostream& operator<< (std::ostream& _stream, const std::pair<std::pair<std::string, int>, std::string>& _pair)
    {
        _stream << "( ( " << _pair.first.first << ", " << _pair.first.second << " ), " << _pair.second << " )"; 
        return _stream;
    }//operator<<(...)
 
 
    inline std::ostream& operator<< (std::ostream& _stream, const std::pair<std::string, int>& _pair)
    {
        _stream << "( " << _pair.first << ", " << _pair.second << " )";
        return _stream;
    }//operator<<(...)
 
 
 
    inline bool fileExistTest(std::string& fileName, LogStream& info, bool exitKey = false, const std::list <std::string>& extList = {})
    {
        std::list<std::string> fullExtList(extList);
        fullExtList.insert(fullExtList.begin(), "");
 
        for (const auto& ext : fullExtList)
        {
            std::string newFileName = ((ext == "") ? fileName : (fileName + "." + ext));
            std::ifstream f(newFileName.c_str());
            if (f.good())
            {
                f.close();
                f.clear();
 
                info('i') << "file " << newFileName << " is found" << std::endl;
                fileName = newFileName;
                return true;
            }
        }
 
        if (exitKey)
        {
            info('e') << "file " << fileName << " is not found" << std::endl;
            exit(-1);
        }
        else
            info('i') << "file " << fileName << " is not found" << std::endl;
 
        return false;
    }
 
 
    inline std::string fileNameStep(const std::string& name, int length, size_t number, const std::string& ext)
    {
        std::string fname(name);
 
        size_t dec = 1;
 
        for (int i = 1; i < length; ++i)
        {
            dec *= 10;
            if (number < dec)
                fname += "0";
        }
 
        std::ostringstream ss;
        ss << number;
        fname += ss.str();
        
        if (ext.size() > 0)
        {
            fname += ".";
            fname += ext;
        }
 
        return fname;
    }
 
 
    inline void copyFile(const std::string& fileNameFrom, const std::string& fileNameTo) 
    {
        std::string buf;
        buf.resize(BUFSIZ);
 
        FILE *in, *out;
        size_t n;
 
        
#pragma warning (push)
#pragma warning (disable: 4996)
        in = fopen(fileNameFrom.c_str(), "rb");
        out = fopen(fileNameTo.c_str(), "wb");
#pragma warning (pop)
 
        while ((n = fread((void*)buf.data(), 1, BUFSIZ, in)) != 0) 
        {
            fwrite((void*)buf.data(), 1, n, out);
        }
 
        std::fclose(in);
        std::fclose(out);
    }//copyFile
 
 
    inline void CreateUserDirectory(const std::string& dir, const std::string& name)
    {
#if defined(_WIN32)
        _mkdir((dir + name).c_str());
#else
        mkdir((dir + name).c_str(), S_IRWXU | S_IRGRP | S_IROTH);
#endif
    }
    
 
    template<typename T>
    inline T sqr(T x) { return x * x; }
 
    template<typename T>
    inline T cubPower(T x) { return x * x * x; }
 
 
    template <typename T>
    inline double macos(const T x)
    {
        double res = abs(x) > 1.0 ? 0.5*PI*(1 - sign(x)) : acos(x);
        return res;
    }
 
 
    template <typename T>
    int sign(T x)
    {
        double dx = (double)x;
        if (dx > 0) return 1;
        if ( (dx < 0.0) || (dx < -0.0) ) return -1;
        return 0;
    }
 
 
 
    void SaveToStream(const Eigen::MatrixXd& matr, std::ostream& str);
 
    void SaveToStream(const Eigen::MatrixXcd& matr, std::ostream& str);
 
    void SaveToStream(const Eigen::VectorXd& vec, std::ostream& str);
 
    void SaveToStream(const std::vector<Point2D>& vec, std::ostream& str);
 
    double M4(double t);
 
    void ModifyE2(double* ee2, double dst2);
 
 
    double Alpha(const Point2D& p, const Point2D& s);
 
    double Lambda(const Point2D& p, const Point2D& s);
 
    Point2D Omega(const Point2D& a, const Point2D& b, const Point2D& c);
 
    template<typename T>
    void SwapEnd(T& var)
    {
        char* varArray = reinterpret_cast<char*>(&var);
        for (long i = 0; i < static_cast<long>(sizeof(var) / 2); ++i)
            std::swap(varArray[sizeof(var) - 1 - i], varArray[i]);
    }
 
    inline double boundDenom(double r2, double eps2)
    {
#ifndef LAMBVORTEX
        return std::max(r2, eps2);
#else
        if (r2 > eps2)
            return std::max(r2, eps2);
        else
            return (r2 < 1e-10) ? 1e-10 : r2 / (1.0 - exp(-6.0*r2 / eps2));
#endif
    }
 
}//namespace VMlib
 
using VMlib::sqr;
using VMlib::cubPower;
 
#endif