fvOptions代码分析

最新推荐文章于 2023-08-19 19:24:36 发布
最新推荐文章于 2023-08-19 19:24:36 发布
阅读量4.2k 收藏 33
点赞数 10
分类专栏： 控制方程 文章标签： openfoam
hty
本文链接：https://blog.csdn.net/hanbingchegu/article/details/107160364
版权

OpenFOAM中的fvOptions是一个功能灵活的框架，可以在不重写原始源代码的情况下,在指定区域内向控制方程添加各种源项或者其他约束（比如固定温度、多孔介质、磁流变流体等）。

本质上，fvOptions类有一个公共函数AddSup。在这个函数中， eqn.source()用于设置源项，其中，当求解器创建IOOptionList时，eqn将显示为引用UEqn。使用eqn.psi()，fvOption类也可以访问当前速度，mesh_是基类选项提供的mesh数据库的引用。所以很容易得到动量源项，它取决于当前的速度场。

这里，我们以pisoFoam求解器为例，分析求解器中是怎么调用 fvOptions的。

#include "createFvOptions.H"//添加头文件createFvOptions.H

fvVectorMatrix UEqn
(
    fvm::ddt(U) + fvm::div(phi, U)
  + MRF.DDt(U)
  + turbulence->divDevReff(U)
 ==
    fvOptions(U)//UEqn在 RHS(right-hand side)上用==fvOptions（U）定义
);

fvOptions.correct(U);//对速度场进行修正

接下来，我们对以上添加部分做逐一分析。

文章目录

1.createFvOptions.H

fv::options& fvOptions(fv::options::New(mesh));

fvOptions是一个fv::options类对象的引用，New(mesh)是fv::options类中的一个静态static方法，其返回fv::options类对象。

以下为fvOptions.H代码:

Class
    Foam::fv::options

Description
    Finite-volume options

SourceFiles
    options.C

\*---------------------------------------------------------------------------*/

#ifndef options_H
#define options_H

#include "fvOptionList.H"
#include "IOdictionary.H"
#include "autoPtr.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{
namespace fv
{

/*---------------------------------------------------------------------------*\
                        Class options Declaration
\*---------------------------------------------------------------------------*/

class options
:
    public IOdictionary,
    public optionList
{
    // Private Member Functions

        //- Create IO object if dictionary is present
        IOobject createIOobject(const fvMesh& mesh) const;

        //- Disallow default bitwise copy construct
        options(const options&);

        //- Disallow default bitwise assignment
        void operator=(const options&);


public:

    // Declare name of the class and its debug switch
    ClassName("fvOptions");


    // Constructors

        //- Construct from components with list of field names
        options(const fvMesh& mesh);

        //- Construct fvOptions and register to datbase if not present
        //  otherwise lookup and return
        static options& New(const fvMesh& mesh);


    //- Destructor
    virtual ~options()
    {}


    // Member Functions

        //- Inherit read from optionList
        using optionList::read;

        //- Read dictionary
        virtual bool read();
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace fv
} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //

fv::options类继承于optionList与IOdictionary类，并调用了私有成员函数createIOobject

