VM2D::Velocity Class Reference

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

#include <Velocity2D.h>

Inheritance diagram for VM2D::Velocity:

Collaboration diagram for VM2D::Velocity:

Public Member Functions
	Velocity (const World2D &W_)
	Конструктор More...
virtual void	CalcConvVelo ()=0
	Вычисление конвективных скоростей вихрей и виртуальных вихрей в вихревом следе, а также в точках wakeVP. More...
virtual void	CalcVeloToWakeVP ()=0
	Вычисление скоростей в точках wakeVP. More...
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)
virtual void	CalcDiffVeloI1I2ToWakeFromSheets (const WakeDataBase &pointsDb, const std::vector< double > &domainRadius, const Boundary &bnd, std::vector< double > &I1, std::vector< Point2D > &I2)=0
virtual void	CalcDiffVeloI1I2ToWakeFromWake (const WakeDataBase &pointsDb, const std::vector< double > &domainRadius, const WakeDataBase &vorticesDb, std::vector< double > &I1, std::vector< Point2D > &I2)=0
void	CalcDiffVeloI1I2 ()
	Вычисление диффузионных скоростей вихрей и виртуальных вихрей в вихревом следе More...
void	CalcDiffVeloI0I3 ()
void	LimitDiffVelo (std::vector< Point2D > &diffVel)
	Контроль больших значений диффузионных скоростей More...
void	CalcDiffVelo ()
	Вычисление диффузионных скоростей More...
void	ResizeAndZero ()
	Очистка старых массивов под хранение скоростей, выделение новой памяти и обнуление More...
void	SaveVisStress ()
	Сохранение вязких напряжений More...
virtual void	FillRhs (Eigen::VectorXd &rhs) const =0
	Расчет вектора правой части (всего) More...
virtual	~Velocity ()
	Деструктор More...

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

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

Detailed Description

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

Author

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

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

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

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

Date

14 января 2024 г.

Definition at line 97 of file Velocity2D.h.

Constructor & Destructor Documentation

VM2D::Velocity::Velocity ( const World2D &  W_ )

inline

Конструктор

Parameters

[in]

W_

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

Definition at line 114 of file Velocity2D.h.

                                    :
            W(W_)
        {
            virtualVortexesParams.resize(0);
        };

virtual VM2D::Velocity::~Velocity ( )

inlinevirtual

Деструктор

Definition at line 180 of file Velocity2D.h.

{ };

Member Function Documentation

virtual void VM2D::Velocity::CalcConvVelo ( )

pure virtual

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

Warning

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

Implemented in VM2D::VelocityBiotSavart.

void Velocity::CalcDiffVelo

(

)

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

Вызывается в 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

(

)

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

(

)

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

Вызывает 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
	)

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
	)

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

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:

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

pure virtual

Implemented in VM2D::VelocityBiotSavart.

Here is the caller graph for this function:

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

pure virtual

Implemented in VM2D::VelocityBiotSavart.

Here is the caller graph for this function:

virtual void VM2D::Velocity::CalcVeloToWakeVP ( )

pure virtual

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

Implemented in VM2D::VelocityBiotSavart.

virtual void VM2D::Velocity::FillRhs ( Eigen::VectorXd &  rhs ) const

pure virtual

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

Implemented in VM2D::VelocityBiotSavart.

void Velocity::LimitDiffVelo

(

std::vector< Point2D > &

diffVel

)

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

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

(

)

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

Вызывается в 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

(

)

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

Вызывается в 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

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

Definition at line 108 of file Velocity2D.h.

const World2D& VM2D::Velocity::W

protected

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

Definition at line 101 of file Velocity2D.h.

VortexesParams VM2D::Velocity::wakeVortexesParams

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

Definition at line 105 of file Velocity2D.h.

---

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

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