World2D.h

Go to the documentation of this file.

/*--------------------------------*- VM2D -*-----------------*---------------*\
| ##  ## ##   ##  ####  #####   |                            | Version 1.12   |
| ##  ## ### ### ##  ## ##  ##  |  VM2D: Vortex Method       | 2024/01/14     |
| ##  ## ## # ##    ##  ##  ##  |  for 2D Flow Simulation    *----------------*
|  ####  ##   ##   ##   ##  ##  |  Open Source Code                           |
|   ##   ##   ## ###### #####   |  https://www.github.com/vortexmethods/VM2D  |
|                                                                             |
| Copyright (C) 2017-2024 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 "Times2D.h"
#include "WorldGen.h"

namespace VM2D
{
    class Airfoil;
    class Boundary;
    class MeasureVP;
    class Mechanics;
    class Passport;
    class Times;
    class Velocity; 
    class Wake;
    class WakeDataBase;

    class World2D : public VMlib::WorldGen
    {
    private:
        std::vector<std::unique_ptr<Airfoil>> airfoil;

        std::vector<std::unique_ptr<Airfoil>> 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:
    
    private:
        Eigen::MatrixXd matr;

        std::vector<std::vector<std::pair<Eigen::MatrixXd, Eigen::MatrixXd>>> IQ;

        Eigen::MatrixXd invMatr;

        bool useInverseMatrix;

        Eigen::VectorXd rhs;

        Eigen::VectorXd sol;

        const Passport& passport;

        mutable Gpu cuda;

    public:
        const Airfoil& getAirfoil(size_t i) const { return *airfoil[i]; };

        const Airfoil& 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 Wake& getWake() const { return *wake; };

        Wake& getNonConstWake() const { return *wake; };

        const WakeDataBase& getSource() const { return *source; };

        const Velocity& getVelocity() const { return *velocity; };
                
        Velocity& getNonConstVelocity() const { return *velocity; };

        const Passport& getPassport() const { return 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]; };

        Times& getTimestat() const { return dynamic_cast<Times&>(*timestat); };

        bool ifDivisible(int val) const { return ((val > 0) && (!(currentStep % val))); };

        void SolveLinearSystem();

        void FillIQ();

        void FillMatrixAndRhs();

        void ReserveMemoryForMatrixAndRhs();

        void CalcVortexVelo(bool shiftTime);

        void CalcPanelsVeloAndAttachedSheets();
        
        void CalcAndSolveLinearSystem();

        void MoveVortexes(std::vector<Point2D>& newPos);

        void CheckInside(std::vector<Point2D>& newPos, const std::vector<std::unique_ptr<Airfoil>>& oldAirfoil);

        void WakeAndAirfoilsMotion();


        World2D(const VMlib::PassportGen& passport_);

        ~World2D() { };
        
        void GenerateMechanicsHeader(size_t mechanicsNumber);



        // Реализация виртуальных функций
        virtual void Step() override;
        //virtual void ZeroStep() override;
    };

}//namespace VM2D

#endif