VM2D::VelocityBiotSavart Class Reference

Класс, определяющий способ вычисления скоростей More...

#include <Velocity2DBiotSavart.h>

Inheritance diagram for VM2D::VelocityBiotSavart:

Collaboration diagram for VM2D::VelocityBiotSavart:

Public Member Functions
	VelocityBiotSavart (const World2D &W_)
	Конструктор More...
virtual	~VelocityBiotSavart ()
	Деструктор More...
void	CalcConvVeloToSetOfPointsFromWake (const WakeDataBase &pointsDb, std::vector< Point2D > &velo, std::vector< double > &domainRadius, bool calcVelo, bool calcRadius)
	Вычисление конвективных скоростей и радиусов вихревых доменов в заданном наборе точек от следа More...
virtual void	CalcConvVelo () override
	Вычисление конвективных скоростей вихрей и виртуальных вихрей в вихревом следе, а также в точках wakeVP. More...
virtual void	FillRhs (Eigen::VectorXd &rhs) const override
	Расчет вектора правой части (всего) More...
virtual void	CalcVeloToWakeVP () override
	Вычисление скоростей в точках wakeVP. More...
void	GetWakeInfluenceToRhs (const Airfoil &afl, std::vector< double > &wakeRhs) const
	Генерация вектора влияния вихревого следа на профиль More...
void	CalcDiffVeloI1I2ToWakeFromSheets (const WakeDataBase &pointsDb, const std::vector< double > &domainRadius, const Boundary &bnd, std::vector< double > &I1, std::vector< Point2D > &I2) override
void	CalcDiffVeloI1I2ToWakeFromWake (const WakeDataBase &pointsDb, const std::vector< double > &domainRadius, const WakeDataBase &vorticesDb, std::vector< double > &I1, std::vector< Point2D > &I2) override
void	CalcDiffVeloI1I2ToSetOfPointsFromWake (const WakeDataBase &pointsDb, const std::vector< double > &domainRadius, const WakeDataBase &vorticesDb, std::vector< double > &I1, std::vector< Point2D > &I2)
	Вычисление числителей и знаменателей диффузионных скоростей в заданном наборе точек More...
void	CalcDiffVeloI1I2ToSetOfPointsFromSheets (const WakeDataBase &pointsDb, const std::vector< double > &domainRadius, const Boundary &bnd, std::vector< double > &I1, std::vector< Point2D > &I2)
void	CalcDiffVeloI1I2 ()
	Вычисление диффузионных скоростей вихрей и виртуальных вихрей в вихревом следе More...
void	CalcDiffVeloI0I3 ()
void	LimitDiffVelo (std::vector< Point2D > &diffVel)
	Контроль больших значений диффузионных скоростей More...
void	CalcDiffVelo ()
	Вычисление диффузионных скоростей More...
void	ResizeAndZero ()
	Очистка старых массивов под хранение скоростей, выделение новой памяти и обнуление More...
void	SaveVisStress ()
	Сохранение вязких напряжений More...

Public Attributes
VortexesParams	wakeVortexesParams
	Струтура, определяющая параметры вихрей в следе More...
std::vector< VortexesParams >	virtualVortexesParams
	Вектор струтур, определяющий параметры виртуальных вихрей для профилей More...

Protected Attributes
const World2D &	W
	Константная ссылка на решаемую задачу More...

Detailed Description

Класс, определяющий способ вычисления скоростей

Способ вычисления скоростей

• напрямую по закону Био — Савара

Author

Марчевский Илья Константинович

Сокол Ксения Сергеевна

Рятина Евгения Павловна

Колганова Александра Олеговна

\Version 1.12
\date 14 января 2024 г.

Definition at line 64 of file Velocity2DBiotSavart.h.

Constructor & Destructor Documentation

VelocityBiotSavart::VelocityBiotSavart

(

const World2D &

W_

)

Конструктор

Parameters

[in]

W_

константная ссылка на решаемую задачу

Definition at line 58 of file Velocity2DBiotSavart.cpp.

                                                        :
    Velocity(W_)
{
};

VelocityBiotSavart::~VelocityBiotSavart ( )

virtual

Деструктор

Definition at line 64 of file Velocity2DBiotSavart.cpp.

{   
};

Member Function Documentation

void VelocityBiotSavart::CalcConvVelo ( )

overridevirtual

Вычисление конвективных скоростей вихрей и виртуальных вихрей в вихревом следе, а также в точках wakeVP.

Warning

скорости приплюсовываются к уже имеющимся

Implements VM2D::Velocity.

Definition at line 69 of file Velocity2DBiotSavart.cpp.

{
    //const int checkStep = 3;


    double tt1 = omp_get_wtime();
    
    W.getTimestat().timeCalcVortexConvVelo.first += omp_get_wtime();
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_CONV_TOWAKE)) 
    //if (W.getCurrentStep() == checkStep)
    GPUWakeToWakeFAST(W.getWake(), wakeVortexesParams.convVelo, wakeVortexesParams.epsastWake, true, true);
    //else
    //GPUCalcConvVeloToSetOfPointsFromWake(W.getWake(), wakeVortexesParams.convVelo, wakeVortexesParams.epsastWake, true, true);    
#else
    CalcConvVeloToSetOfPointsFromWake(W.getWake(), wakeVortexesParams.convVelo, wakeVortexesParams.epsastWake, true, true);
#endif
    



    double tt2 = omp_get_wtime();


/*
    if (W.getCurrentStep() == checkStep)
    {
        std::ofstream pos("checkPos.txt");
        pos.precision(17);
        pos << W.getWake().vtx.size() << std::endl;
        for (int i = 0; i < W.getWake().vtx.size(); ++i)
            pos  << W.getWake().vtx[i].r()[0] << " " << W.getWake().vtx[i].r()[1] << " " << W.getWake().vtx[i].g() << std::endl;
        pos.close();

        std::ofstream of("checkVelo.txt");
        of.precision(16);
        for (int i = 0; i < wakeVortexesParams.convVelo.size(); ++i)
            of << i << " " << wakeVortexesParams.convVelo[i][0] << " " << wakeVortexesParams.convVelo[i][1] << " " \
            << wakeVortexesParams.epsastWake[i] << std::endl;
        of.close();
        exit(100500);
    }
*/

    //W.getInfo('t') << "Convective velocities time = " << int(((tt2 - tt1) * 1000)*10) / 10.0 << " ms, bodies = " << W.getWake().vtx.size() << std::endl;


    std::vector<Point2D> nullVector(0);

    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_CONV_TOBOU))  
        GPUCalcConvVeloToSetOfPointsFromWake(W.getBoundary(bou).virtualWake, nullVector, virtualVortexesParams[bou].epsastWake, false, true);
