defs.h

Go to the documentation of this file.

/*--------------------------------*- VMlib -*----------------*---------------*\
| ##  ## ##   ## ##   ##  ##    |                            | Version 1.12   |
| ##  ## ### ### ##       ##    |  VMlib: VM2D/VM3D Library  | 2024/01/14     |
| ##  ## ## # ## ##   ##  ####  |  Open Source Code          *----------------*
|  ####  ##   ## ##   ##  ## ## |  https://www.github.com/vortexmethods/VM2D  |
|   ##   ##   ## #### ### ####  |  https://www.github.com/vortexmethods/VM3D  |
|                                                                             |
| Copyright (C) 2017-2024 Ilia Marchevsky                                     |
*-----------------------------------------------------------------------------*
| File name: defs.h                                                           |
| Info: Source code of VMlib                                                  |
|                                                                             |
| This file is part of VMlib.                                                 |
| VMLib 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.                                         |
|                                                                             |
| VMlib 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 VMlib.  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 defaultNameLength = 5;

    const double defaultDistFar = 10.0;

    const double defaultDelta = 1.e-5;

    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> defaultPanelsType = { "panelsRectilinear", 0 };

    const std::pair<std::string, int> defaultBoundaryCondition = { "boundaryConstLayerAver", 0 };

    const std::pair<std::string, int> defaultLinearSystemSolver = { "linearSystemGauss", 0 };


    const std::pair<std::string, int> defaultVelocityComputation{ "velocityBiotSavart", 0 };

    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 = 1.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 };
} //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, 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;
            }
        }

        info('e') << "file " << fileName << " is not found" << std::endl;
        exit(-1);
        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);
        }
    }//copyFile


    inline void CreateDirectory(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 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;

#endif