  • IOdictionary 类用于处理 fvOptions 相关的字典文件，
  • optionList 中定义 fvOptions 源项具体内容。
  • createIOobject:该私有成员函数会接连访问constant 文件夹和system文件夹，如果存在fvOptions文件，则进行数据读取并初始化，否则放弃读取。

2. fvOptions.C

\*---------------------------------------------------------------------------*/

#include "fvOptions.H"
#include "fvMesh.H"
#include "Time.H"

// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

namespace Foam
{
    namespace fv
    {
        defineTypeNameAndDebug(options, 0);
    }
}


// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //

Foam::IOobject Foam::fv::options::createIOobject
(
    const fvMesh& mesh
) const
{
    IOobject io
    (
        typeName,
        mesh.time().constant(),
        mesh,
        IOobject::MUST_READ,
        IOobject::NO_WRITE
    );

    if (io.headerOk())
    {
        Info<< "Creating finite volume options from "
            << io.instance()/io.name() << nl
            << endl;

        io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
        return io;
    }
    else
    {
        // Check if the fvOptions file is in system
        io.instance() = mesh.time().system();

        if (io.headerOk())
        {
            Info<< "Creating finite volume options from "
                << io.instance()/io.name() << nl
                << endl;

            io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
            return io;
        }
        else
        {
            Info<< "No finite volume options present" << nl << endl;

            io.readOpt() = IOobject::NO_READ;
            return io;
        }
    }
}


// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

Foam::fv::options::options
(
    const fvMesh& mesh
)
:
    IOdictionary(createIOobject(mesh)), //构造函数中调用 createIOobject 函数来对父类 IOdictionary 进行初始化
    optionList(mesh, *this)//通过(*this) 作为参数传递给父类 optionList
{}

//存在，读取；否则创建并引用
Foam::fv::options& Foam::fv::options::New(const fvMesh& mesh)
{
    if (mesh.thisDb().foundObject<options>(typeName))
    {
        return const_cast<options&>
        (
            mesh.lookupObject<options>(typeName)
        );
    }
    else
    {
        if (debug)
        {
            InfoInFunction
                << "Constructing " << typeName
                << " for region " << mesh.name() << endl;
        }

        options* objectPtr = new options(mesh);
        regIOobject::store(objectPtr);
        return *objectPtr;
    }
}


bool Foam::fv::options::read()
{
    if (IOdictionary::regIOobject::read())
    {
        optionList::read(*this);
        return true;
    }
    else
    {
        return false;
    }
}


// ************************************************************************* //

optionList(mesh,*this)参数一个是fvmesh类，一个是options类，在fvOptionList.H文件中，对应于optionList(const fvMesh& mesh, const dictionary& dict)，可见options类对象是对dictionary类对象的引用。

3. fvOptionList.H

Class
    Foam::fv::optionList

Description
    List of finite volume options

SourceFile
    optionList.C

\*---------------------------------------------------------------------------*/

#ifndef fvOptionList_H
#define fvOptionList_H

#include "fvOption.H"
#include "PtrList.H"
#include "GeometricField.H"
#include "geometricOneField.H"
#include "fvPatchField.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

// Forward declaration of friend functions and operators

namespace fv
{
    class optionList;
}

Ostream& operator<<(Ostream& os, const fv::optionList& options);

namespace fv
{

/*---------------------------------------------------------------------------*\
                         Class optionList Declaration
\*---------------------------------------------------------------------------*/

class optionList
:
    public PtrList<option>
{
protected:

    // Protected data

        //- Reference to the mesh database
        const fvMesh& mesh_;

        //- Time index to check that all defined sources have been applied
        label checkTimeIndex_;


    // Protected Member Functions

        //- Return the "options" sub-dictionary if present otherwise return dict
        const dictionary& optionsDict(const dictionary& dict) const;

        //- Read options dictionary
        bool readOptions(const dictionary& dict);

        //- Check that all sources have been applied
        void checkApplied() const;

        //- Disallow default bitwise copy construct
        optionList(const optionList&);

        //- Disallow default bitwise assignment
        void operator=(const optionList&);


public:

    //- Runtime type information
    TypeName("optionList");


    // Constructors

        //- Construct null
        optionList(const fvMesh& mesh);

        //- Construct from mesh and dictionary
        optionList(const fvMesh& mesh, const dictionary& dict);


    //- Destructor
    virtual ~optionList()
    {}


    // Member Functions

        //- Reset the source list
        void reset(const dictionary& dict);


        // Sources

            //- Return source for equation
            // 重载的括号操作符，在求解器里，方程的构造过程中调用的就是这些括号操作符
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                GeometricField<Type, fvPatchField, volMesh>& field
            );

            //- Return source for equation with specified name
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                GeometricField<Type, fvPatchField, volMesh>& field,
                const word& fieldName
            );