#else
        CalcConvVeloToSetOfPointsFromWake(W.getBoundary(bou).virtualWake, nullVector, virtualVortexesParams[bou].epsastWake, false, true);
#endif
    }
    
    //double tt3 = omp_get_wtime();

//вычисление конвективных скоростей по закону Био-Савара от виртуальных вихрей
    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
        //Влияние на пелену от виртуальных вихрей
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_CONVVIRT))
        W.getBoundary(bou).GPUCalcConvVelocityToSetOfPointsFromSheets(W.getWake(), wakeVortexesParams.convVelo);
#else
        W.getBoundary(bou).CalcConvVelocityToSetOfPointsFromSheets(W.getWake(), wakeVortexesParams.convVelo);
#endif
    }
        
    //double tt4 = omp_get_wtime();

    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
        //Скороcти самих виртуальных вихрей
        W.getBoundary(bou).CalcConvVelocityAtVirtualVortexes(virtualVortexesParams[bou].convVelo);
    }

    //double tt5 = omp_get_wtime();

    //std::cout << tt2 - tt1 << " " << tt3 - tt2 << " " << tt4 - tt3 << " " << tt5 - tt4 << std::endl;

    W.getTimestat().timeCalcVortexConvVelo.second += omp_get_wtime();
    
    W.getTimestat().timeVP.first += omp_get_wtime();

    //вычисление скоростей в заданных точках только на соответствующем шаге по времени
    if ((W.getPassport().timeDiscretizationProperties.saveVPstep > 0) && (!(W.getCurrentStep() % W.getPassport().timeDiscretizationProperties.saveVPstep)))
        CalcVeloToWakeVP(); 
    W.getTimestat().timeVP.second += omp_get_wtime();   
}//CalcConvVelo()

Here is the call graph for this function:

void VelocityBiotSavart::CalcConvVeloToSetOfPointsFromWake	(	const WakeDataBase &	pointsDb,
		std::vector< Point2D > &	velo,
		std::vector< double > &	domainRadius,
		bool	calcVelo,
		bool	calcRadius
	)

Вычисление конвективных скоростей и радиусов вихревых доменов в заданном наборе точек от следа

Parameters

[in]	pointsDb	константная ссылка на базу данных пелены из вихрей, в которых надо сосчитать конвективные скорости
[out]	velo	ссылка на вектор скоростей в требуемых точках
[out]	domainRadius	ссылка на вектор радиусов вихревых доменов
[in]	calcVelo	признак вычисления скоростей в точках
[in]	calcRadius	признак вычисления радиусов доменов

Definition at line 231 of file Velocity2DBiotSavart.cpp.

{
    std::vector<Point2D> selfVelo(pointsDb.vtx.size());
    domainRadius.resize(pointsDb.vtx.size());

    double cft = IDPI;

#pragma warning (push)
#pragma warning (disable: 4101)
    //Локальные переменные для цикла
    Point2D velI;
    Point2D tempVel;
    double dst2eps, dst2;   
#pragma warning (pop)

    double eps2 = W.getPassport().wakeDiscretizationProperties.eps2;
    
    if (calcVelo)
    {
#pragma omp parallel for default(none) shared(selfVelo, cft, calcVelo, calcRadius, eps2, pointsDb, domainRadius) private(tempVel, velI, dst2, dst2eps) schedule(dynamic, DYN_SCHEDULE)
        for (int i = 0; i < pointsDb.vtx.size(); ++i)
        {
            double ee2[3] = { 10000.0, 10000.0, 10000.0 };

            velI.toZero();

            const Point2D& posI = pointsDb.vtx[i].r();

            for (size_t j = 0; j < W.getWake().vtx.size(); ++j)
            {
                const Point2D& posJ = W.getWake().vtx[j].r();

                dst2 = (posI-posJ).length2();

                //Модифицируем массив квадратов расстояний до ближайших вихрей из wake
#ifndef TESTONLYVELO
                if (calcRadius)
                    VMlib::ModifyE2(ee2, dst2);
#endif // !TESTONLYVELO             

                const double& gamJ = W.getWake().vtx[j].g();

                tempVel.toZero();
                dst2eps = VMlib::boundDenom(dst2, eps2); //Сглаживать надо!!!               

                tempVel = { -posI[1] + posJ[1], posI[0] - posJ[0] };
                tempVel *= (gamJ / dst2eps);
                velI += tempVel;
            }
            
            for (size_t j = 0; j < W.getSource().vtx.size(); ++j)
            {
                const Point2D& posJ = W.getSource().vtx[j].r();
                const double& gamJ = W.getPassport().physicalProperties.accelCft() * W.getSource().vtx[j].g();

                tempVel.toZero();

                dst2 = dist2(posI, posJ);
                dst2eps = VMlib::boundDenom(dst2, W.getPassport().wakeDiscretizationProperties.eps2); //Сглаживать надо!!!

                tempVel = { posI[0] - posJ[0], posI[1] - posJ[1] };
                tempVel *= (gamJ / dst2eps);
                velI += tempVel;
            }
#ifndef TESTONLYVELO
            if (calcRadius)
            {
                for (size_t s = 0; s < W.getNumberOfBoundary(); ++s)
                {
                    const auto& bou = W.getBoundary(s);
                    //Модифицируем массив квадратов расстояний до ближайших вихрей из virtualWake                   
                    for (size_t j = 0; j < bou.virtualWake.vtx.size(); ++j)                     
                        ModifyE2(ee2, dist2(posI, bou.virtualWake.vtx[j].r()));         
                }
            }
#endif

            velI *= cft;
            selfVelo[i] = velI;

#ifndef TESTONLYVELO
            if (calcRadius)
                domainRadius[i] = 1.0 * sqrt((ee2[0] + ee2[1] + ee2[2]) / 3.0);
#endif
        }
    }
    else if (calcRadius)
    {
#pragma omp parallel for default(none) shared(selfVelo, cft, calcVelo, calcRadius, pointsDb, domainRadius) private(tempVel, velI, dst2) schedule(dynamic, DYN_SCHEDULE)
        for (int i = 0; i < pointsDb.vtx.size(); ++i)
        {
            double ee2[3] = { 10000.0, 10000.0, 10000.0 };

            velI.toZero();

            const Point2D& posI = pointsDb.vtx[i].r();

            for (size_t j = 0; j < W.getWake().vtx.size(); ++j)
            {
                const Point2D& posJ = W.getWake().vtx[j].r();

                dst2 = dist2(posI, posJ);

                //Модифицируем массив квадратов расстояний до ближайших вихрей из wake
                VMlib::ModifyE2(ee2, dst2);             
            }

            for (size_t s = 0; s < W.getNumberOfBoundary(); ++s)
            {
                for (size_t j = 0; j < W.getBoundary(s).virtualWake.vtx.size(); ++j)
                {
                    const Point2D& posJ = W.getBoundary(s).virtualWake.vtx[j].r();
                    dst2 = dist2(posI, posJ);

                    //Модифицируем массив квадратов расстояний до ближайших вихрей из virtualWake
                    ModifyE2(ee2, dst2);
                    /*
                    if (dst2 < ee2[0])
                    {
                        size_t pnl = W.getBoundary(s).virtualWake.aflPan[j].second;
                        ee2[0] = ee2[1] = ee2[2] = 0.5 * W.getBoundary(s).afl.len[pnl] / (W.getBoundary(s).vortexBeginEnd[pnl].second - W.getBoundary(s).vortexBeginEnd[pnl].first);                        
                    }
                    else
                        ModifyE2(ee2, dst2);
                    */

                }
            }

            domainRadius[i] = 1.0 * sqrt((ee2[0] + ee2[1] + ee2[2]) / 3.0);
        }
    } //else


    if (calcVelo)
        for (size_t i = 0; i < velo.size(); ++i)
            velo[i] += selfVelo[i];
}//CalcConvVeloToSetOfPointsFromWake(...)

