openfoam 订阅
OpenFOAM是一个完全由C++编写,在linux下运行,面向对象的计算流体力学(CFD)类库 [1]  。OpenFOAM跟商用的CFD软件Ansys Fluent,CFX类似,但其为开源的,采用类似于我们日常习惯的方法在软件中描述偏微分方程的有限体积离散化。2004年开始OpenFOAM一直作为免费使用的开源软件,有OpenFOAM和OpenFOAM-Extened两个版本,分别有Henry Weller负责的OpenCFD以及Hrvoje Jasak负责的Wikki公司分别维护 [2]  。 展开全文
OpenFOAM是一个完全由C++编写,在linux下运行,面向对象的计算流体力学(CFD)类库 [1]  。OpenFOAM跟商用的CFD软件Ansys Fluent,CFX类似,但其为开源的,采用类似于我们日常习惯的方法在软件中描述偏微分方程的有限体积离散化。2004年开始OpenFOAM一直作为免费使用的开源软件,有OpenFOAM和OpenFOAM-Extened两个版本,分别有Henry Weller负责的OpenCFD以及Hrvoje Jasak负责的Wikki公司分别维护 [2]  。
信息
软件语言
英语
软件名称
OpenFOAM
软件版本
5.0(2017.08)
软件平台
Linux
OpenFOAM发展历程
1989年开始,Henry Weller和帝国理工大学等人开始编写OpenFOAM的前身,当时的名称为“FOAM”(Field Operation and Manipulation的简写)。1993年,克罗地亚人Hrvoje Jasak在帝国理工大学Gosman团队读PhD期间开始写FOAM,1996年,第一篇使用“FOAM”的博士论文出现 [3]  。随后在2000-2004年被Nabla公司购买,当时的FOAM并未开源且为一款商业软件。2004年12月,Henry Weller, Chris Creenshields, Mattijs Janssens通过他们创立的OpenCFD公司将FOAM开源化并发行,同时将“FOAM”更名为“OpenFOAM”。同年,Hrvoje Jasak创办了Wikki公司(2008年Henrik Rusche加入),Hrvoje Jasak的公司主要负责OpenFOAM-Extened版本的发布和管理。2008年,“OpenFOAM”发布了snappyHexMesh,其为一个非常强大的、依然在更新的六面体(多面体)全自动网格划分程序。2010年,Helene Blanchonnet加入OpenCFD,创建了新版的OpenFOAM网站以及一个Bug汇报网站。2011年,“OpenFOAM”由SGI集团收购,为了保证其开源特性,在OpenCFD被收购之前,创立了位于美国的非营利性OpenFOAM基金会。“OpenFOAM”被转移至OpenFOAM基金会下,其主要负责“OpenFOAM”的发布以及开源特性。2012年,SGI集团把OpenCFD卖给了ESI集团。2014年,Henry Weller和Chris Creenshields离开了ESI集团,继续负责“OpenFOAM”的开发和维护,OpenFOAM基金会移至英国。2015年3月,Henry Weller,Chris Creenshields,Jenya Collings在英国雷丁创立CFD Direct,以OpenFOAM基金会的利益负责OpenFOAM的开发和管理。
收起全文
精华内容
下载资源
问答
  • OpenFOAM OpenFOAM项目 腔数
  • OpenFOAM是由OpenFOAM Foundation发布的免费的开源计算流体动力学(CFD)软件包。 它在商业和学术组织的大多数工程和科学领域都拥有庞大的用户群。 OpenFOAM具有广泛的功能,可以解决从涉及化学React,湍流和热传递...
  • openfoam学习心得——openfoam编程进阶

    千次阅读 2020-05-16 12:14:59
    openfoam学习心得——openfoam编程重新学 1、OpenFOAM编程入门:setRootCase都干了些啥? https://mp.weixin.qq.com/s?__biz=MzA4NDU5NzI2MQ==&mid=2386311098&idx=1&sn=44820dbad31e66463542b25991cef1...

    openfoam学习心得——openfoam编程重新学

    1、OpenFOAM编程入门:setRootCase都干了些啥?
    setRootCase都干了些啥
    2、blockMesh > log.blockMesh
    运行blockMesh这个命令,并将其output写进log文件里面
    可以看blockMesh源代码学习数据的写入
    3、mesh.boundaryMesh() 返回polyBoundaryMesh类

    polyBoundaryMesh类输出结果
    (
        movingWall
        {
            type            wall;
            inGroups        List<word> 1(wall);
            nFaces          20;
            startFace       760;
        }
        fixedWalls
        {
            type            wall;
            inGroups        List<word> 1(wall);
            nFaces          60;
            startFace       780;
        }
        frontAndBack
        {
            type            patch;
            nFaces          800;
            startFace       840;
        }
    )
    **polyPatch类:**
    type            wall;
    inGroups        List<word> 1(wall);
    nFaces          20;
    startFace       760;
     
     **fvboundarymesh类**
     **fvPatch类:**
     polyPatch可以理解为fvPatch的一个总和,fvpatch用来计算面中心等
    

    4、openfoam Workshop
    5、The openfoam technology primer–边界条件与几何场如何结合的
    6、 TypeName (“base”)与defineTypeNameAndDebug(AlgorithmBase,0)-必须写类全名

    展开为:
    ClassName("base");
    virtual const word& type() const {return typeName}
    再展开:
    ClassNameNoDebug("base");
    static int debug 
    virtual const word& type() const {return typeName}
    再展开:char*可以指向一个字符串
    
    TypeName ("base")最终展开
    static const char* typeName_(){return "base"}  //返回classname
    virtual const word& type() const {return typeName} //返回typename-虚函数,可被覆盖
    static const ::Foam::word typeName
    static int debug 
    这里初始化了两个变量但是没有赋值,下面来看赋值:
    defineTypeNameAndDebug(AlgorithmBase,0)
    展开为:
    defineTypeName(AlgorithmBase)
    defineDebugSwitch(AlgorithmBase,0--debug有关,不深究
    展开为:
    defineTypeNameWithName(AlgorithmBase,AlgorithmBase::typeName_());
    defineDebugSwitch(AlgorithmBase,0)
    最后展开为:
    const Foam::word AlgorithmBase::TypeName(AlgorithmBase::typeName_())
    defineDebugSwitch(AlgorithmBase,0

    咋一看,对于此类类对象,其typeName_()与type()返回值是一样的,但是注意type() 方法是虚函数,固当用指针时,将产生奇效,如下:

    autoPtr< incompressible::turbulenceModel > turbulence
    turbulence->typeName_()  --返回turbulenceModel
    turbulence->type()  --返回kOmega
    

    7、 RTS机制相关宏函数展开
    完整代码请移步:openfoam RTS机制分析

    第一个要学习的宏函数如下,顺带学习下如何展开宏函数:
    #define declareRunTimeSelectionTable(autoPtr,baseType,argNames,argList,parList)\
                                                                                   \
        /* Construct from argList function pointer type */                         \
        typedef autoPtr<baseType> (*argNames##ConstructorPtr)argList;              \
                                                                                   \
        /* Construct from argList function table type */                           \
        typedef HashTable<argNames##ConstructorPtr, word, string::hash>            \
            argNames##ConstructorTable;                                            \
                                                                                   \
        /* Construct from argList function pointer table pointer */                \
        static argNames##ConstructorTable* argNames##ConstructorTablePtr_;         \
                                                                                   \
        /* Table constructor called from the table add function */                 \
        static void construct##argNames##ConstructorTables();                      \
                                                                                   \
        /* Table destructor called from the table add function destructor */       \
        static void destroy##argNames##ConstructorTables();                        \
                                                                                   \
        /* Class to add constructor from argList to table */                       \
        template<class baseType##Type>                                             \
        class add##argNames##ConstructorToTable                                    \
        {                                                                          \
        public:                                                                    \
                                                                                   \
            static autoPtr<baseType> New argList                                   \
            {                                                                      \
                return autoPtr<baseType>(new baseType##Type parList);              \
            }                                                                      \
                                                                                   \
            add##argNames##ConstructorToTable                                      \
            (                                                                      \
                const word& lookup = baseType##Type::typeName                      \
            )                                                                      \
            {                                                                      \
                construct##argNames##ConstructorTables();                          \
                if (!argNames##ConstructorTablePtr_->insert(lookup, New))          \
                {                                                                  \
                    std::cerr<< "Duplicate entry " << lookup                       \
                        << " in runtime selection table " << #baseType             \
                        << std::endl;                                              \
                    error::safePrintStack(std::cerr);                              \
                }                                                                  \
            }                                                                      \
                                                                                   \
            ~add##argNames##ConstructorToTable()                                   \
            {                                                                      \
                destroy##argNames##ConstructorTables();                            \
            }                                                                      \
        };                                                                         \
                                                                                   \
        /* Class to add constructor from argList to table */                       \
        /* Remove only the entry (not the table) upon destruction */               \
        template<class baseType##Type>                                             \
        class addRemovable##argNames##ConstructorToTable                           \
        {                                                                          \
            /* retain lookup name for later removal */                             \
            const word& lookup_;                                                   \
                                                                                   \
        public:                                                                    \
                                                                                   \
            static autoPtr<baseType> New argList                                   \
            {                                                                      \
                return autoPtr<baseType>(new baseType##Type parList);              \
            }                                                                      \
                                                                                   \
            addRemovable##argNames##ConstructorToTable                             \
            (                                                                      \
                const word& lookup = baseType##Type::typeName                      \
            )                                                                      \
            :                                                                      \
                lookup_(lookup)                                                    \
            {                                                                      \
                construct##argNames##ConstructorTables();                          \
                argNames##ConstructorTablePtr_->set(lookup, New);                  \
            }                                                                      \
                                                                                   \
            ~addRemovable##argNames##ConstructorToTable()                          \
            {                                                                      \
                if (argNames##ConstructorTablePtr_)                                \
                {                                                                  \
                    argNames##ConstructorTablePtr_->erase(lookup_);                \
                }                                                                  \
            }                                                                      \
        };
    
     declareRunTimeSelectionTable--一次声明对应一个构造函数
            (
                autoPtr, 
                AlgorithmBase, 
                Word,   argNames--word构造、copy构造等
                (
                    const word& algorithmName    argList-此构造函数形参数
                ),
                (algorithmName)
            )
    展开后如下:
    上面宏中###是为了区分开参数与非参数
    typedef autoPtr< AlgorithmBase > (*WordConstructorPtr)( const word& algorithmName );
    函数指针--WordConstructorPtr理解成一个类,其对象就是函数指针
    string::hash默认参数,word是key,value是WordConstructorPtr类(或叫函数指针)
    typedef HashTable< WordConstructorPtr, word, string::hash > WordConstructorTable;
    初始化哈希表指针-静态的,父类、子类对象均可访问此表-所有对象访问的都是同一张表
    static WordConstructorTable* WordConstructorTablePtr_;
    函数声明
    static void constructWordConstructorTables();
    static void destroyWordConstructorTables();
    template< class AlgorithmBaseType >--类中类
    class addWordConstructorToTable --将构造函数添加到Hash表中
    {
        public:
        static autoPtr< AlgorithmBase > New ( const word& algorithmName )
        {
        给指向基类的指针动态分配内存-指向由word构造生成的基类对象
            return autoPtr< AlgorithmBase >(new AlgorithmBaseType (algorithmName));
        }
        找类中的typename静态名称
        addWordConstructorToTable ( const word& lookup = AlgorithmBaseType::typeName )
        {
        调用前面声明的函数
            constructWordConstructorTables();
            New函数是一个前面指定好的函数指针类型
            if (!WordConstructorTablePtr_->insert(lookup, New))
            {
                std::cerr<< "Duplicate entry "
                    << lookup << " in runtime selection table "
                    << "AlgorithmBase" << std::endl;
                error::safePrintStack(std::cerr);
            }
        }
        析构函数,因为前面的函数中一旦调用将产生有动态分配的内存
        ~addWordConstructorToTable()
        {
            destroyWordConstructorTables();
        }
    };
    类中类
    template< class AlgorithmBaseType >
    class addRemovableWordConstructorToTable
    {
        const word& lookup_;  私有成员
        
        public:
        静态函数:返回一个基类指针,其指向的可能是别的对象
        ======植入进哈希表的是一个函数
        static autoPtr< AlgorithmBase > New ( const word& algorithmName )
        {
            return autoPtr< AlgorithmBase >(new AlgorithmBaseType (algorithmName));
        }
         ======植入进哈希表的是一个函数
        addRemovableWordConstructorToTable ( const word& lookup = AlgorithmBaseType::typeName )
        : lookup_(lookup)
        {
            constructWordConstructorTables();
            WordConstructorTablePtr_->set(lookup, New);
        }
       =======删除某个哈希表元素
        ~addRemovableWordConstructorToTable()
        {
            if (WordConstructorTablePtr_)
            {
                WordConstructorTablePtr_->erase(lookup_);
            }
        }
    };
    

    上面声明了一个静态数据成员-一张哈希表,key-typename;value是一个函数:此函数的功能是为基类指针复制基类或子类对象。下面的宏将上述静态变量与函数展开。

    defineRunTimeSelectionTable(AlgorithmBase, Word)展开后如下:
    初始化
    AlgorithmBase::WordConstructorTable* AlgorithmBase::WordConstructorTablePtr_ = __null;不至于变成野指针
        void AlgorithmBase::constructWordConstructorTables() {
            static bool constructed = false;
            if (!constructed) {
                constructed = true;
                初始化哈希表指针-分配了内存
                AlgorithmBase::WordConstructorTablePtr_ = new AlgorithmBase::WordConstructorTable; 
            }
        };
        如果这个指针不为空指针,就删除堆内存的对象,并设置为空指针
        void AlgorithmBase::destroyWordConstructorTables() {
            if (AlgorithmBase::WordConstructorTablePtr_) {
                delete AlgorithmBase::WordConstructorTablePtr_;
                AlgorithmBase::WordConstructorTablePtr_ = __null;
            }
        };
    

    至此,上述的类变定义完成了,我们也搞清楚了类中每个函数的意思,下面还有一个宏来使用上面定义好的类。

    addToRunTimeSelectionTable(AlgorithmBase, AlgorithmBase, Word)展开为: 
    这里告诉我们如何调用类中类
    AlgorithmBase::addWordConstructorToTable< AlgorithmBase > addAlgorithmBaseWordConstructorToAlgorithmBaseTable_;
    

    上面初始化一个类中类对象,在初始化过程中,为基类的哈希表中插入了key-value对,这说明这个表会一直存在。即时再用别的基类对象访问这个表,此表仍然存在相同的数据。第一个AlgorithmBase表示addWordConstructorToTable方法位于基类中,第二个参数AlgorithmBase,代表了插入的key-value的typename函数以及New函数的功能,其返回的是一个基类还是子类对象有此参数指定。可能有点难理解,我们来看其子类。

    class AlgorithmNew
    :
        public AlgorithmBase
    {
        public: 
    
            // Declare the static variable typeName of the class AlgorithmNew.
            TypeName ("new");
    
            // Empty constructor. 
            AlgorithmNew () {};
    
            // Word constructor.
            AlgorithmNew (const word& algorithmName) {};
    
            // Make the class callable (function object) 
            virtual void operator()()
            {
                Info << "AlgorithmNew::operator()()" << endl;
            }
    };
    defineTypeNameAndDebug(AlgorithmNew, 0);
    addToRunTimeSelectionTable(AlgorithmBase, AlgorithmNew , Word);
    

    此时基类的static成员,哈希表中应该是这样的:
    AlgorithmBase – New函数–返回基类指针,指针指向的是以word构造生成的AlgorithmBase类对象
    AlgorithmNew – New函数–返回基类指针,指针指向的是以word构造生成的AlgorithmNew类对象

    再来一个继承:

    class AlgorithmAdditional
    :
        public AlgorithmNew 
    {
        public: 
    
            // Declare the static variable typeName of the class AlgorithmAdditional.
            TypeName ("additional");
    
            // Empty constructor. 
            AlgorithmAdditional () {};
    
            // Word constructor.
            AlgorithmAdditional (const word& algorithmName) {};
    
            // Make the class callable (function object) 
            virtual void operator()()
            {
                // Call base operator explicitly.
                AlgorithmNew::operator()();
                // Perform additional operations.
                Info << "AlgorithmAdditional::operator()()" << endl;
            }
    };
    
    defineTypeNameAndDebug(AlgorithmAdditional, 0);
    addToRunTimeSelectionTable(AlgorithmBase, AlgorithmAdditional , Word)
    

    此时基类的static成员,哈希表中应该是这样的:
    AlgorithmBase – New函数–返回基类指针,指针指向的是以word构造生成的AlgorithmBase类对象
    AlgorithmNew – New函数–返回基类指针,指针指向的是以word构造生成的AlgorithmNew类对象
    AlgorithmAdditional – New函数–返回基类指针,指针指向的是以word构造生成的AlgorithmAdditional 类对象

    这个表在编译的时候就已经永恒存在了,可以发现都是以word构造生成的对象,要是我有别的构造呢?如copy构造,原理相同。
    注意,表中的New函数是定义在addWordConstructorToTable类中-此类为基类中的类的,在基类中同样有一个New函数,充当selector

     static autoPtr< AlgorithmBase > New (const word& algorithmName)
            {
              输入一个typename--也就是key
                WordConstructorTable::iterator cstrIter =
                    WordConstructorTablePtr_->find(algorithmName);
               找不到就报错
                // If the Factory Method was not found. 
                if (cstrIter == WordConstructorTablePtr_->end())
                {
                    FatalErrorIn
                    (
                        "AlgorithmBase::New(const word&)"
                    )   << "Unknown AlgorithmBase type "
                        << algorithmName << nl << nl
                        << "Valid AlgorithmBase types are :" << endl
                        << WordConstructorTablePtr_->sortedToc()
                        << exit(FatalError);
                }
    
                cstrIter()--返回key对应的value,也就是new函数,并传参定义基类指针。
                return cstrIter()(algorithmName);
    
            }
    

    从上面代码我们可以学习到,哈希表类中有个迭代器的类中类,()运算符被重载,用来返回key对应的value。
    综上学习完毕,RTS机制说直接点就是在基类中生成一个静态的哈希表,基类和子类每编译一次,就往哈希表中加入一个值,其加入值的方法也很精妙,竟然是初始化类中类对象,这个值是永恒的,与求解器运行与否无关,同时基类中还会有一个静态的New函数,用来做选择,看看到底调用哈希表中的哪个函数指针,生成什么类型的对象赋予基类指针。可以猜想定义湍流模型肯定是需要往哈希表中加值的。

    8、湍流模型中的RTS分析
    1. turbulenceModel 类中
    declareRunTimeNewSelectionTable宏-–生成一个哈希表,同时生成往哈希表中插值的类,此时的类中类New函数–也就是此类中哈希表的value返回的是key值所对应类的New函数–选择器:
    defineRunTimeSelectionTable宏–这个宏是定义declareRunTimeNewSelectionTable宏中所声明的函数用的

    2.RASModel类中
    declareRunTimeSelectionTable宏–生成一个哈希表,同时生成往哈希表中插值的类,这个返回的是基类或子类对象。
    defineRunTimeSelectionTable(RASModel, dictionary)宏–说明是哈希表中New函数返回的对象是由字典构造生成的。
    addToRunTimeSelectionTable(turbulenceModel, RASModel, turbulenceModel)宏–说明将RASModel类添加到turbulenceModel类的哈希表中:
    也就是RASModel(类的typename) New—这个函数返回RASModel::New

    3、kEpsilon类中
    addToRunTimeSelectionTable(RASModel, kEpsilon, dictionary)宏–说明将kEpsilon类添加到RASModel的哈希表中,采用字典构造生成kEpsilon类对象,返回给基类指针。

    把类添加到哈希表等同于key=类的typename,value=New函数(属于类中类的New函数),其返回此类对象。某一个类中存在哈希表,则存在select(属于基类的New函数),可以在哈希表中用迭代器来选择函数执行。

    故而我们在文件中指定的都是typename–可能与类名相同,也可能不同,一般是一样的。

    综上,autoPtr< incompressible::turbulenceModel > turbulence
    (
    incompressible::turbulenceModel::New(U, phi, laminarTransport)
    );运行过程为,turbulenceModel::New根据字典选择RASModel,则调用RASModel中的RASModel::New函数,然后根据字典选择kEpsilon,则在生成kEpsilon对象。

    展开全文
  • OpenFOAM-v1812-AD 该存储库包含OpenFOAM-v1812源代码,这些源代码通过正向和反向模式下的自动区分(AD)来区分。 安装 OpenFOAM-v1812-AD的安装与OpenFOAM-v1812的安装类似。 需要首先安装所有必备组件,获取Open...
  • - OpenFOAM-2.0.1-foss2016a + a patch to fix compilation error - OpenFOAM-Extend-3.2-foss-2016a - OpenFOAM-Extend-3.2-ictce-7.3.5</p><p>该提问来源于开源项目:easybuilders/easybuild-...
  • <div><p>Looking at the two openfoam recipes, it could be useful to add in the openfoam-selector. This is much like the mpi-selector that allows registration and selection of various openfoam ...
  • 轻松学会OpenFOAM(更新:2020-09-20) | OpenFOAM快速上手简明教程

    轻松学会OpenFOAM(更新:2020-09-20) | OpenFOAM快速上手简明教程

    展开全文
  • 这份目录分类收录了知乎上高价值的 OpenFOAM 文章,主要来源是 知乎专栏-OpenFOAM Studio、知乎用户-陈与论-文章、知乎用户-海兮吾槊-文章 和 知乎用户-神秘色彩-文章。本目录将持续更新,欢迎作者和读者在评论区...

    这份目录分类收录了知乎上高价值的 OpenFOAM 文章,主要来源是 知乎专栏-OpenFOAM Studio、知乎用户-陈与论-文章、知乎用户-海兮吾槊-文章 和 知乎用户-神秘色彩-文章。本目录将持续更新,欢迎作者和读者在评论区补充新的文章。

    知乎上有关 OpenFOAM 的高质量回答,请参阅知乎收藏夹 OpenFOAM;有关 OpenFOAM 的全部内容,请参阅知乎话题 openfoam。

    (一)编译、安装和配置

    在亚马逊 AWS 上使用 OpenFOAM

    在超算机群上运行 OpenFOAM

    在 Ubuntu 上安装 OpenFOAM + liggghts + CFDEM coupling

    在 Ubuntu 上安装 OpenFOAM + preCICE 【未完成】

    在 Ubuntu 上安装 OpenFOAM + waves2foam

    olaFlow (原 olaFoam) 编译和测试

    Git、GitHub 和 OpenFOAM-dev

    Environment Modules 简明教程

    (二)算例

    用 potentialFoam 初始化流场

    interFoam 算例导读(上)

    interFoam 算例导读(中)

    interFoam 算例导读(下)

    interFoam 动网格算例导读 - 浮体

    interFoam 动网格算例导读 - 带障碍物的溃坝

    上进的非牛顿流体 - climbingRod 算例赏析

    动网格算例 - 搅拌容器

    模拟弹头在水中的空化现象

    interPhaseChangeFoam 算例配置

    OpenFOAM 离心泵数值仿真及不同 CFD 软件间对比

    用 OpenFOAM 计算 M6 机翼流场

    OpenFOAM 计算低亚音速飞机起落架流场

    OpenFOAM的一个简单并行计算(计算房间内的流量通量)

    (三)Utility 工具

    参数化 blockMeshDict

    监测点、断面和等值面

    用 Sample 工具提取明渠水面

    fieldAverage、postAverageTurbulenceFields 和 createTurbulenceFieldsLES

    如何在 OpenFOAM 里求雷诺应力

    OpenFOAM 中的 fieldAverage

    OpenFOAM 中非均匀初始场的设定

    OpenFOAM 里的 mapfield 是怎么 map 的

    OpenFOAM 中的网格自动化生成

    (四)求解器

    从 potentialFoam 看 OpenFOAM 求解器结构

    interPhaseChangeFoam 求解器解析

    compressibleInterFoam 解析

    OpenFOAM 中的数据结构 - icoFoam 为例【未完成】

    OpenFOAM 中的动态多态(Info,solve)

    如何在 OpenFOAM 中插入自己写的外部 python 函数

    (五)数值方法

    用 OpenFOAM 进行张量计算

    OpenFOAM 中方程的求解算法

    OpenFOAM 中 laplacian 项离散格式解码

    用 GdbOF 追踪 laplacian 函数在 OpenFOAM 中的定义过程

    【翻译】OpenFOAM 中的空间离散化与矩阵系数

    OpenFOAM 中的 SIMPLE 算法解析

    (六)紊流模型

    OpenFOAM 中的壁面函数选择

    OpenFOAM中 的 wall function 到底是怎么弄的【未完成】

    Reynolds stress turbulence model in Openfoam

    给定 Reynolds stress 场,反推速度场

    DES 类模型理解

    附录

    OpenFOAM Linux Cheat Sheet

    用 git 管理 OpenFOAM 算例(附 .gitignore 文件)

    适合 OpenFOAM 的编辑器工具【未完成】

    以上资源由知乎专栏 OpenFOAM Studio 为您整合,感谢关注!

    展开全文
  • OpenFOAM安装教程(史上最全) 参考东岳流体:http://www.dyfluid.com/docs/install.html

    OpenFOAM安装教程(史上最全:OpenFOAM安装、ParaView安装、OpenFOAM多版本共存)

    1. OF安装+ParaView安装:http://www.dyfluid.com/docs/install.html(参考东岳流体)
    2. OF安装+OF多版本共存:http://blog.sina.com.cn/s/blog_14bf001d10102wifw.html(参考CFD界博客)
    3. OF多版本共存:https://forum.cfdwired.com/t/topic/389(参考Forum论坛)
    4. OF安装:https://blog.csdn.net/bfadlzt/article/details/80396670(CSDN)
    5. cofludy:https://www.cnblogs.com/cofludy/p/5931731.html(此链接中有部分描述错误,属于作者七平八凑,适合有一定of基础,可以纠错学习的同学)
    展开全文
  • <div><p>When building the OpenFOAM 1712 version, additional binaries and libraries should be produced and installed in <code>platforms/linux64GccDPInt32RpathOpt/bin</code> and <code>platforms/linux64...
  • <div><p>openfoam & openfoam-org do not build correctly with gcc: because it raises an error for -Wdeprecated-copy. This commit fixes that. <p>Also fixes an issue with building openfoam-org as flex...
  • OpenFOAM-源码

    2021-02-12 11:24:32
    “#OpenFOAM
  • OpenFOAM】——OpenFOAM入门算例学习

    千次阅读 2019-06-21 15:47:00
    1 明确目标——为啥费老大劲儿学习OpenFOAM 学习OpenFOAM主要出于课题需要,希望实现以下几个目标: l 【 】学会用SnappyHexMesh生成高质量网格; l 【 】学习使用OpenFOAM自带的 Immersed Boundary Method (IBM...
  • OpenFOAM初学者常常对于软件的使用流程感到很迷惑,与其他的具有GUI的CFD软件不同,OpenFOAM的所有操作均为基于文本操作,譬如说里面各种计算模型、计算参数、流程控制参数等,均为通过修改对应的文本文件来进行指定...
  • openfoam2-源码

    2021-03-31 09:54:56
    openfoam2
  • openfoam1-源码

    2021-03-06 10:22:52
    openfoam1
  • 深入理解 OpenFOAM 环境变量与编译操作系统选择由于 OpenFOAM 在 Linux 平台开发和测试,在非 Linux 平台无法直接对软件进行编译和安装,所以在非 Linux 平台上最简便方法是使用 docker 容器运行 OpenFOAM。...
  • 安装环境 使用虚拟机安装使用的是Ubuntu 16.04版本,目前这个版本的各种...直接更新源之后使用apt-get安装即可,需要同时安装openfoam和paraview。 但是!!!but!!!据师兄描述,openFOAM的版本更新在内部结...
  • openfoam入门

    2017-11-06 15:53:39
    openfoam入门OpenFOAM的能力媲美最領先的通用商業閉源流體力學 套裝軟體。它依賴用戶選擇的第三方前、後處理軟體, 且配備:  外掛程式(paraFoam)用ParaView作為解算後數據和網格的可視 化檢視。  轉換器允許...
  • OpenFoam用户指南

    2018-07-09 22:08:59
    OpenFoam教材,搞CFD的需要。OpenFoam是开源的求解器,支持自定义。
  • 您感觉OpenFOAM运行得很慢?采用并行计算可以极大的提高运行效率,是OpenFOAM必须要学习的内容。即便是个人的笔记本电脑,采用并行计算通常也可以加速的。 以为并行计算很难?实际上,采用这个视频中的方法,它的...
  • 近期不少留言说OpenFOAM不容易安装,今天来谈谈如何在Linux下利用Docker安装OpenFOAM。 Linux发行版众多,估计有几百种,比较流行的是三个派系: RHEL系。比较出名的发行版像Red Hat Enterprise、CentOS、Fedora等 ...
  • OpenFOAM-ESI-源码

    2021-02-09 16:47:03
    关于OpenFOAM OpenFOAM是的免费,开源CFD软件。 它在商业和学术组织的大多数工程和科学领域都拥有庞大的用户群。 OpenFOAM具有广泛的功能,可以解决从涉及化学React,湍流和热传递的复杂流体流到声学,固体力学和...
  • OpenFOAM-3.0.1.tgz

    2020-03-27 11:00:43
    OpenFOAM 开源CFD工具箱 OpenFOAM-开源CFD工具箱。OpenFOAM是用于计算流体动力学(CFD)的通用可编程软件工具。有关更多信息,请参见: -主网站:https : //openfoam.org-C ++源文档:...
  • OpenFoam安装,ubuntu20.04,ESI-OpenFoam-v2006 1.安装支持软件 以下软件复制安装即可,另只适用于ubuntu20.04其他版本可参考思路。 sudo apt update sudo apt-get update sudo apt-get install build-...
  • <div><p>This pull request adds openfoam-org versions 6 and 7 and a variant +metis for linking metis. <p>The version number change from 5.0 to 6 and 7 is due to the change made by OpenFOAM ...
  • OpenFOAM-7

    2020-11-02 08:52:13
    OpenFOAM-7源码,git下载太慢,在csdn备份一份,需要的拿走。 资源来自互联网,未做任何修改。
  • OpenFOAM Courses.7z

    2020-03-10 15:07:27
    OpenFOAM二次开发指南,包含了很多OpenFOAM二次开发的相关课程PPT和教程。涵盖OpenFOAM C++基础到求解器改造。
  • OpenFOAM 6 user guide

    2018-11-20 02:56:45
    Manipulation (OpenFOAM) C++ libraries. It provides a description of the basic operation of OpenFOAM, first through a set of tutorial exercises in chapter 2 and later by a more detailed description of ...
  • OpenFoam decompose libraries

    2020-12-09 03:28:06
    -I/apps/gent/SL6/sandybridge/software/OpenFOAM/2.4.0-intel-2015b/OpenFOAM-2.4.0/src/OpenFOAM/lnInclude -I/apps/gent/SL6/sandybridge/software/OpenFOAM/2.4.0-intel-2015b/OpenFOAM-2.4.0/src/OSspecific/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,191
精华内容 476
关键字:

openfoam