            //- Return source for equation
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const volScalarField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field
            );

            //- Return source for equation with specified name
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const volScalarField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field,
                const word& fieldName
            );

            //- Return source for equation
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const volScalarField& alpha,
                const volScalarField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field
            );

            //- Return source for equation with specified name
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const volScalarField& alpha,
                const volScalarField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field,
                const word& fieldName
            );

            //- Return source for equation
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const volScalarField& alpha,
                const geometricOneField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field
            );

            //- Return source for equation
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const geometricOneField& alpha,
                const volScalarField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field
            );

            //- Return source for equation
            template<class Type>
            tmp<fvMatrix<Type>> operator()
            (
                const geometricOneField& alpha,
                const geometricOneField& rho,
                GeometricField<Type, fvPatchField, volMesh>& field
            );


        // Constraints

            //- Apply constraints to equation
            template<class Type>
            void constrain(fvMatrix<Type>& eqn);


        // Correction

            //- Apply correction to field
            template<class Type>
            void correct(GeometricField<Type, fvPatchField, volMesh>& field);


        // IO

            //- Read dictionary
            virtual bool read(const dictionary& dict);

            //- Write data to Ostream
            virtual bool writeData(Ostream& os) const;

            //- Ostream operator
            friend Ostream& operator<<
            (
                Ostream& os,
                const optionList& options
            );
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace fv
} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#ifdef NoRepository
    #include "fvOptionListTemplates.C"
#endif

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //

这里注意以下几点：

  • optionList 类继承自 PtrList<option> ，这 意味着 fvOptions 类是支持同时定义多个源项；
  • 这里出现了重载的运算符 () ;
  • 关于成员函数 void reset(const dictionary& dict);的定义(这里涉及到reset和optionsDict函数的定义)查看fvOptionList.C。

4. fvOptionList.C

\*---------------------------------------------------------------------------*/

#include "fvOptionList.H"
#include "surfaceFields.H"

// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

namespace Foam
{
namespace fv
{
    defineTypeNameAndDebug(optionList, 0);
}
}


// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //

const Foam::dictionary& Foam::fv::optionList::optionsDict
(
    const dictionary& dict
) const
{
    if (dict.found("options"))
    {
        return dict.subDict("options");
    }
    else
    {
        return dict;
    }
}


bool Foam::fv::optionList::readOptions(const dictionary& dict)
{
    checkTimeIndex_ = mesh_.time().timeIndex() + 2;

    bool allOk = true;
    forAll(*this, i)
    {
        option& bs = this->operator[](i);
        bool ok = bs.read(dict.subDict(bs.name()));
        allOk = (allOk && ok);
    }
    return allOk;
}


void Foam::fv::optionList::checkApplied() const
{
    if (mesh_.time().timeIndex() == checkTimeIndex_)
    {
        forAll(*this, i)
        {
            const option& bs = this->operator[](i);
            bs.checkApplied();
        }
    }
}


// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

Foam::fv::optionList::optionList(const fvMesh& mesh, const dictionary& dict)
:
    PtrList<option>(),
    mesh_(mesh),
    checkTimeIndex_(mesh_.time().startTimeIndex() + 2)
{
    reset(optionsDict(dict));
}


Foam::fv::optionList::optionList(const fvMesh& mesh)
:
    PtrList<option>(),
    mesh_(mesh),
    checkTimeIndex_(mesh_.time().startTimeIndex() + 2)
{}


// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //

void Foam::fv::optionList::reset(const dictionary& dict)
{
    // Count number of active fvOptions
    label count = 0;
    forAllConstIter(dictionary, dict, iter)
    {
        if (iter().isDict())
        {
            count++;
        }
    }

    this->setSize(count);
    label i = 0;
    forAllConstIter(dictionary, dict, iter)
    {
        if (iter().isDict())
        {
            const word& name = iter().keyword();
            const dictionary& sourceDict = iter().dict();

            this->set
            (
                i++,
                option::New(name, sourceDict, mesh_)
            );
        }
    }
}


bool Foam::fv::optionList::read(const dictionary& dict)
{
    return readOptions(optionsDict(dict));
}


bool Foam::fv::optionList::writeData(Ostream& os) const
{
    // Write list contents
    forAll(*this, i)
    {
        os  << nl;
        this->operator[](i).writeHeader(os);
        this->operator[](i).writeData(os);
        this->operator[](i).writeFooter(os);
    }

    // Check state of IOstream
    return os.good();
}


// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //

Foam::Ostream& Foam::operator<<(Ostream& os, const fv::optionList& options)
{
    options.writeData(os);
    return os;
}


// ************************************************************************* //

5. fvOptions(U)的实现

这一部分可参考SemiImplicitSource.C文件

(文件位置：$FOAM_SRC/fvOptions/sources/general/)

#include "SemiImplicitSource.H"
#include "fvMesh.H"
#include "fvMatrices.H"
#include "DimensionedField.H"
#include "fvmSup.H"

// * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //

template<class Type>
const Foam::wordList Foam::fv::SemiImplicitSource<Type>::volumeModeTypeNames_
(
    IStringStream("(absolute specific)")()
);


// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //

template<class Type>
typename Foam::fv::SemiImplicitSource<Type>::volumeModeType
Foam::fv::SemiImplicitSource<Type>::wordToVolumeModeType
(
    const word& vmtName
) const
{
    forAll(volumeModeTypeNames_, i)
    {
        if (vmtName == volumeModeTypeNames_[i])
        {
            return volumeModeType(i);
        }
    }

    FatalErrorInFunction
        << "Unknown volumeMode type " << vmtName
        << ". Valid volumeMode types are:" << nl << volumeModeTypeNames_
        << exit(FatalError);

    return volumeModeType(0);
}


template<class Type>
Foam::word Foam::fv::SemiImplicitSource<Type>::volumeModeTypeToWord
(
    const volumeModeType& vmtType
) const
{
    if (vmtType > volumeModeTypeNames_.size())
    {
        return "UNKNOWN";
    }
    else
    {
        return volumeModeTypeNames_[vmtType];
    }
}


template<class Type>
void Foam::fv::SemiImplicitSource<Type>::setFieldData(const dictionary& dict)
{
    fieldNames_.setSize(dict.toc().size());
    injectionRate_.setSize(fieldNames_.size());

    applied_.setSize(fieldNames_.size(), false);

    label i = 0;
    forAllConstIter(dictionary, dict, iter)
    {
        fieldNames_[i] = iter().keyword();
        dict.lookup(iter().keyword()) >> injectionRate_[i];
        i++;
    }

    // Set volume normalisation
    if (volumeMode_ == vmAbsolute)
    {
        VDash_ = V_;
    }
}


// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

template<class Type>
Foam::fv::SemiImplicitSource<Type>::SemiImplicitSource
(
    const word& name,
    const word& modelType,
    const dictionary& dict,
    const fvMesh& mesh
)
:
    cellSetOption(name, modelType, dict, mesh),
    volumeMode_(vmAbsolute),
    VDash_(1.0),
    injectionRate_()
{
    read(dict);
}


// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //

template<class Type>
void Foam::fv::SemiImplicitSource<Type>::addSup
(
    fvMatrix<Type>& eqn,
    const label fieldi
)
{
    if (debug)
    {
        Info<< "SemiImplicitSource<" << pTraits<Type>::typeName
            << ">::addSup for source " << name_ << endl;
    }

    const GeometricField<Type, fvPatchField, volMesh>& psi = eqn.psi();

    DimensionedField<Type, volMesh> Su
    (
        IOobject
        (
            name_ + fieldNames_[fieldi] + "Su",
            mesh_.time().timeName(),
            mesh_,
            IOobject::NO_READ,
            IOobject::NO_WRITE
        ),
        mesh_,
        dimensioned<Type>
        (
            "zero",
            eqn.dimensions()/dimVolume,
            Zero
        ),
        false
    );

    UIndirectList<Type>(Su, cells_) = injectionRate_[fieldi].first()/VDash_;

    DimensionedField<scalar, volMesh> Sp
    (
        IOobject
        (
            name_ + fieldNames_[fieldi] + "Sp",
            mesh_.time().timeName(),
            mesh_,
            IOobject::NO_READ,
            IOobject::NO_WRITE
        ),
        mesh_,
        dimensioned<scalar>
        (
            "zero",
            Su.dimensions()/psi.dimensions(),
            0.0
        ),
        false
    );

    UIndirectList<scalar>(Sp, cells_) = injectionRate_[fieldi].second()/VDash_;

    eqn += Su + fvm::SuSp(Sp, psi);
}


template<class Type>
void Foam::fv::SemiImplicitSource<Type>::addSup
(
    const volScalarField& rho,
    fvMatrix<Type>& eqn,
    const label fieldi
)
{
    if (debug)
    {
        Info<< "SemiImplicitSource<" << pTraits<Type>::typeName
            << ">::addSup for source " << name_ << endl;
    }

    return this->addSup(eqn, fieldi);
}

6. correct函数