Here is the call graph for this function:

Here is the caller graph for this function:

void Velocity::CalcDiffVelo ( )

inherited

Вычисление диффузионных скоростей

Вызывается в CalcVortexVelo()

omp

Definition at line 253 of file Velocity2D.cpp.

{
    W.getTimestat().timeCalcVortexDiffVelo.first += omp_get_wtime();

    double t12start, t12finish;
    double t03start, t03finish;
    double tOtherstart, tOtherfinish;

    if (W.getPassport().physicalProperties.nu > 0.0)
    {
        t12start = omp_get_wtime();
        CalcDiffVeloI1I2();
        t12finish = omp_get_wtime();

        t03start = omp_get_wtime();
        CalcDiffVeloI0I3();
        t03finish = omp_get_wtime();

        //контроль застрелов диффузионной скорости
        tOtherstart = omp_get_wtime();
        LimitDiffVelo(wakeVortexesParams.diffVelo);

        for (size_t bou = 0; bou < virtualVortexesParams.size(); ++bou)
            LimitDiffVelo(virtualVortexesParams[bou].diffVelo);
    
        
        for (size_t afl = 0; afl < W.getNumberOfAirfoil(); ++afl)
            for (size_t i = 0; i < W.getAirfoil(afl).viscousStress.size(); ++i)
                W.getNonConstAirfoil(afl).viscousStress[i] *= W.getPassport().physicalProperties.nu;

        SaveVisStress();
        tOtherfinish = omp_get_wtime();

    }
    W.getTimestat().timeCalcVortexDiffVelo.second += omp_get_wtime();

    //W.getInfo('t') << "diff_whole = " << W.getTimestat().timeCalcVortexDiffVelo.second - W.getTimestat().timeCalcVortexDiffVelo.first << std::endl;
    //W.getInfo('t') << "diff_I12   = " << t12finish - t12start << std::endl;
    //W.getInfo('t') << "diff_I03   = " << t03finish - t03start << std::endl;
    //W.getInfo('t') << "diff_other = " << tOtherfinish - tOtherstart << std::endl;


}// CalcDiffVelo()

Here is the call graph for this function:

void Velocity::CalcDiffVeloI0I3 ( )

inherited

Definition at line 165 of file Velocity2D.cpp.

{
    for (size_t afl = 0; afl < W.getNumberOfAirfoil(); ++afl)
    {
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_I0I3))        
        if (W.getPassport().numericalSchemes.velocityComputation.second == 0)
        {
            double tt1 = omp_get_wtime();
            W.getNonConstAirfoil(afl).GPUGetDiffVelocityI0I3ToSetOfPointsAndViscousStresses(W.getWake(), wakeVortexesParams.epsastWake, wakeVortexesParams.I0, wakeVortexesParams.I3);
            double tt2 = omp_get_wtime();
            //W.getInfo('t') << "I03_bou->wake  = " << (tt2 - tt1) << std::endl;
        }
        else
            W.getNonConstAirfoil(afl).GetDiffVelocityI0I3ToWakeAndViscousStresses(W.getWake(), wakeVortexesParams.epsastWake, wakeVortexesParams.I0, wakeVortexesParams.I3);
#else
        W.getNonConstAirfoil(afl).GetDiffVelocityI0I3ToWakeAndViscousStresses(W.getWake(), wakeVortexesParams.epsastWake, wakeVortexesParams.I0, wakeVortexesParams.I3);        
#endif
    }   

    //Порядок циклов именно такой, т.к. CUDA оптимизирует вызов ядер, 
    //и на один "слой" виртуальных вихрей считается влияние сразу от всех профилей
    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
        for (size_t afl = 0; afl < W.getNumberOfAirfoil(); ++afl)
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_I0I3))
        {
            double tt1 = omp_get_wtime();
            W.getNonConstAirfoil(afl).GPUGetDiffVelocityI0I3ToSetOfPointsAndViscousStresses(W.getBoundary(bou).virtualWake, virtualVortexesParams[bou].epsastWake, virtualVortexesParams[bou].I0, virtualVortexesParams[bou].I3);
            double tt2 = omp_get_wtime();
            //W.getInfo('t') << "I03_bou->layer = " << (tt2 - tt1) << std::endl;
        }
#else
            W.getNonConstAirfoil(afl).GetDiffVelocityI0I3ToSetOfPointsAndViscousStresses(W.getBoundary(bou).virtualWake, virtualVortexesParams[bou].epsastWake, virtualVortexesParams[bou].I0, virtualVortexesParams[bou].I3);
#endif          
    }
    //влияние поверхности
    Point2D I3;
    double I0;

    double domrad = 0.0;

