World2D.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: World2D.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 WORLD2D_H
#define WORLD2D_H
 
#include "Gpu2D.h"
#include "WorldGen.h"
#include "Passport2D.h"
#include "Velocity2D.h"
#include "cpuTreeInfo.h"
 
 
namespace VM2D
{
    class Airfoil;
    class AirfoilGeometry;
    class Boundary;
    class MeasureVP;
    class Mechanics;
    class Passport;
    class Times;
    class TimersGen;
    class Velocity; 
    class Wake;
    class WakeDataBase;
    class GmresSolver;
 
    class World2D : public VMlib::WorldGen
    {
    private:
        std::vector<std::unique_ptr<Airfoil>> airfoil;
 
        std::vector<std::unique_ptr<AirfoilGeometry>> oldAirfoil;
 
        std::vector<std::unique_ptr<Boundary>> boundary;
 
        std::vector<size_t> dispBoundaryInSystem;
 
        std::vector<std::unique_ptr<Mechanics>> mechanics;
 
        std::unique_ptr<Velocity> velocity;
 
        std::unique_ptr<Wake> wake;
 
        std::unique_ptr<WakeDataBase> source;
 
        std::unique_ptr<MeasureVP> measureVP;
 
public: 
        mutable int gabb;
        mutable int check01;
        mutable int check02;
        mutable int checkPan;
 
        std::unique_ptr<CpuTreeInfo> inflTreeWake;
        std::unique_ptr<CpuTreeInfo> cntrTreeWake;
        std::unique_ptr<CpuTreeInfo> cntrTreeVP;
        std::unique_ptr<CpuTreeInfo> cntrTreePnl;
 
        //для вспомогательных операций
        std::unique_ptr<CpuTreeInfo> auxTreePnl;
    private:
        Eigen::MatrixXd matrReord;
 
        std::vector<std::vector<std::pair<Eigen::MatrixXd, Eigen::MatrixXd>>> IQ;
 
        Eigen::MatrixXd invMatr;
 
        bool useInverseMatrix;
 
        Eigen::VectorXd rhsReord;
 
        Eigen::VectorXd sol;
 
        const Passport& passport;
 
        mutable Gpu cuda;
 
    public:
 
        Point2D getV0() const
        {
            return passport.physicalProperties.V0(getCurrentTime());
        }
 
        bool isAnyMovable() const;
 
        bool isAnyMovableOrDeformable() const;
 
        const Airfoil& getAirfoil(size_t i) const { return *airfoil[i]; };
 
        const AirfoilGeometry& getOldAirfoil(size_t i) const { return *oldAirfoil[i]; };
 
        Airfoil& getNonConstAirfoil(size_t i) const { return *airfoil[i]; };
 
        size_t getNumberOfAirfoil() const { return airfoil.size(); };
 
        const Boundary& getBoundary(size_t i) const { return *boundary[i]; };
 
        Boundary& getNonConstBoundary(size_t i) const { return *boundary[i]; };
 
        size_t getNumberOfBoundary() const { return boundary.size(); };
 
        size_t getDispBoundaryInSystem(size_t i) const { return dispBoundaryInSystem[i]; };
 
        const MeasureVP& getMeasureVP() const { return *measureVP; };
 
        MeasureVP& getNonConstMeasureVP() const { return *measureVP; };
 
        const Mechanics& getMechanics(size_t i) const { return *mechanics[i]; };
 
        Mechanics& getNonConstMechanics(size_t i) const { return *mechanics[i]; };
 
        const std::vector<std::unique_ptr<Mechanics>>& getMechanicsVector() const { return mechanics; };
 
        const Wake& getWake() const { return *wake; };
 
        Wake& getNonConstWake() const { return *wake; };
 
        CpuTreeInfo& getInflTreeWake() const { return *inflTreeWake; };
        CpuTreeInfo& getCntrTreeWake() const { return *cntrTreeWake; };
        CpuTreeInfo& getAuxTreePnl() const { return *auxTreePnl; };
        CpuTreeInfo& getCntrTreeVP() const { return *cntrTreeVP; };
        CpuTreeInfo& getCntrTreePnl() const { return *cntrTreePnl; }
 
        const WakeDataBase& getSource() const { return *source; };
 
        const Velocity& getVelocity() const { return *velocity; };
 
        Velocity& getNonConstVelocity() const { return *velocity; };
 
        const Passport& getPassport() const { return passport; };
 
        Passport& getNonConstPassport() const { return const_cast<Passport&>(passport); };
 
        const Gpu& getCuda() const { return cuda; };
 
        Gpu& getNonConstCuda() const { return cuda; };
 
        const std::pair<Eigen::MatrixXd, Eigen::MatrixXd>& getIQ(size_t i, size_t j) const { return IQ[i][j]; };
 
        VMlib::TimersGen& getTimers() const { return *timers; };
 
        bool ifDivisible(int val) const { return ((val > 0) && (!(currentStep % val))); };
 
        void SolveLinearSystem();
 
        void FillIQ();
 
        void FillMatrixAndRhs();
 
        void ReserveMemoryForMatrixAndRhs();
 
        void CalcVortexVelo();
#ifdef TURB
        void CalcVeloDifference(std::vector<double>& nut) const;
#endif
        void CalcPanelsVeloAndAttachedSheets();
 
        void CalcAndSolveLinearSystem();
 
        void MoveVortexes(std::vector<Point2D>& newPos, std::vector<double>* nutPtr = nullptr);
 
        void CheckInside(std::vector<Point2D>& newPos, const std::vector<std::unique_ptr<AirfoilGeometry>>& oldAirfoil);
 
        void WakeAndAirfoilsMotion(bool dynamics, std::vector<double>* nutPtr = nullptr);
 
 
        World2D(const VMlib::PassportGen& passport_);
 
        ~World2D() {};
 
        void GenerateMechanicsHeader(size_t mechanicsNumber);
 
 
 
        // Реализация виртуальных функций
        virtual void Step() override;
        //virtual void ZeroStep() override;
 
        VMlib::vmTimer timerInitialBuild;
        VMlib::vmTimer timerRhs;
        VMlib::vmTimer timerFillMatrix;
        VMlib::vmTimer timerSlaeSolve;
 
        VMlib::vmTimer timerConvVelo;
        VMlib::vmTimer timerInside;
        VMlib::vmTimer timerMerging;
    };
 
}//namespace VM2D
 
#endif