在 optionList 类里，所有可能出现在求解器代码里函数都有了，包括 correct ， constrain ，
makeRelative ， makeAbsolute ， relative 以及 ()
运算符的重载。但是，注意这里并没有具体的代码实现，而是通过类似

 forAll(*this, i) 
 {    
	 this->operator[](i).makeAbsolute(phi);
  }

调用其他地方的函数。 optionList 的一个重要使命是，统计 fvOptions
文件里定义了多少个源项，并将每一个源项都作为一个储存起来，然后再根据词典的内容创建特定的源项。核心在于 reset 函数。

reset(optionsDict(dict));

可见构造函数里调用了 reset 函数，并且用 optionsDict 函数的返回值作为 reset 函数的参数。 ------以上部分引自参考2

参考：

  1. http://xiaopingqiu.github.io/2016/03/20/fvOptions1/
  2. http://xiaopingqiu.github.io/2016/03/20/fvOptions2/
  3. https://blog.csdn.net/weixin_43651242/article/details/105928732?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-2.compare&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-2.compare
  4. https://caefn.com/?s=fvOptions
  5. http://www.cfd-online.com/Forums/openfoam-programming-development/130503-using-fvoptions-add-momentum-source.html
  6. https://blog.csdn.net/hanbingchegu/article/details/107417054
  7. OpenFOAM 中的源项模型 fvOptions 解析