#pragma omp parallel for private(I0, I3, domrad)
    for (int vt = 0; vt < (int)wakeVortexesParams.diffVelo.size(); ++vt)
    {
        domrad = std::max(wakeVortexesParams.epsastWake[vt], W.getPassport().wakeDiscretizationProperties.getMinEpsAst());

        wakeVortexesParams.I0[vt] *= domrad;
        wakeVortexesParams.I0[vt] += DPI * sqr(domrad);

        I3 = wakeVortexesParams.I3[vt];
        I0 = wakeVortexesParams.I0[vt];

        if (fabs(I0) > 1.e-8)
            wakeVortexesParams.diffVelo[vt] += I3 * (1.0 / I0);
    }

    for (size_t targetBou = 0; targetBou < W.getNumberOfBoundary(); ++targetBou)
#pragma omp parallel for private(I0, I3, domrad)
        for (int vt = 0; vt < (int)virtualVortexesParams[targetBou].diffVelo.size(); ++vt)
        {
            domrad = std::max(virtualVortexesParams[targetBou].epsastWake[vt], W.getPassport().wakeDiscretizationProperties.getMinEpsAst());

            virtualVortexesParams[targetBou].I0[vt] *= domrad;
            virtualVortexesParams[targetBou].I0[vt] += DPI * sqr(domrad);

            I3 = virtualVortexesParams[targetBou].I3[vt];
            I0 = virtualVortexesParams[targetBou].I0[vt];

            if (fabs(I0) > 1.e-8)
                virtualVortexesParams[targetBou].diffVelo[vt] += I3 * (1.0 / I0);
        }
}//CalcDiffVeloI0I3()

Here is the call graph for this function:

Here is the caller graph for this function:

void Velocity::CalcDiffVeloI1I2 ( )

inherited

Вычисление диффузионных скоростей вихрей и виртуальных вихрей в вихревом следе

Вызывает 4 раза функцию CalcDiffVeloToSetOfPoints

Warning

скорости приплюсовываются к уже имеющимся

Definition at line 56 of file Velocity2D.cpp.

{   
    // !!! пелена на пелену
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_I1I2))    
    if (W.getPassport().numericalSchemes.velocityComputation.second == 0)
    {
        double tt1 = omp_get_wtime();
        //GPUCalcDiffVeloI1I2ToSetOfPointsFromWake(W.getWake(), wakeVortexesParams.epsastWake, W.getWake(), wakeVortexesParams.I1, wakeVortexesParams.I2);
        GPUDiffVeloFAST(W.getWake(), wakeVortexesParams.epsastWake, W.getWake(), wakeVortexesParams.I1, wakeVortexesParams.I2);
        double tt2 = omp_get_wtime();

        //W.getInfo('t') << "Diffusive velocities time = " << int(((tt2 - tt1) * 1000) * 10) / 10.0 << " ms, bodies = " << W.getWake().vtx.size() << std::endl;
        //W.getInfo('t') << "I12_wake->wake   = " << (tt2 - tt1) << std::endl;

    }
    else
        CalcDiffVeloI1I2ToWakeFromWake(W.getWake(), wakeVortexesParams.epsastWake, W.getWake(), wakeVortexesParams.I1, wakeVortexesParams.I2);
#else
    CalcDiffVeloI1I2ToWakeFromWake(W.getWake(), wakeVortexesParams.epsastWake, W.getWake(), wakeVortexesParams.I1, wakeVortexesParams.I2);  
#endif

     
    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
        //не нужно, т.к. сделано выше перед началом вычисления скоростей
        //W.getNonConstBoundary(bou).virtualWake.WakeSynchronize();
        
        
    //виртуальные на границе на след
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_I1I2))                
        if (W.getPassport().numericalSchemes.velocityComputation.second == 0)
        {
            double tt1 = omp_get_wtime();
            GPUCalcDiffVeloI1I2ToSetOfPointsFromSheets(W.getWake(), wakeVortexesParams.epsastWake, W.getBoundary(bou), wakeVortexesParams.I1, wakeVortexesParams.I2);
            double tt2 = omp_get_wtime();
            //W.getInfo('t') << "I12_layer->wake  = " << (tt2 - tt1) << std::endl;
        }
        else
            CalcDiffVeloI1I2ToWakeFromSheets(W.getWake(), wakeVortexesParams.epsastWake, W.getBoundary(bou), wakeVortexesParams.I1, wakeVortexesParams.I2);
#else           
        CalcDiffVeloI1I2ToWakeFromSheets(W.getWake(), wakeVortexesParams.epsastWake, W.getBoundary(bou), wakeVortexesParams.I1, wakeVortexesParams.I2);
#endif  

    // !!! след на виртуальные      
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_I1I2))                    
        {
            double tt1 = omp_get_wtime();
            GPUCalcDiffVeloI1I2ToSetOfPointsFromWake(W.getBoundary(bou).virtualWake, virtualVortexesParams[bou].epsastWake, W.getWake(), virtualVortexesParams[bou].I1, virtualVortexesParams[bou].I2);
            double tt2 = omp_get_wtime();
            //W.getInfo('t') << "I12_wake->layer  = " << (tt2 - tt1) << std::endl;
        }
#else
        CalcDiffVeloI1I2ToSetOfPointsFromWake(W.getBoundary(bou).virtualWake, virtualVortexesParams[bou].epsastWake, W.getWake(), virtualVortexesParams[bou].I1, virtualVortexesParams[bou].I2);
#endif
        for (size_t targetBou = 0; targetBou < W.getNumberOfBoundary(); ++targetBou)
        {
        // виртуальные на виртуальные
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_I1I2))                
            {
                double tt1 = omp_get_wtime();
                GPUCalcDiffVeloI1I2ToSetOfPointsFromSheets(W.getBoundary(targetBou).virtualWake, virtualVortexesParams[targetBou].epsastWake, W.getBoundary(bou), virtualVortexesParams[targetBou].I1, virtualVortexesParams[targetBou].I2);
                double tt2 = omp_get_wtime();
                //W.getInfo('t') << "I12_layer->layer = " << (tt2 - tt1) << std::endl;
            }
#else           
            CalcDiffVeloI1I2ToSetOfPointsFromSheets(W.getBoundary(targetBou).virtualWake, virtualVortexesParams[targetBou].epsastWake, W.getBoundary(bou), virtualVortexesParams[targetBou].I1, virtualVortexesParams[targetBou].I2);
#endif  
        }   
        
    } //for bou
    
    
    double tDivstart, tDivfinish;

    Point2D I2;
    double I1;
    
    tDivstart = omp_get_wtime();

#pragma omp parallel for private(I1, I2)
    for (int vt = 0; vt < (int)wakeVortexesParams.diffVelo.size(); ++vt)
    {
        I2 = wakeVortexesParams.I2[vt];
        I1 = wakeVortexesParams.I1[vt];
        if (fabs(I1) < 1.e-8)
            wakeVortexesParams.diffVelo[vt] = { 0.0, 0.0 };
        else
            wakeVortexesParams.diffVelo[vt] = I2 * (1.0 / (I1 * std::max(wakeVortexesParams.epsastWake[vt], W.getPassport().wakeDiscretizationProperties.getMinEpsAst())));
    }   
    
    for (size_t targetBou = 0; targetBou < W.getNumberOfBoundary(); ++targetBou)
#pragma omp parallel for private(I1, I2)
    for (int vt = 0; vt < (int)virtualVortexesParams[targetBou].diffVelo.size(); ++vt)
    {
        I2 = virtualVortexesParams[targetBou].I2[vt];
        I1 = virtualVortexesParams[targetBou].I1[vt];

        if (fabs(I1) < 1.e-8)
            virtualVortexesParams[targetBou].diffVelo[vt] = { 0.0, 0.0 };
        else
            virtualVortexesParams[targetBou].diffVelo[vt] = I2 * (1.0 / (I1 * std::max(virtualVortexesParams[targetBou].epsastWake[vt], W.getPassport().wakeDiscretizationProperties.getMinEpsAst())));
    }

    tDivfinish = omp_get_wtime();
    //W.getInfo('t') << "I12_Div       = " << (tDivfinish - tDivstart) << std::endl;

}//CalcDiffVeloI1I2()

Here is the call graph for this function:

Here is the caller graph for this function:

void Velocity::CalcDiffVeloI1I2ToSetOfPointsFromSheets ( const WakeDataBase &  pointsDb, const std::vector< double > &  domainRadius, const Boundary &  bnd, std::vector< double > &  I1, std::vector< Point2D > &  I2  )

inherited

Todo:

Понять природу магической константы 8.0 и синхронизировать с GPU

Todo:

Сделать переменной и синхронизировать с GPU

Todo:

Учитываем пока только нулевой момент решения

Definition at line 365 of file Velocity2D.cpp.

{
    double tCPUSTART, tCPUEND;

    tCPUSTART = omp_get_wtime();

    std::vector<double> selfI1(pointsDb.vtx.size(), 0.0);
    std::vector<Point2D> selfI2(pointsDb.vtx.size(), { 0.0, 0.0 });

#pragma warning (push)
#pragma warning (disable: 4101)
    //Локальные переменные для цикла
    Point2D Rij;
    double rij, expr;
    double diffRadius;
    double left;
    double right;
    double posJx;
    double domRad;
#pragma warning (pop)


#pragma omp parallel for default(none) shared(selfI1, selfI2, domainRadius, bnd, pointsDb, std::cout) private(Rij, rij, expr, domRad, diffRadius, left, right, posJx)
    for (int i = 0; i < pointsDb.vtx.size(); ++i)
    {
        const Vortex2D& vtxI = pointsDb.vtx[i];

        domRad = std::max(domainRadius[i], W.getPassport().wakeDiscretizationProperties.getMinEpsAst());

        diffRadius = 8.0 * domRad;

        left = vtxI.r()[0] - diffRadius;
        right = vtxI.r()[0] + diffRadius;

        for (size_t j = 0; j < bnd.afl.getNumberOfPanels(); ++j)
        {
            const int nQuadPt = 3;

            const double ptG = bnd.sheets.freeVortexSheet(j, 0) * bnd.afl.len[j] / nQuadPt;

            for (int q = 0; q < nQuadPt; ++q)
            {
                const Point2D& ptJ = bnd.afl.getR(j) + bnd.afl.tau[j] * (q + 0.5) * bnd.afl.len[j] * (1.0 / nQuadPt);  // vorticesDb.vtx[j];
                posJx = ptJ[0];

                if ((left < posJx) && (posJx < right))
                {
                    Rij = vtxI.r() - ptJ;
                    rij = Rij.length();
                    if (rij < diffRadius && rij > 1.e-10)
                    {
                        expr = exp(-rij / domRad);
                        selfI2[i] += (ptG * expr / rij) * Rij;
                        selfI1[i] += ptG * expr;
                    }
                }//if (rij>1e-6)
            }
        }//for j
    } // for r

    for (size_t i = 0; i < I1.size(); ++i)
    {
        I1[i] += selfI1[i];
        I2[i] += selfI2[i];
    }

    tCPUEND = omp_get_wtime();
    //W.getInfo('t') << "DIFF_CPU: " << tCPUEND - tCPUSTART << std::endl;
}//CalcDiffVeloI1I2ToSetOfPointsFromSheets(...)

Here is the call graph for this function:

Here is the caller graph for this function:

void Velocity::CalcDiffVeloI1I2ToSetOfPointsFromWake ( const WakeDataBase &  pointsDb, const std::vector< double > &  domainRadius, const WakeDataBase &  vorticesDb, std::vector< double > &  I1, std::vector< Point2D > &  I2  )

inherited

Вычисление числителей и знаменателей диффузионных скоростей в заданном наборе точек

Parameters

[in]	pointsDb	константная ссылка на базу данных пелены из вихрей, в которых надо сосчитать диффузионные скорости
[in]	domainRadius	константная ссылка на вектор радиусов вихревых доменов
[in]	vorticesDb	константная ссылка на на базу данных пелены из вихрей,от которых надо сосчитать влияния на points
[out]	I1	ссылка на вектор величин I1 (знаменателей в диффузионных скоростях) в требуемых точках
[out]	I2	ссылка на вектор величин I2 (числителей в диффузионных скоростях) в требуемых точках

Todo:

Понять природу магической константы 8.0 и синхронизировать с GPU

Definition at line 300 of file Velocity2D.cpp.