寒冰彻骨
关注
  • 10
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
openfoam学习心得—fvOptions详解
weixin_43651242的博客
05-05 4819
openfoam学习心得—openfoam类 1.RTS机制 每一个类都有一个New函数，用来返回指向该类对象的指针 2.fvoptions—是一个对象，重载（）操作符 3.IOobject—是个类旨在在目录下查找文件与文件建立链接 IOobject io ( “fvOptions”, --文件名 mesh.time().constant(), --文件路径...
kEpsilonSources:修改了 OpenFOAM 的 kEpsilon 湍流模型，它使用 fvOptions 添加源项
06-25
kEpsilon 源 修改了 OpenFOAM 的 kEpsilon 湍流模型，它使用 fvOptions 添加源项。 安装 克隆并移动到此存储库，然后运行wmake libso ： cd $WM_PROJECT_USER_DIR git clone https://github.com/petebachant/kEpsilonSources.git cd kEpsilonSources wmake libso 用法 将"libmyIncompressibleRASModels.so"添加到您案例的system/controlDict libs中，并在constant/RASProperties使用 RASModel kEpsilonSources; 例如，请参阅
OpenFOAM 2.2.0: fvOptions----运行时可选的物理操作
寒冰彻骨的博客
07-17 3645
`OpenFOAM`中引入了一个新的框架`fvOptions`，允许用户选择任何可以表示为控制方程的源项或约束的物理参数，例如多孔介质、磁流变液和体力等。
OpenFOAM的fvOptions
ambu1230的博客
08-19 265
对此，我在进行槽道流仿真时，进行了验证。对比了中间截面的平均速度和出口截面的平均速度，发现它们几乎一致。这个fvOptions影响的是方程中的源项，类似重力项，通过调整体积力的大小来设定速度的大小。采用OpenFoam中的fvOptions。进行如下设置，可以大致设定流动的平均速度。
如何设置fvOptions【翻译】
asd165654的博客
07-19 581
翻译自：CFD-online 帖子地址：http://www.cfd-online.com/Forums/openfoam-pre-processing/121763-how-set-fvoptions.html yurifrey： 大家好 我想在2.2.x版本当中使用fvOptions设置多孔介质区域。但是求解器似乎没有读取这个文件...我创建了拥有两个分离域的网格，下面是第...
interFoam求解器分析
寒冰彻骨的博客
10-23 4716
interFoam是基于 VOF 模型的不可压、绝热、不可溶两相界面捕获求解器，其界面是通过跟踪相分数，计算每个网格内的相场值而后处理出来的，并不是直接算出来的。这就导致网格划分越密，VOF后处理出来的界面越薄，相变区也随之变得尖锐。
turbulence-&gtdivDevReff(U)代码解读
寒冰彻骨的博客
07-06 2810
24.1.2 Momentum equation Departing from the Navier-Stokes equations, the momentum equation of pimpleFoam are derived. ∂ρu ∂t + ∇(ρuu) + ∇ · τ = −∇p + g (43) because we assume a constant density we can divide by ρ ∂u ∂t + ∇(uu) + 1ρ∇ · τ = =∇pρ + gρ (44) T.
控制方程文章汇总
寒冰彻骨的博客
09-01 451
本文旨在对`控制方程`专题下的文章进行整理，方便阅读及查看。
向DPMFoam或MPPICFoam求解器中添加源项
姜蜉蝣的博客
07-18 2728
本文总结了向DPMFoam/MPPICFoam求解器中添加源项以及如何使用的详细过程。
turbinesFoam:OpenFOAM 的执行器线建模扩展库
08-05
特征fvOptions类，用于将致动器线和由致动器线构造的涡轮机添加到任何兼容的求解器或湍流模型，例如simpleFoam 、 pimpleFoam 、 interFoam等。安装 cd $WM_PROJECT_USER_DIRgit clone ...
OpenFOAM中动量方程 UEqn 浅析
寒冰彻骨的博客
07-16 3767
本文分析了OpenFOAM中的动量方程UEqn()，对其中的基本代码逐条进行了分析。 fvVectorMatrix UEqn ( fvm::ddt(U) + fvm::div(phi, U) + MRF.DDt(U) //MRF是多参考坐标系，在动网格中会用到（像旋转机械等），一般情况下可忽略 + turbulence->divDevReff(U) == fvOptions(U)//源项或约束 );
Cauchy应力张量、剪切力张量与压力的关系
寒冰彻骨的博客
07-18 5962
Cauchy应力张量σ，它包括作用于体积单元dV的所有应力。也就是说，包括剪切力和压力。 首先，对于Cauchy应力张量σ，有： σ=[σxxσxyσxzσyxσyyσyzσzxσzyσzz]\mathbf σ= \begin{bmatrix} \sigma_{xx}& \sigma_{xy} & \sigma_{xz} \\ \sigma_{yx}& \sigma_{yy} & \sigma_{yz} \\ \sigma_{zx}& \sigma_{zy
MRF.DDt(U)---MRF模型简介
寒冰彻骨的博客
07-14 4797
本文旨在解决 MRF.DDt(U) 代码问题，并分析了代码由来。MRF，多重参考系模型， 主要用于解决旋转坐标系问题，如：旋转机械，搅拌器等。这种模型适用于定常流动，当转子与定子相互影响较弱时，计算结果相对准确。
能量方程浅析
寒冰彻骨的博客
09-01 4063
本文对三大控制方程中的能量方程进行了简要概述。
剪切应力张量
寒冰彻骨的博客
07-18 3966
本文介绍了N-S方程中的剪切张量，并介绍了膨胀粘度项，应变率以及相应的剪切应力化简形式
剪切应力张量divDevReff 与 divDevRhoReff解析
寒冰彻骨的博客
07-20 2585
在OpenFOAM中，我们用函数divDevReff 与 divDevRhoReff来计算剪切应力。 文章目录函数名称含义代码解读 函数名称含义 下面，解释这两个函数名称的由来： ∇⋅τ=∇⋅σdev\nabla \cdot \tau=\nabla \cdot \sigma^{dev}∇⋅τ=∇⋅σdev 关于这个公示的推导可查看Cauchy应力张量、剪切力张量与压力的关系。 div:散度（divergence）； dev:每个二阶张量都可分解为 dev 部分（deviatoric）和 hyd 部分（hy
grpcio-1.63.0-cp38-cp38-linux_armv7l.whl
最新发布
05-28
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
SQLyog-13.1.3-0.x86Community.exe
05-28
SQLyog-13.1.3-0.x86Community
openfoam component z方向
05-25
OpenFOAM是一个基于有限体积方法的开源CFD软件套件，其组件包含了一些处理不同方向的工具。其中，处理z方向的组件主要有以下几个： 1. cellZones：用于定义网格单元的集合，并对其进行分类和处理。 2. faceZones：用于定义网格面的集合，并对其进行分类和处理。 3. boundaryField：用于定义边界条件，可以通过在boundaryField中添加z方向的边界条件来处理z方向的变量。 4. fvOptions：用于添加不同类型的物理模型，例如处理z方向的重力场等。 5. turbulenceModels：用于添加不同类型的湍流模型，例如处理z方向的二维或三维湍流模型等。 这些组件可以根据具体问题的需要进行选择和组合，以实现对z方向的处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值