{
    double tCPUSTART, tCPUEND;

    tCPUSTART = omp_get_wtime();

    std::vector<double> selfI1(pointsDb.vtx.size(), 0.0);
    std::vector<Point2D> selfI2(pointsDb.vtx.size(), { 0.0, 0.0 }); 

#pragma warning (push)
#pragma warning (disable: 4101)
    //Локальные переменные для цикла
    Point2D Rij;
    double rij, expr;
    double diffRadius, domRad;
    double left;
    double right;
    double posJx;
#pragma warning (pop)

#pragma omp parallel for default(none) shared(selfI1, selfI2, domainRadius, vorticesDb, pointsDb) private(Rij, rij, expr, diffRadius, domRad, left, right, posJx)
    for (int i = 0; i < pointsDb.vtx.size(); ++i)
    {
        const Vortex2D& vtxI = pointsDb.vtx[i];

        domRad = std::max(domainRadius[i], W.getPassport().wakeDiscretizationProperties.getMinEpsAst());

        diffRadius = 8.0 * domRad;

        left = vtxI.r()[0] - diffRadius;
        right = vtxI.r()[0] + diffRadius;

        for (size_t j = 0; j < vorticesDb.vtx.size(); ++j)
        {
            const Vortex2D& vtxJ = vorticesDb.vtx[j];
            posJx = vtxJ.r()[0];

            if ((left < posJx) && (posJx < right))
            {
                Rij = vtxI.r() - vtxJ.r();
                rij = Rij.length();
                if (rij < diffRadius && rij > 1.e-10)
                {
                    expr = exp(-rij / domRad);
                    selfI2[i] += (vtxJ.g()* expr / rij) * Rij;
                    selfI1[i] += vtxJ.g()*expr;
                }
            }//if (rij>1e-6)
        }//for j
    } // for r


    for (size_t i = 0; i < I1.size(); ++i)
    {
        I1[i] += selfI1[i];
        I2[i] += selfI2[i];
    }

    tCPUEND = omp_get_wtime();
    //W.getInfo('t') << "DIFF_CPU: " << tCPUEND - tCPUSTART << std::endl;
}//CalcDiffVeloI1I2ToSetOfPointsFromWake(...)

Here is the call graph for this function:

Here is the caller graph for this function:

void VelocityBiotSavart::CalcDiffVeloI1I2ToWakeFromSheets ( const WakeDataBase &  pointsDb, const std::vector< double > &  domainRadius, const Boundary &  bnd, std::vector< double > &  I1, std::vector< Point2D > &  I2  )

overridevirtual

Implements VM2D::Velocity.

Definition at line 972 of file Velocity2DBiotSavart.cpp.

{
    CalcDiffVeloI1I2ToSetOfPointsFromSheets(pointsDb, domainRadius, bnd, I1, I2);
}

void VelocityBiotSavart::CalcDiffVeloI1I2ToWakeFromWake ( const WakeDataBase &  pointsDb, const std::vector< double > &  domainRadius, const WakeDataBase &  vorticesDb, std::vector< double > &  I1, std::vector< Point2D > &  I2  )

overridevirtual

Implements VM2D::Velocity.

Definition at line 967 of file Velocity2DBiotSavart.cpp.

{
    CalcDiffVeloI1I2ToSetOfPointsFromWake(pointsDb, domainRadius, vorticesDb, I1, I2);
}//CalcDiffVeloI1I2ToWakeFromWake(...)

Here is the call graph for this function:

void VelocityBiotSavart::CalcVeloToWakeVP ( )

overridevirtual

Вычисление скоростей в точках wakeVP.

Implements VM2D::Velocity.

Definition at line 163 of file Velocity2DBiotSavart.cpp.

{
    std::vector<Point2D> velConvWake;
    std::vector<std::vector<Point2D>> velConvBou;

    int addWSize = (int)W.getMeasureVP().getWakeVP().vtx.size();

    velConvWake.resize(addWSize, { 0.0, 0.0 });

    velConvBou.resize(W.getNumberOfBoundary());
    for (size_t i = 0; i < W.getNumberOfBoundary(); ++i)
        velConvBou[i].resize(addWSize, { 0.0, 0.0 });

#if (defined(USE_CUDA))
    W.getNonConstCuda().RefreshVP();
#endif

#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_VP))
    GPUCalcConvVeloToSetOfPointsFromWake(W.getMeasureVP().getWakeVP(), velConvWake, W.getNonConstMeasureVP().getNonConstDomainRadius(), true, false);
#else
    CalcConvVeloToSetOfPointsFromWake(W.getMeasureVP().getWakeVP(), velConvWake, W.getNonConstMeasureVP().getNonConstDomainRadius(), true, false);
#endif             

    for (size_t i = 0; i < W.getNumberOfBoundary(); ++i)
#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_VP))      
        W.getNonConstBoundary(i).GPUCalcConvVelocityToSetOfPointsFromSheets(W.getMeasureVP().getWakeVP(), velConvBou[i]);
#else
        W.getNonConstBoundary(i).CalcConvVelocityToSetOfPointsFromSheets(W.getMeasureVP().getWakeVP(), velConvBou[i]);
#endif             

    std::vector<Point2D>& velocityRef = W.getNonConstMeasureVP().getNonConstVelocity();
    velocityRef.assign(addWSize, W.getPassport().physicalProperties.V0());

    for (int i = 0; i < addWSize; ++i)
        velocityRef[i] += velConvWake[i];

    for (size_t bou = 0; bou < velConvBou.size(); ++bou)
        for (int j = 0; j < addWSize; ++j)
            velocityRef[j] += velConvBou[bou][j];

}// CalcVeloToWakeVP()

Here is the call graph for this function:

Here is the caller graph for this function:

void VelocityBiotSavart::FillRhs ( Eigen::VectorXd &  rhs ) const

overridevirtual

Расчет вектора правой части (всего)

Implements VM2D::Velocity.

Definition at line 832 of file Velocity2DBiotSavart.cpp.

{
    Eigen::VectorXd locRhs;
    std::vector<double> lastRhs(W.getNumberOfBoundary());

    size_t currentRow = 0;

    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
        //double tt0 = omp_get_wtime();

        const Airfoil& afl = W.getAirfoil(bou);
        size_t np = afl.getNumberOfPanels();

        size_t nVars;

        nVars = W.getBoundary(bou).GetUnknownsSize();
        locRhs.resize(nVars);


        std::vector<double> wakeRhs;

        double tt1 = omp_get_wtime();

#if (defined(__CUDACC__) || defined(USE_CUDA)) && (defined(CU_RHS))
        //GPUGetWakeInfluenceToRhs(afl, wakeRhs);       
        GPUFASTGetWakeInfluenceToRhs(afl, wakeRhs);
        //GetWakeInfluenceToRhs(afl, wakeRhs);

#else
        GetWakeInfluenceToRhs(afl, wakeRhs);
#endif          


        double tt2 = omp_get_wtime();
        //W.getInfo('t') << "Rhs time = " << int(((tt2 - tt1) * 1000) * 10) / 10.0 << " ms, bodies = " << W.getWake().vtx.size() << std::endl;


        std::vector<double> vInfRhs;
        afl.GetInfluenceFromVInfToPanel(vInfRhs);

        /*
        //if (W.currentStep == 200)
        {
            std::stringstream ss;
            ss << "rhsWake-" << W.currentStep;
            std::ofstream of(W.getPassport().dir + "dbg/" + ss.str());
            for (size_t i = 0; i < wakeRhs.size(); ++i)
                of << wakeRhs[i] << std::endl;
            of.close();
        }
        */



#pragma omp parallel for \
    default(none) \
    shared(locRhs, afl, bou, wakeRhs, vInfRhs, np) \
    schedule(dynamic, DYN_SCHEDULE)
        for (int i = 0; i < (int)afl.getNumberOfPanels(); ++i)
        {
            locRhs(i) = -vInfRhs[i] - wakeRhs[i] + 0.25 * ((afl.getV(i) + afl.getV(i + 1)) & afl.tau[i]); //0.25 * (afl.getV(i) + afl.getV(i + 1))*afl.tau[i] - прямолинейные
            if (W.getBoundary(bou).sheetDim > 1)
                locRhs(np + i) = -vInfRhs[np + i] - wakeRhs[np + i];

            //влияние присоединенных слоев от самого себя и от других профилей              
            for (size_t q = 0; q < W.getNumberOfBoundary(); ++q)
            {
                const auto& sht = W.getBoundary(q).sheets;
                const auto& iq = W.getIQ(bou, q);

                const Airfoil& aflOther = W.getAirfoil(q);
                if (W.getMechanics(q).isDeform || W.getMechanics(q).isMoves)
                {
                    for (size_t j = 0; j < aflOther.getNumberOfPanels(); ++j)
                    {
                        if ((i != j) || (bou != q))
                        {
                            locRhs(i) += -iq.first(i, j) * sht.attachedVortexSheet(j, 0);
                            locRhs(i) += -iq.second(i, j) * sht.attachedSourceSheet(j, 0); // getIQ(bou, q).second(i, j) пока забито нулем для криволинейных
                        }//if (i != j)
                    }//for j
                }
            }//for q
        }//for i

        lastRhs[bou] = 0.0;

        for (size_t q = 0; q < afl.gammaThrough.size(); ++q)
            lastRhs[bou] += afl.gammaThrough[q];





        double dwcm; //wcm0, wcm1, wcmOld0, wcmOld1, dwc0, dwc1;
        const double currT = W.getPassport().timeDiscretizationProperties.currTime;
        const double dt = W.getPassport().timeDiscretizationProperties.dt;

        //wcm0 = W.getNonConstMechanics(bou).AngularVelocityOfAirfoil(currT);
        //wcmOld0 = W.getNonConstMechanics(bou).AngularVelocityOfAirfoil(currT - dt);
        //dwc0 = wcm0 - wcmOld0;

        dwcm = W.getNonConstMechanics(bou).AngularVelocityOfAirfoil(currT) - W.getNonConstMechanics(bou).AngularVelocityOfAirfoil(currT - dt);
        lastRhs[bou] += 2.0 * dwcm * W.getAirfoil(bou).area * (W.getAirfoil(bou).inverse ? 1.0 : -1.0);

        /*
        if (bou == 0)
        {
            lastRhs[bou] -= (2.0 * PI * 0.5) * dwc0 * 0.5;
        }

        if (bou == 1)
        {
            wcm1 = W.getNonConstMechanics(bou).AngularVelocityOfAirfoil(currT);
            wcmOld1 = W.getNonConstMechanics(bou).AngularVelocityOfAirfoil(currT - dt);
            dwc1 = wcm1 - wcmOld1;
            //std::cout << "dwc0,1 = " << dwc0 << " " << dwc1 << std::endl;
            lastRhs[bou] += (2.0 * PI * 1.0) * (dwc1) * 1.0;
        }
        */

        //размазываем правую часть      
        for (size_t i = 0; i < nVars; ++i)
            rhs(i + currentRow) = locRhs(i);

        rhs(currentRow + nVars) = lastRhs[bou];

        currentRow += nVars + 1;
    }// for bou
}

Here is the call graph for this function:

void VelocityBiotSavart::GetWakeInfluenceToRhs	(	const Airfoil &	afl,
		std::vector< double > &	wakeRhs
	)		const

Генерация вектора влияния вихревого следа на профиль

Генерирует вектор влияния вихревого следа на профиль, используемый затем для расчета вектора правой части.

Parameters

[in]	afl	константная ссылка на профиль, правая часть для которого вычисляется
[out]	wakeRhs	ссылка на вектор влияния вихревого следа на ОДИН профиль

Definition at line 641 of file Velocity2DBiotSavart.cpp.

{
    size_t np = afl.getNumberOfPanels();
    size_t shDim = W.getBoundary(afl.numberInPassport).sheetDim;

    wakeRhs.resize(W.getBoundary(afl.numberInPassport).GetUnknownsSize());

    //локальные переменные для цикла    
    std::vector<double> velI(shDim, 0.0);

#pragma omp parallel for default(none) shared(shDim, afl, np, wakeRhs, IDPI) private(velI)
    for (int i = 0; i < np; ++i)
    {
        velI.assign(shDim, 0.0);

        if (W.getWake().vtx.size() > 0)
        {
            //Учет влияния следа
            afl.GetInfluenceFromVorticesToPanel(i, W.getWake().vtx.data(), W.getWake().vtx.size(), velI);
        }

        if (W.getSource().vtx.size() > 0)
        {
            //Учет влияния источников
            afl.GetInfluenceFromSourcesToPanel(i, W.getSource().vtx.data(), W.getSource().vtx.size(), velI);
        }

        for (size_t j = 0; j < shDim; ++j)
            velI[j] *= IDPI / afl.len[i];

        wakeRhs[i] = velI[0];

        if (shDim != 1)
            wakeRhs[np + i] = velI[1];
    }//for i
}//GetWakeInfluenceToRhs(...)

Here is the call graph for this function:

Here is the caller graph for this function:

void Velocity::LimitDiffVelo ( std::vector< Point2D > &  diffVel )

inherited

Контроль больших значений диффузионных скоростей

Parameters

[in,out]

diffVel

ссылка на вектор диффузионных скоростей

Definition at line 239 of file Velocity2D.cpp.

{
    for (size_t i = 0; i < diffVel.size(); ++i)
    {
        Point2D& diffV = diffVel[i];

        diffV *= W.getPassport().physicalProperties.nu;

        if (diffV.length() > 1.5 * W.getPassport().physicalProperties.vRef)
            diffV.normalize(1.5 * W.getPassport().physicalProperties.vRef);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Velocity::ResizeAndZero ( )

inherited

Очистка старых массивов под хранение скоростей, выделение новой памяти и обнуление

Вызывается в CalcVortexVelo() на каждом шаге расчета перед непосредственно расчетом скоростей

Definition at line 661 of file Velocity2D.cpp.

{
    W.getTimestat().timeCalcVortexConvVelo.first += omp_get_wtime();
    wakeVortexesParams.convVelo.clear();
    wakeVortexesParams.convVelo.resize(W.getWake().vtx.size(), { 0.0, 0.0 });
    W.getTimestat().timeCalcVortexConvVelo.second += omp_get_wtime();

    W.getTimestat().timeCalcVortexDiffVelo.first += omp_get_wtime();
    wakeVortexesParams.I0.clear();
    wakeVortexesParams.I0.resize(W.getWake().vtx.size(), 0.0);

    wakeVortexesParams.I1.clear();
    wakeVortexesParams.I1.resize(W.getWake().vtx.size(), 0.0);

    wakeVortexesParams.I2.clear();
    wakeVortexesParams.I2.resize(W.getWake().vtx.size(), { 0.0, 0.0 });

    wakeVortexesParams.I3.clear();
    wakeVortexesParams.I3.resize(W.getWake().vtx.size(), { 0.0, 0.0 });

    wakeVortexesParams.diffVelo.clear();
    wakeVortexesParams.diffVelo.resize(W.getWake().vtx.size(), { 0.0, 0.0 });

    wakeVortexesParams.epsastWake.clear();
    wakeVortexesParams.epsastWake.resize(W.getWake().vtx.size(), 0.0);
    W.getTimestat().timeCalcVortexDiffVelo.second += omp_get_wtime();

    //Создаем массивы под виртуальные вихри
    W.getTimestat().timeCalcVortexConvVelo.first += omp_get_wtime();
    virtualVortexesParams.clear();
    virtualVortexesParams.resize(W.getNumberOfBoundary());
    W.getTimestat().timeCalcVortexConvVelo.second += omp_get_wtime();

    for (size_t bou = 0; bou < W.getNumberOfBoundary(); ++bou)
    {
        W.getTimestat().timeCalcVortexConvVelo.first += omp_get_wtime();
        virtualVortexesParams[bou].convVelo.clear();
        virtualVortexesParams[bou].convVelo.resize(W.getBoundary(bou).virtualWake.vtx.size(), { 0.0, 0.0 });
        W.getTimestat().timeCalcVortexConvVelo.second += omp_get_wtime();

        W.getTimestat().timeCalcVortexDiffVelo.first += omp_get_wtime();
        virtualVortexesParams[bou].I0.clear();
        virtualVortexesParams[bou].I0.resize(W.getBoundary(bou).virtualWake.vtx.size(), 0.0);

        virtualVortexesParams[bou].I1.clear();
        virtualVortexesParams[bou].I1.resize(W.getBoundary(bou).virtualWake.vtx.size(), 0.0);

        virtualVortexesParams[bou].I2.clear();
        virtualVortexesParams[bou].I2.resize(W.getBoundary(bou).virtualWake.vtx.size(), { 0.0, 0.0 });

        virtualVortexesParams[bou].I3.clear();
        virtualVortexesParams[bou].I3.resize(W.getBoundary(bou).virtualWake.vtx.size(), { 0.0, 0.0 });

        virtualVortexesParams[bou].diffVelo.clear();
        virtualVortexesParams[bou].diffVelo.resize(W.getBoundary(bou).virtualWake.vtx.size(), { 0.0, 0.0 });

        virtualVortexesParams[bou].epsastWake.clear();
        virtualVortexesParams[bou].epsastWake.resize(W.getBoundary(bou).virtualWake.vtx.size(), 0.0);

        W.getTimestat().timeCalcVortexDiffVelo.second += omp_get_wtime();
    }
}//ResizeAndZero()

Here is the call graph for this function:

void Velocity::SaveVisStress ( )

inherited

Сохранение вязких напряжений

Вызывается в CalcDiffVelo()

Definition at line 725 of file Velocity2D.cpp.

{
    if ((W.getPassport().timeDiscretizationProperties.saveVtxStep > 0) && (W.ifDivisible(W.getPassport().timeDiscretizationProperties.saveVisStress)))
        //      if ((W.getPassport().timeDiscretizationProperties.saveVTK > 0) && (W.ifDivisible(10)) && (W.getNumberOfAirfoil() > 0))
    {
        for (size_t q = 0; q < W.getNumberOfAirfoil(); ++q)
        {
            if (q == 0)
                VMlib::CreateDirectory(W.getPassport().dir, "visStress");

            std::stringstream ss;
            ss << "VisStress_" << q << "-";
            std::string fname = VMlib::fileNameStep(ss.str(), W.getPassport().timeDiscretizationProperties.nameLength, W.getCurrentStep(), "txt");
            std::ofstream outfile;
            outfile.open(W.getPassport().dir + "visStress/" + fname);

            outfile << W.getAirfoil(q).viscousStress.size() << std::endl; //Сохранение числа вихрей в пелене

            for (size_t i = 0; i < W.getAirfoil(q).viscousStress.size(); ++i)
            {
                const Point2D& r = 0.5 * (W.getAirfoil(q).getR(i + 1) + W.getAirfoil(q).getR(i));
                double gi = W.getAirfoil(q).viscousStress[i];
                outfile << static_cast<int>(i) << " " << r[0] << " " << r[1] << " " << gi << std::endl;
            }//for i    
            outfile.close();
        }
    }
}

Member Data Documentation

std::vector<VortexesParams> VM2D::Velocity::virtualVortexesParams

inherited

Вектор струтур, определяющий параметры виртуальных вихрей для профилей

Definition at line 108 of file Velocity2D.h.

const World2D& VM2D::Velocity::W

protectedinherited

Константная ссылка на решаемую задачу

Definition at line 101 of file Velocity2D.h.

VortexesParams VM2D::Velocity::wakeVortexesParams

inherited

Струтура, определяющая параметры вихрей в следе

Definition at line 105 of file Velocity2D.h.

---

The documentation for this class was generated from the following files:

• VM2D/Velocity2D/Velocity2DBiotSavart.h
• VM2D/Velocity2D/Velocity2DBiotSavart.cpp

• VM2D
• VelocityBiotSavart
• Generated by 1.8.11