User Guide

User Manual: Pdf

Open the PDF directly: View PDF PDF.
Page Count: 1

OpenFOAM
The Open Source CFD Toolbox
User Guide
Version 1.6
24th July 2009
U-2
Copyright c
°2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 OpenCFD
Limited.
Permission is granted to copy, distribute and/or modify this document under the terms
of the GNU Free Documentation License, Version 1.2 published by the Free Software
Foundation; with no Invariant Sections, no Back-Cover Texts and one Front-Cover Text:
“Available free from openfoam.org.” A copy of the license is included in the section
entitled “GNU Free Documentation License”.
This document is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.
Typeset in L
A
T
EX.
OpenFOAM-1.6
U-3
GNU Free Documentation License
Version 1.2, November 2002
Copyright c
°2000,2001,2002 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies of this license document, but
changing it is not allowed.
Preamble
The purpose of this License is to make a manual, textbook, or other functional and useful
document “free” in the sense of freedom: to assure everyone the effective freedom to copy and
redistribute it, with or without modifying it, either commercially or noncommercially. Secon-
darily, this License preserves for the author and publisher a way to get credit for their work,
while not being considered responsible for modifications made by others.
This License is a kind of “copyleft”, which means that derivative works of the document
must themselves be free in the same sense. It complements the GNU General Public License,
which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free
software needs free documentation: a free program should come with manuals providing the
same freedoms that the software does. But this License is not limited to software manuals; it
can be used for any textual work, regardless of subject matter or whether it is published as a
printed book. We recommend this License principally for works whose purpose is instruction or
reference.
1. APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that contains a notice placed
by the copyright holder saying it can be distributed under the terms of this License. Such a
notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under
the conditions stated herein. The “Document”, below, refers to any such manual or work.
Any member of the public is a licensee, and is addressed as “you”. You accept the license if
you copy, modify or distribute the work in a way requiring permission under copyright law.
A“Modified Version” of the D8(e)-053.1098(e)-437.503(D)8.811(m)0.0828044(e)-0.233867(n)0653867(h)-414.644(m)0.0828044(e)-0.234986(a)0.0492351(n)0.32898(o)-410.802(a)0.0492351(n)2506301(r)-300.524(w)28.3795(o)0.0492351(r)-00.32841(t)-371.749(c)-0.234986(on0.049235(n)28.3795(t)0.0492351(i)-0.246175(d)0.331218(i)-0.250651(n)0.364901(f)-413.843(t)0.308838(h)0..32898(e)-437.2662D)-0.06490407(n)0.32898(c)-0.232748(u)0.326742(m)0.0805665(e)-0.232748(n.04923534(w)28.3795(o)0.0492351((t)0.3248417TJ-238.689 -13s)-41.906(r)-0.21141c)-0.233867(ot)0.312195(ra)0.051473(t)0.311076(i)-0.233867(on)-41.956(i)-0.247294(of)-41.9603(t)0.311076(i)-0.247294(t)04492353reithee co diee verbati mtwoe with modification0.2484.8178]TJ285.23-383.861(a)0.0492351(n0.308838(/3-383.861(a(w)28.3818(o)0.420.217s)0.0895183(t)0.308838(ry)-349.215(a)0.0492351(n)0.331218(sp)0.331218(l)-0.250651(a)-0.248413(t)0.313368(e)--41.966(l)-0.241218(i)--409.408,)-378.909(t)0420.867(y)-349.215(a)0.0492351(n)0.331218(o)0.0492351(t)0.308838(h)0.331218(e)0.0492351((t)0.84.8178]J-325.269 -13)-0.247294(l)-0.233867(a)0.0492351gy)27.8352(o)00.210368(b)0..8352(oo)-394.295(g)0.0492748(e)-0.233413(.)-0.246175]TJ173781 -13.6348 Td[(A)0.0744121]TJ/R253 1]TJ1 Tf12.9512 0 Td[(“.)-652688(l)-0.2.5698(e)ociod ltda oecuion”
U-4
document straightforwardly with generic text editors or (for images composed of pixels) generic
paint programs or (for drawings) some widely available drawing editor, and that is suitable for
input to text formatters or for automatic translation to a variety of formats suitable for input to
text formatters. A copy made in an otherwise Transparent file format whose markup, or absence
of markup, has been arranged to thwart or discourage subsequent modification by readers is not
Transparent. An image format is not Transparent if used for any substantial amount of text. A
copy that is not “Transparent” is called “Opaque”.
Examples of suitable formats for Transparent copies include plain ASCII without markup,
Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD,
and standard-conforming simple HTML, PostScript or PDF designed for human modification.
Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include
proprietary formats that can be read and edited only by proprietary word processors, SGML or
XML for which the DTD and/or processing tools are not generally available, and the machine-
generated HTML, PostScript or PDF produced by some word processors for output purposes
only.
The “Title Page” means, for a printed book, the title page itself, plus such following pages
as are needed to hold, legibly, the material this License requires to appear in the title page. For
works in formats which do not have any title page as such, “Title Page” means the text near
the most prominent appearance of the work’s title, preceding the beginning of the body of the
text.
A section “Entitled XYZ” means a named subunit of the Document whose title either is
precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another
language. (Here XYZ stands for a specific section name mentioned below, such as “Acknowl-
edgements”,“Dedications”,“Endorsements”, or “History”.) To “Preserve the Ti-
tle” of such a section when you modify the Document means that it remains a section “Entitled
XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this
License applies to the Document. These Warranty Disclaimers are considered to be included by
reference in this License, but only as regards disclaiming warranties: any other implication that
these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
2. VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially or noncom-
mercially, provided that this License, the copyright notices, and the license notice saying this
License applies to the Document are reproduced in all copies, and that you add no other con-
ditions whatsoever to those of this License. You may not use technical measures to obstruct or
control the reading or further copying of the copies you make or distribute. However, you may
accept compensation in exchange for copies. If you distribute a large enough number of copies
you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly
display copies.
3. COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have printed covers) of the
Document, numbering more than 100, and the Document’s license notice requires Cover Texts,
you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts:
Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers
must also clearly and legibly identify you as the publisher of these copies. The front cover must
present the full title with all words of the title equally prominent and visible. You may add
other material on the covers in addition. Copying with changes limited to the covers, as long as
they preserve the title of the Document and satisfy these conditions, can be treated as verbatim
copying in other respects.
OpenFOAM-1.6
U-5
If the required texts for either cover are too voluminous to fit legibly, you should put the first
ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent
pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you
must either include a machine-readable Transparent copy along with each Opaque copy, or state
in or with each Opaque copy a computer-network location from which the general network-using
public has access to download using public-standard network protocols a complete Transparent
copy of the Document, free of added material. If you use the latter option, you must take
reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure
that this Transparent copy will remain thus accessible at the stated location until at least one
year after the last time you distribute an Opaque copy (directly or through your agents or
retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before
redistributing any large number of copies, to give them a chance to provide you with an updated
version of the Document.
4. MODIFICATIONS
You may copy and distribute a Modified Version of the Document under the conditions of
sections 2 and 3 above, provided that you release the Modified Version under precisely this
License, with the Modified Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy of it. In addition, you
must do these things in the Modified Version:
A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document,
and from those of previous versions (which should, if there were any, be listed in the
History section of the Document). You may use the same title as a previous version if the
original publisher of that version gives permission.
B. List on the Title Page, as authors, one or more persons or entities responsible for au-
thorship of the modifications in the Modified Version, together with at least five of the
principal authors of the Document (all of its principal authors, if it has fewer than five),
unless they release you from this requirement.
C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications adjacent to the other copyright
notices.
F. Include, immediately after the copyright notices, a license notice giving the public per-
mission to use the Modified Version under the terms of this License, in the form shown
in the Addendum below.
G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts
given in the Document’s license notice.
H. Include an unaltered copy of this License.
I. Preserve the section Entitled “History”, Preserve its Title, and add to it an item stating
at least the title, year, new authors, and publisher of the Modified Version as given on the
Title Page. If there is no section Entitled “History” in the Document, create one stating
the title, year, authors, and publisher of the Document as given on its Title Page, then
add an item describing the Modified Version as stated in the previous sentence.
OpenFOAM-1.6
U-6
J. Preserve the network location, if any, given in the Document for public access to a Trans-
parent copy of the Document, and likewise the network locations given in the Document
for previous versions it was based on. These may be placed in the “History” section. You
may omit a network location for a work that was published at least four years before the
Document itself, or if the original publisher of the version it refers to gives permission.
K. For any section Entitled “Acknowledgements” or “Dedications”, Preserve the Title of the
section, and preserve in the section all the substance and tone of each of the contributor
acknowledgements and/or dedications given therein.
L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their
titles. Section numbers or the equivalent are not considered part of the section titles.
M. Delete any section Entitled “Endorsements”. Such a section may not be included in the
Modified Version.
N. Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title
with any Invariant Section.
O. Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or appendices that qualify as
Secondary Sections and contain no material copied from the Document, you may at your option
designate some or all of these sections as invariant. To do this, add their titles to the list of
Invariant Sections in the Modified Version’s license notice. These titles must be distinct from
any other section titles.
You may add a section Entitled “Endorsements”, provided it contains nothing but endorse-
ments of your Modified Version by various parties–for example, statements of peer review or
that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to
25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version.
Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through
arrangements made by) any one entity. If the Document already includes a cover text for the
same cover, previously added by you or by arrangement made by the same entity you are acting
on behalf of, you may not add another; but you may replace the old one, on explicit permission
from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to
use their names for publicity for or to assert or imply endorsement of any Modified Version.
5. COMBINING DOCUMENTS
You may combine the Document with other documents released under this License, under
the terms defined in section 4 above for modified versions, provided that you include in the
combination all of the Invariant Sections of all of the original documents, unmodified, and list
them all as Invariant Sections of your combined work in its license notice, and that you preserve
all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and multiple identical In-
variant Sections may be replaced with a single copy. If there are multiple Invariant Sections
with the same name but different contents, make the title of each such section unique by adding
at the end of it, in parentheses, the name of the original auth
Invariant Sections im thlieense notich of thr combined wo
U-7
6. COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents released under
this License, and replace the individual copies of this License in the various documents with a
single copy that is included in the collection, provided that you follow the rules of this License
for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually
under this License, provided you insert a copy of this License into the extracted document, and
follow this License in all other respects regarding verbatim copying of that document.
7. AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate and independent docu-
ments or works, in or on a volume of a storage or distribution medium, is called an “aggregate”
if the copyright resulting from the compilation is not used to limit the legal rights of the com-
pilation’s users beyond what the individual works permit. When the Document is included in
an aggregate, this License does not apply to the other works in the aggregate which are not
themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document,
then if the Document is less than one half of the entire aggregate, the Document’s Cover Texts
may be placed on covers that bracket the Document within the aggregate, or the electronic
equivalent of covers if the Document is in electronic form. Otherwise they must appear on
printed covers that bracket the whole aggregate.
8. TRANSLATION
Translation is considered a kind of modification, so you may distribute translations of the
Document under the terms of section 4. Replacing Invariant Sections with translations requires
special permission from their copyright holders, but you may include translations of some or
all Invariant Sections in addition to the original versions of these Invariant Sections. You
may include a translation of this License, and all the license notices in the Document, and any
Warranty Disclaimers, provided that you also include the original English version of this License
and the original versions of those notices and disclaimers. In case of a disagreement between
the translation and the original version of this License or a notice or disclaimer, the original
version will prevail.
If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”,
the requirement (section 4) to Preserve its Title (section 1) will typically require changing the
actual title.
9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as expressly provided
for under this License. Any other attempt to copy, modify, sublicense or distribute the Document
is void, and will automatically terminate your rights under this License. However, parties who
have received copies, or rights, from you under this License will not have their licenses terminated
so long as such parties remain in full compliance.
10. FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the GNU Free Documenta-
tion License from time to time. Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If the Document
specifies that a particular numbered version of this License “or any later version” applies to it,
you have the option of following the terms and conditions either of that specified version or of
OpenFOAM-1.6
U-8
any later version that has been published (not as a draft) by the Free Software Foundation. If
the Document does not specify a version number of this License, you may choose any version
ever published (not as a draft) by the Free Software Foundation.
OpenFOAM-1.6
U-9
Trademarks
ANSYS is a registered trademark of ANSYS Inc.
CFX is a registered trademark of Ansys Inc.
CHEMKIN is a registered trademark of Reaction Design Corporation
EnSight is a registered trademark of Computational Engineering International Ltd.
Fieldview is a registered trademark of Intelligent Light
Fluent is a registered trademark of Ansys Inc.
GAMBIT is a registered trademark of Ansys Inc.
Icem-CFD is a registered trademark of Ansys Inc.
I-DEAS is a registered trademark of Structural Dynamics Research Corporation
JAVA is a registered trademark of Sun Microsystems Inc.
Linux is a registered trademark of Linus Torvalds
OpenFOAM is a registered trademark of OpenCFD Ltd
ParaView is a registered trademark of Kitware
STAR-CD is a registered trademark of Computational Dynamics Ltd.
UNIX is a registered trademark of The Open Group
OpenFOAM-1.6
U-10
OpenFOAM-1.6
Contents
Copyright Notice U-2
GNU Free Documentation Licence U-3
1. APPLICABILITY AND DEFINITIONS . . . . . . . . . . . . . . . . . U-3
2. VERBATIM COPYING . . . . . . . . . . . . . . . . . . . . . . . . . U-4
3. COPYING IN QUANTITY . . . . . . . . . . . . . . . . . . . . . . . . U-4
4. MODIFICATIONS . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-5
5. COMBINING DOCUMENTS . . . . . . . . . . . . . . . . . . . . . . U-6
6. COLLECTIONS OF DOCUMENTS . . . . . . . . . . . . . . . . . . . U-7
7. AGGREGATION WITH INDEPENDENT WORKS . . . . . . . . . . U-7
8. TRANSLATION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-7
9. TERMINATION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-7
10. FUTURE REVISIONS OF THIS LICENSE . . . . . . . . . . . . . . U-7
Trademarks U-9
Contents U-11
1 Introduction U-17
2 Tutorials U-19
2.1 Lid-driven cavity flow . . . . . . . . . . . . . . . . . . . . . . . . . . U-19
2.1.1 Pre-processing . . . . . . . . . . . . . . . . . . . . . . . . . . U-20
2.1.1.1 Mesh generation . . . . . . . . . . . . . . . . . . . U-20
2.1.1.2 Boundary and initial conditions . . . . . . . . . . . U-22
2.1.1.3 Physical properties . . . . . . . . . . . . . . . . . . U-23
2.1.1.4 Control . . . . . . . . . . . . . . . . . . . . . . . . U-23
2.1.1.5 Discretisation and linear-solver settings . . . . . . . U-25
2.1.2 Viewing the mesh . . . . . . . . . . . . . . . . . . . . . . . . U-25
2.1.3 Running an application . . . . . . . . . . . . . . . . . . . . . U-26
2.1.4 Post-processing . . . . . . . . . . . . . . . . . . . . . . . . . U-28
2.1.4.1 Isosurface and contour plots . . . . . . . . . . . . . U-28
2.1.4.2 Vector plots . . . . . . . . . . . . . . . . . . . . . . U-30
2.1.4.3 Streamline plots . . . . . . . . . . . . . . . . . . . U-30
2.1.5 Increasing the mesh resolution . . . . . . . . . . . . . . . . . U-30
2.1.5.1 Creating a new case using an existing case . . . . . U-32
2.1.5.2 Creating the finer mesh . . . . . . . . . . . . . . . U-32
2.1.5.3 Mapping the coarse mesh results onto the fine mesh U-32
2.1.5.4 Control adjustments . . . . . . . . . . . . . . . . . U-33
2.1.5.5 Running the code as a background process . . . . . U-33
2.1.5.6 Vector plot with the refined mesh . . . . . . . . . . U-33
U-12 Contents
2.1.5.7 Plotting graphs . . . . . . . . . . . . . . . . . . . . U-34
2.1.6 Introducing mesh grading . . . . . . . . . . . . . . . . . . . U-36
2.1.6.1 Creating the graded mesh . . . . . . . . . . . . . . U-37
2.1.6.2 Changing time and time step . . . . . . . . . . . . U-38
2.1.6.3 Mapping fields . . . . . . . . . . . . . . . . . . . . U-39
2.1.7 Increasing the Reynolds number . . . . . . . . . . . . . . . . U-39
2.1.7.1 Pre-processing . . . . . . . . . . . . . . . . . . . . U-39
2.1.7.2 Running the code . . . . . . . . . . . . . . . . . . . U-39
2.1.8 High Reynolds number flow . . . . . . . . . . . . . . . . . . U-40
2.1.8.1 Pre-processing . . . . . . . . . . . . . . . . . . . . U-41
2.1.8.2 Running the code . . . . . . . . . . . . . . . . . . . U-42
2.1.9 Changing the case geometry . . . . . . . . . . . . . . . . . . U-43
2.1.10 Post-processing the modified geometry . . . . . . . . . . . . U-46
2.2 Stress analysis of a plate with a hole . . . . . . . . . . . . . . . . . U-46
2.2.1 Mesh generation . . . . . . . . . . . . . . . . . . . . . . . . U-47
2.2.1.1 Boundary and initial conditions . . . . . . . . . . . U-49
2.2.1.2 Mechanical properties . . . . . . . . . . . . . . . . U-51
2.2.1.3 Thermal properties . . . . . . . . . . . . . . . . . . U-51
2.2.1.4 Control . . . . . . . . . . . . . . . . . . . . . . . . U-51
2.2.1.5 Discretisation schemes and linear-solver control . . U-52
2.2.2 Running the code . . . . . . . . . . . . . . . . . . . . . . . . U-54
2.2.3 Post-processing . . . . . . . . . . . . . . . . . . . . . . . . . U-54
2.2.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-55
2.2.4.1 Increasing mesh resolution . . . . . . . . . . . . . . U-55
2.2.4.2 Introducing mesh grading . . . . . . . . . . . . . . U-56
2.2.4.3 Changing the plate size . . . . . . . . . . . . . . . U-56
2.3 Breaking of a dam . . . . . . . . . . . . . . . . . . . . . . . . . . . U-56
2.3.1 Mesh generation . . . . . . . . . . . . . . . . . . . . . . . . U-56
2.3.2 Boundary conditions . . . . . . . . . . . . . . . . . . . . . . U-58
2.3.3 Setting initial field . . . . . . . . . . . . . . . . . . . . . . . U-58
2.3.4 Fluid properties . . . . . . . . . . . . . . . . . . . . . . . . . U-59
2.3.5 Turbulence modelling . . . . . . . . . . . . . . . . . . . . . . U-60
2.3.6 Time step control . . . . . . . . . . . . . . . . . . . . . . . . U-60
2.3.7 Discretisation schemes . . . . . . . . . . . . . . . . . . . . . U-61
2.3.8 Linear-solver control . . . . . . . . . . . . . . . . . . . . . . U-62
2.3.9 Running the code . . . . . . . . . . . . . . . . . . . . . . . . U-62
2.3.10 Post-processing . . . . . . . . . . . . . . . . . . . . . . . . . U-63
2.3.11 Running in parallel . . . . . . . . . . . . . . . . . . . . . . . U-63
2.3.12 Post-processing a case run in parallel . . . . . . . . . . . . . U-67
3 Applications and libraries U-69
3.1 The programming language of OpenFOAM . . . . . . . . . . . . . . U-69
3.1.1 Language in general . . . . . . . . . . . . . . . . . . . . . . U-69
3.1.2 Object-orientation and C++ . . . . . . . . . . . . . . . . . . U-70
3.1.3 Equation representation . . . . . . . . . . . . . . . . . . . . U-70
3.1.4 Solver codes . . . . . . . . . . . . . . . . . . . . . . . . . . . U-71
3.2 Compiling applications and libraries . . . . . . . . . . . . . . . . . . U-71
3.2.1 Header .H files . . . . . . . . . . . . . . . . . . . . . . . . . . U-71
3.2.2 Compiling with wmake . . . . . . . . . . . . . . . . . . . . . U-73
3.2.2.1 Including headers . . . . . . . . . . . . . . . . . . . U-73
3.2.2.2 Linking to libraries . . . . . . . . . . . . . . . . . . U-74
OpenFOAM-1.6
Contents U-13
3.2.2.3 Source files to be compiled . . . . . . . . . . . . . . U-74
3.2.2.4 Running wmake . . . . . . . . . . . . . . . . . . . . U-75
3.2.2.5 wmake environment variables . . . . . . . . . . . . U-75
3.2.3 Removing dependency lists: wclean and rmdepall . . . . . . . U-75
3.2.4 Compilation example: the pisoFoam application . . . . . . . U-76
3.2.5 Debug messaging and optimisation switches . . . . . . . . . U-79
3.2.6 Linking new user-defined libraries to existing applications . . U-80
3.3 Running applications . . . . . . . . . . . . . . . . . . . . . . . . . . U-80
3.4 Running applications in parallel . . . . . . . . . . . . . . . . . . . . U-81
3.4.1 Decomposition of mesh and initial field data . . . . . . . . . U-81
3.4.2 Running a decomposed case . . . . . . . . . . . . . . . . . . U-83
3.4.3 Distributing data across several disks . . . . . . . . . . . . . U-84
3.4.4 Post-processing parallel processed cases . . . . . . . . . . . . U-85
3.4.4.1 Reconstructing mesh and data . . . . . . . . . . . U-85
3.4.4.2 Post-processing decomposed cases . . . . . . . . . . U-85
3.5 Standard solvers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-85
3.6 Standard utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-88
3.7 Standard libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-94
4 OpenFOAM cases U-101
4.1 File structure of OpenFOAM cases . . . . . . . . . . . . . . . . . . U-101
4.2 Basic input/output file format . . . . . . . . . . . . . . . . . . . . . U-102
4.2.1 General syntax rules . . . . . . . . . . . . . . . . . . . . . . U-102
4.2.2 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . U-102
4.2.3 The data file header . . . . . . . . . . . . . . . . . . . . . . U-103
4.2.4 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-104
4.2.5 Scalars, vectors and tensors . . . . . . . . . . . . . . . . . . U-105
4.2.6 Dimensional units . . . . . . . . . . . . . . . . . . . . . . . . U-105
4.2.7 Dimensioned types . . . . . . . . . . . . . . . . . . . . . . . U-106
4.2.8 Fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-106
4.2.9 Directives and macro substitutions . . . . . . . . . . . . . . U-107
4.3 Time and data input/output control . . . . . . . . . . . . . . . . . U-108
4.4 Numerical schemes . . . . . . . . . . . . . . . . . . . . . . . . . . . U-110
4.4.1 Interpolation schemes . . . . . . . . . . . . . . . . . . . . . . U-112
4.4.1.1 Schemes for strictly bounded scalar fields . . . . . U-113
4.4.1.2 Schemes for vector fields . . . . . . . . . . . . . . . U-113
4.4.2 Surface normal gradient schemes . . . . . . . . . . . . . . . U-114
4.4.3 Gradient schemes . . . . . . . . . . . . . . . . . . . . . . . . U-114
4.4.4 Laplacian schemes . . . . . . . . . . . . . . . . . . . . . . . U-115
4.4.5 Divergence schemes . . . . . . . . . . . . . . . . . . . . . . . U-115
4.4.6 Time schemes . . . . . . . . . . . . . . . . . . . . . . . . . . U-116
4.4.7 Flux calculation . . . . . . . . . . . . . . . . . . . . . . . . . U-117
4.5 Solution and algorithm control . . . . . . . . . . . . . . . . . . . . . U-117
4.5.1 Linear solver control . . . . . . . . . . . . . . . . . . . . . . U-117
4.5.1.1 Solution tolerances . . . . . . . . . . . . . . . . . . U-118
4.5.1.2 Preconditioned conjugate gradient solvers . . . . . U-119
4.5.1.3 Smooth solvers . . . . . . . . . . . . . . . . . . . . U-119
4.5.1.4 Geometric-algebraic multi-grid solvers . . . . . . . U-119
4.5.2 Solution under-relaxation . . . . . . . . . . . . . . . . . . . U-120
4.5.3 PISO and SIMPLE algorithms . . . . . . . . . . . . . . . . . U-121
4.5.3.1 Pressure referencing . . . . . . . . . . . . . . . . . U-121
OpenFOAM-1.6
U-14 Contents
4.5.4 Other parameters . . . . . . . . . . . . . . . . . . . . . . . . U-122
5 Mesh generation and conversion U-123
5.1 Mesh description . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-123
5.1.1 Mesh specification and validity constraints . . . . . . . . . . U-123
5.1.1.1 Points . . . . . . . . . . . . . . . . . . . . . . . . . U-124
5.1.1.2 Faces . . . . . . . . . . . . . . . . . . . . . . . . . U-124
5.1.1.3 Cells . . . . . . . . . . . . . . . . . . . . . . . . . . U-124
5.1.1.4 Boundary . . . . . . . . . . . . . . . . . . . . . . . U-125
5.1.2 The polyMesh description . . . . . . . . . . . . . . . . . . . . U-125
5.1.3 The cellShape tools . . . . . . . . . . . . . . . . . . . . . . . U-126
5.1.4 1- and 2-dimensional and axi-symmetric problems . . . . . . U-126
5.2 Boundaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-128
5.2.1 Specification of patch types in OpenFOAM . . . . . . . . . . U-128
5.2.2 Base types . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-130
5.2.3 Primitive types . . . . . . . . . . . . . . . . . . . . . . . . . U-132
5.2.4 Derived types . . . . . . . . . . . . . . . . . . . . . . . . . . U-132
5.3 Mesh generation with the blockMesh utility . . . . . . . . . . . . . . U-132
5.3.1 Writing a blockMeshDict file . . . . . . . . . . . . . . . . . . U-134
5.3.1.1 The vertices . . . . . . . . . . . . . . . . . . . . U-135
5.3.1.2 The edges . . . . . . . . . . . . . . . . . . . . . . U-135
5.3.1.3 The blocks . . . . . . . . . . . . . . . . . . . . . . U-136
5.3.1.4 The patches . . . . . . . . . . . . . . . . . . . . . U-137
5.3.2 Multiple blocks . . . . . . . . . . . . . . . . . . . . . . . . . U-138
5.3.3 Creating blocks with fewer than 8 vertices . . . . . . . . . . U-139
5.3.4 Running blockMesh . . . . . . . . . . . . . . . . . . . . . . . U-140
5.4 Mesh generation with the snappyHexMesh utility . . . . . . . . . . . U-140
5.4.1 The mesh generation process of snappyHexMesh . . . . . . . U-141
5.4.2 Creating the background hex mesh . . . . . . . . . . . . . . U-142
5.4.3 Cell splitting at feature edges and surfaces . . . . . . . . . . U-143
5.4.4 Cell removal . . . . . . . . . . . . . . . . . . . . . . . . . . . U-144
5.4.5 Cell splitting in specified regions . . . . . . . . . . . . . . . . U-145
5.4.6 Snapping to surfaces . . . . . . . . . . . . . . . . . . . . . . U-146
5.4.7 Mesh layers . . . . . . . . . . . . . . . . . . . . . . . . . . . U-146
5.4.8 Mesh quality controls . . . . . . . . . . . . . . . . . . . . . . U-148
5.5 Mesh conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-148
5.5.1 fluentMeshToFoam . . . . . . . . . . . . . . . . . . . . . . . U-149
5.5.2 starToFoam . . . . . . . . . . . . . . . . . . . . . . . . . . . U-150
5.5.2.1 General advice on conversion . . . . . . . . . . . . U-151
5.5.2.2 Eliminating extraneous data . . . . . . . . . . . . . U-151
5.5.2.3 Removing default boundary conditions . . . . . . . U-152
5.5.2.4 Renumbering the model . . . . . . . . . . . . . . . U-152
5.5.2.5 Writing out the mesh data . . . . . . . . . . . . . . U-153
5.5.2.6 Problems with the .vrt file . . . . . . . . . . . . . . U-154
5.5.2.7 Converting the mesh to OpenFOAM format . . . . U-154
5.5.3 gambitToFoam . . . . . . . . . . . . . . . . . . . . . . . . . . U-154
5.5.4 ideasToFoam . . . . . . . . . . . . . . . . . . . . . . . . . . . U-155
5.5.5 cfx4ToFoam . . . . . . . . . . . . . . . . . . . . . . . . . . . U-155
5.6 Mapping fields between different geometries . . . . . . . . . . . . . U-155
5.6.1 Mapping consistent fields . . . . . . . . . . . . . . . . . . . . U-156
5.6.2 Mapping inconsistent fields . . . . . . . . . . . . . . . . . . . U-156
OpenFOAM-1.6
Contents U-15
5.6.3 Mapping parallel cases . . . . . . . . . . . . . . . . . . . . . U-156
6 Post-processing U-159
6.1 paraFoam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-159
6.1.1 Overview of paraFoam . . . . . . . . . . . . . . . . . . . . . U-159
6.1.2 The Properties panel . . . . . . . . . . . . . . . . . . . . . . U-160
6.1.3 The Display panel . . . . . . . . . . . . . . . . . . . . . . . . U-161
6.1.4 The button toolbars . . . . . . . . . . . . . . . . . . . . . . U-163
6.1.5 Manipulating the view . . . . . . . . . . . . . . . . . . . . . U-163
6.1.5.1 View settings . . . . . . . . . . . . . . . . . . . . . U-163
6.1.5.2 General settings . . . . . . . . . . . . . . . . . . . U-163
6.1.6 Contour plots . . . . . . . . . . . . . . . . . . . . . . . . . . U-164
6.1.6.1 Introducing a cutting plane . . . . . . . . . . . . . U-164
6.1.7 Vector plots . . . . . . . . . . . . . . . . . . . . . . . . . . . U-164
6.1.7.1 Plotting at cell centres . . . . . . . . . . . . . . . . U-164
6.1.8 Streamlines . . . . . . . . . . . . . . . . . . . . . . . . . . . U-164
6.1.9 Image output . . . . . . . . . . . . . . . . . . . . . . . . . . U-165
6.1.10 Animation output . . . . . . . . . . . . . . . . . . . . . . . . U-165
6.2 Post-processing with Fluent . . . . . . . . . . . . . . . . . . . . . . U-166
6.3 Post-processing with Fieldview . . . . . . . . . . . . . . . . . . . . . U-167
6.4 Post-processing with EnSight . . . . . . . . . . . . . . . . . . . . . . U-167
6.4.1 Converting data to EnSight format . . . . . . . . . . . . . . U-168
6.4.2 The ensight74FoamExec reader module . . . . . . . . . . . . U-168
6.4.2.1 Configuration of EnSight for the reader module . . U-168
6.4.2.2 Using the reader module . . . . . . . . . . . . . . . U-168
6.5 Sampling data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . U-169
6.6 Monitoring and managing jobs . . . . . . . . . . . . . . . . . . . . . U-172
6.6.1 The foamJob script for running jobs . . . . . . . . . . . . . . U-173
6.6.2 The foamLog script for monitoring jobs . . . . . . . . . . . . U-173
7 Models and physical properties U-175
7.1 Thermophysical models . . . . . . . . . . . . . . . . . . . . . . . . . U-175
7.1.1 Thermophysical property data . . . . . . . . . . . . . . . . . U-177
7.2 Turbulence models . . . . . . . . . . . . . . . . . . . . . . . . . . . U-178
7.2.1 Model coefficients . . . . . . . . . . . . . . . . . . . . . . . . U-179
7.2.2 Wall functions . . . . . . . . . . . . . . . . . . . . . . . . . . U-179
Index U-181
OpenFOAM-1.6
U-16 Contents
OpenFOAM-1.6
Chapter 1
Introduction
This guide accompanies the release of version 1.6 of the Open Source Field Operation
and 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 the individual components that make up OpenFOAM.
OpenFOAM is first and foremost a C++ library, used primarily to create executa-
bles, known as applications. The applications fall into two categories: solvers, that are
each designed to solve a specific problem in continuum mechanics; and utilities, that are
designed to perform tasks that involve data manipulation. The OpenFOAM distribution
contains numerous solvers and utilities covering a wide range of problems, as described
in chapter 3.
One of the strengths of OpenFOAM is that new solvers and utilities can be created
by its users with some pre-requisite knowledge of the underlying method, physics and
programming techniques involved.
OpenFOAM is supplied with pre- and post-processing environments. The interface
to the pre- and post-processing are themselves OpenFOAM utilities, thereby ensuring
consistent data handling across all environments. The overall structure of OpenFOAM is
shown in Figure 1.1. The pre-processing and running of OpenFOAM cases is described
Applications
User
Tools
Meshing
Utilities Standard
Applications Others
e.g.EnSight
Post-processingSolvingPre-processing
Open Source Field Operation and Manipulation (OpenFOAM) C++ Library
ParaView
Figure 1.1: Overview of OpenFOAM structure.
in chapter 4 In chapter 5, we cover both the generation of meshes using the mesh gen-
erator supplied with OpenFOAM and conversion of mesh data generated by third-party
products. Post-processing is described in chapter 6.
U-18 Introduction
OpenFOAM-1.6
Chapter 2
Tutorials
In this chapter we shall describe in detail the process of setup, simulation and post-
processing for some OpenFOAM test cases, with the principal aim of introducing a user to
the basic procedures of running OpenFOAM. The $FOAM TUTORIALS directory contains
many more cases that demonstrate the use of all the solvers and many utilities supplied
with OpenFOAM. Before attempting to run the tutorials, the user must first make sure
that they have installed OpenFOAM correctly.
The tutorial cases describe the use of the blockMesh pre-processing tool, case setup
and running OpenFOAM solvers and post-processing using paraFoam. Those users with
access to third-party post-processing tools supported in OpenFOAM have an option:
either they can follow the tutorials using paraFoam; or refer to the description of the use
of the third-party product in chapter 6 when post-processing is required.
Copies of all tutorials are available from the tutorials directory of the OpenFOAM
installation. The tutorials are organised into a set of directories according to the type
of flow and then subdirectories according to solver. For example, all the icoFoam cases
are stored within a subdirectory incompressible/icoFoam, where incompressible indicates
the type of flow. If the user wishes to run a range of example cases, it is recommended
that the user copy the tutorials directory into their local run directory. They can be easily
copied by typing:
mkdir -p $FOAM RUN
cp -r $FOAM TUTORIALS $FOAM RUN
2.1 Lid-driven cavity flow
This tutorial will describe how to pre-process, run and post-process a case involving
isothermal, incompressible flow in a two-dimensional square domain. The geometry is
shown in Figure 2.1 in which all the boundaries of the square are walls. The top wall
moves in the x-direction at a speed of 1 m/s while the other 3 are stationary. Initially,
the flow will be assumed laminar and will be solved on a uniform mesh using the icoFoam
solver for laminar, isothermal, incompressible flow. During the course of the tutorial, the
effect of increased mesh resolution and mesh grading towards the walls will be investigated.
Finally, the flow Reynolds number will be increased and the pisoFoam solver will be used
for turbulent, isothermal, incompressible flow.
U-20 Tutorials
x
Ux= 1 m/s
d= 0.1 m
y
Figure 2.1: Geometry of the lid driven cavity.
2.1.1 Pre-processing
Cases are setup in OpenFOAM by editing case files. Users should select an xeditor of
choice with which to do this, such as emacs,vi,gedit,kate,nedit,etc. Editing files is
possible in OpenFOAM because the I/O uses a dictionary format with keywords that
convey sufficient meaning to be understood by even the least experienced users.
A case being simulated involves data for mesh, fields, properties, control parameters,
etc. As described in section 4.1, in OpenFOAM this data is stored in a set of files within
a case directory rather than in a single case file, as in many other CFD packages. The
case directory is given a suitably descriptive name, e.g. the first example case for this
tutorial is simply named cavity. In preparation of editing case files and running the first
cavity case, the user should change to the case directory
cd $FOAM RUN/tutorials/incompressible/icoFoam/cavity
2.1.1.1 Mesh generation
OpenFOAM always operates in a 3 dimensional Cartesian coordinate system and all
geometries are generated in 3 dimensions. OpenFOAM solves the case in 3 dimensions
by default but can be instructed to solve in 2 dimensions by specifying a ‘special’ empty
boundary condition on boundaries normal to the (3rd) dimension for which no solution
is required.
The cavity domain consists of a square of side length d= 0.1 m in the x-yplane. A
uniform mesh of 20 by 20 cells will be used initially. The block structure is shown in
Figure 2.2. The mesh generator supplied with OpenFOAM, blockMesh, generates meshes
from a description specified in an input dictionary, blockMeshDict located in the con-
stant/polyMesh directory for a given case. The blockMeshDict entries for this case are as
follows:
1/*--------------------------------*- C++ -*----------------------------------*\
2| ========= | |
3| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
4| \\ / O peration | Version: 1.6 |
5| \\ / A nd | Web: http://www.OpenFOAM.org |
6| \\/ M anipulation | |
7\*---------------------------------------------------------------------------*/
8FoamFile
9{
10 version 2.0;
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-21
3 2
4 5
7 6
0
z
x1
y
Figure 2.2: Block structure of the mesh for the cavity.
11 format ascii;
12 class dictionary;
13 object blockMeshDict;
14 }
15 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
16
17 convertToMeters 0.1;
18
19 vertices
20 (
21 (0 0 0)
22 (1 0 0)
23 (1 1 0)
24 (0 1 0)
25 (0 0 0.1)
26 (1 0 0.1)
27 (1 1 0.1)
28 (0 1 0.1)
29 );
30
31 blocks
32 (
33 hex (0 1 2 3 4 5 6 7) (20 20 1) simpleGrading (1 1 1)
34 );
35
36 edges
37 (
38 );
39
40 patches
41 (
42 wall movingWall
43 (
44 (3 7 6 2)
45 )
46 wall fixedWalls
47 (
48 (0 4 7 3)
49 (2 6 5 1)
50 (1 5 4 0)
51 )
52 empty frontAndBack
53 (
54 (0 3 2 1)
55 (4 5 6 7)
56 )
57 );
58
59 mergePatchPairs
60 (
61 );
62
63 // ************************************************************************* //
The file first contains header information in the form of a banner (lines 1-7), then file
information contained in a FoamFile sub-dictionary, delimited by curly braces ({...}).
OpenFOAM-1.6
U-22 Tutorials
For the remainder of the manual:
For the sake of clarity and to save space, file headers, including the banner and
FoamFile sub-dictionary, will be removed from verbatim quoting of case files
The file first specifies coordinates of the block vertices; it then defines the blocks
(here, only 1) from the vertex labels and the number of cells within it; and finally, it defines
the boundary patches. The user is encouraged to consult section 5.3 to understand the
meaning of the entries in the blockMeshDict file.
The mesh is generated by running blockMesh on this blockMeshDict file. From within
the case directory, this is done, simply by typing in the terminal:
blockMesh
The running status of blockMesh is reported in the terminal window. Any mistakes in
the blockMeshDict file are picked up by blockMesh and the resulting error message directs
the user to the line in the file where the problem occurred. There should be no error
messages at this stage.
2.1.1.2 Boundary and initial conditions
Once the mesh generation is complete, the user can look at this initial fields set up for
this case. The case is set up to start at time t= 0 s, so the initial field data is stored in
a0sub-directory of the cavity directory. The 0sub-directory contains 2 files, pand U,
one for each of the pressure (p) and velocity (U) fields whose initial values and boundary
conditions must be set. Let us examine file p:
17 dimensions [0 2 -2 0 0 0 0];
18
19 internalField uniform 0;
20
21 boundaryField
22 {
23 movingWall
24 {
25 type zeroGradient;
26 }
27
28 fixedWalls
29 {
30 type zeroGradient;
31 }
32
33 frontAndBack
34 {
35 type empty;
36 }
37 }
38
39 // ************************************************************************* //
There are 3 principal entries in field data files:
dimensions specifies the dimensions of the field, here kinematic pressure, i.e. m2s2(see
section 4.2.6 for more information);
internalField the internal field data which can be uniform, described by a single value;
or nonuniform, where all the values of the field must be specified (see section 4.2.8
for more information);
boundaryField the boundary field data that includes boundary conditions and data for
all the boundary patches (see section 4.2.8 for more information).
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-23
For this case cavity, the boundary consists of walls only, split into 2 patches named: (1)
fixedWalls for the fixed sides and base of the cavity; (2) movingWall for the moving top
of the cavity. As walls, both are given a zeroGradient boundary condition for p, meaning
“the normal gradient of pressure is zero”. The frontAndBack patch represents the front
and back planes of the 2D case and therefore must be set as empty.
In this case, as in most we encounter, the initial fields are set to be uniform. Here the
pressure is kinematic, and as an incompressible case, its absolute value is not relevant, so
is set to uniform 0 for convenience.
The user can similarly examine the velocity field in the 0/U file. The dimensions are
those expected for velocity, the internal field is initialised as uniform zero, which in the
case of velocity must be expressed by 3 vector components, i.e.uniform (0 0 0) (see
section 4.2.5 for more information).
The boundary field for velocity requires the same boundary condition for the front-
AndBack patch. The other patches are walls: a no-slip condition is assumed on the
fixedWalls, hence a fixedValue condition with a value of uniform (0 0 0). The top
surface moves at a speed of 1 m/s in the x-direction so requires a fixedValue condition
also but with uniform (1 0 0).
2.1.1.3 Physical properties
The physical properties for the case are stored in dictionaries whose names are given the
suffix . . . Properties, located in the Dictionaries directory tree. For an icoFoam case,
the only property that must be specified is the kinematic viscosity which is stored from
the transportProperties dictionary. The user can check that the kinematic viscosity is
set correctly by opening the transportProperties dictionary to view/edit its entries. The
keyword for kinematic viscosity is nu, the phonetic label for the Greek symbol νby which
it is represented in equations. Initially this case will be run with a Reynolds number of
10, where the Reynolds number is defined as:
Re =d|U|
ν(2.1)
where dand |U|are the characteristic length and velocity respectively and νis the
kinematic viscosity. Here d= 0.1 m, |U|= 1 m s1, so that for Re = 10, ν= 0.01 m2s1.
The correct file entry for kinematic viscosity is thus specified below:
17
18 nu nu [ 0 2 -1 0 0 0 0 ] 0.01;
19
20
21 // ************************************************************************* //
2.1.1.4 Control
Input data relating to the control of time and reading and writing of the solution data are
read in from the controlDict dictionary. The user should view this file; as a case control
file, it is located in the system directory.
The start/stop times and the time step for the run must be set. OpenFOAM offers
great flexibility with time control which is described in full in section 4.3. In this tutorial
we wish to start the run at time t= 0 which means that OpenFOAM needs to read field
data from a directory named 0— see section 4.1 for more information of the case file
structure. Therefore we set the startFrom keyword to startTime and then specify the
startTime keyword to be 0.
For the end time, we wish to reach the steady state solution where the flow is circu-
lating around the cavity. As a general rule, the fluid should pass through the domain 10
OpenFOAM-1.6
U-24 Tutorials
times to reach steady state in laminar flow. In this case the flow does not pass through
this domain as there is no inlet or outlet, so instead the end time can be set to the time
taken for the lid to travel ten times across the cavity, i.e. 1 s; in fact, with hindsight, we
discover that 0.5 s is sufficient so we shall adopt this value. To specify this end time, we
must specify the stopAt keyword as endTime and then set the endTime keyword to 0.5.
Now we need to set the time step, represented by the keyword deltaT. To achieve
temporal accuracy and numerical stability when running icoFoam, a Courant number of
less than 1 is required. The Courant number is defined for one cell as:
Co =δt|U|
δx (2.2)
where δt is the time step, |U|is the magnitude of the velocity through that cell and δx
is the cell size in the direction of the velocity. The flow velocity varies across the domain
and we must ensure Co < 1 everywhere. We therefore choose δt based on the worst case:
the maximum Co corresponding to the combined effect of a large flow velocity and small
cell size. Here, the cell size is fixed across the domain so the maximum Co will occur next
to the lid where the velocity approaches 1 m s1. The cell size is:
δx =d
n=0.1
20 = 0.005 m (2.3)
Therefore to achieve a Courant number less than or equal to 1 throughout the domain
the time step deltaT must be set to less than or equal to:
δt =Co δx
|U|=1×0.005
1= 0.005 s (2.4)
As the simulation progresses we wish to write results at certain intervals of time that
we can later view with a post-processing package. The writeControl keyword presents
several options for setting the time at which the results are written; here we select the
timeStep option which specifies that results are written every nth time step where the
value nis specified under the writeInterval keyword. Let us decide that we wish to
write our results at times 0.1, 0.2,. . . , 0.5 s. With a time step of 0.005 s, we therefore
need to output results at every 20th time time step and so we set writeInterval to 20.
OpenFOAM creates a new directory named after the current time,e.g. 0.1 s, on each
occasion that it writes a set of data, as discussed in full in section 4.1. In the icoFoam
solver, it writes out the results for each field, Uand p, into the time directories. For this
case, the entries in the controlDict are shown below:
17
18 application icoFoam;
19
20 startFrom startTime;
21
22 startTime 0;
23
24 stopAt endTime;
25
26 endTime 0.5;
27
28 deltaT 0.005;
29
30 writeControl timeStep;
31
32 writeInterval 20;
33
34 purgeWrite 0;
35
36 writeFormat ascii;
37
38 writePrecision 6;
39
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-25
40 writeCompression uncompressed;
41
42 timeFormat general;
43
44 timePrecision 6;
45
46 runTimeModifiable yes;
47
48
49 // ************************************************************************* //
2.1.1.5 Discretisation and linear-solver settings
The user specifies the choice of finite volume discretisation schemes in the fvSchemes
dictionary in the system directory. The specification of the linear equation solvers and
tolerances and other algorithm controls is made in the fvSolution dictionary, similarly in
the system directory. The user is free to view these dictionaries but we do not need to
discuss all their entries at this stage except for pRefCell and pRefValue in the PISO
sub-dictionary of the fvSolution dictionary. In a closed incompressible system such as the
cavity, pressure is relative: it is the pressure range that matters not the absolute values.
In cases such as this, the solver sets a reference level by pRefValue in cell pRefCell. In
this example both are set to 0. Changing either of these values will change the absolute
pressure field, but not, of course, the relative pressures or velocity field.
2.1.2 Viewing the mesh
Before the case is run it is a good idea to view the mesh to check for any errors. The mesh
is viewed in paraFoam, the post-processing tool supplied with OpenFOAM. The paraFoam
post-processing is started by typing in the terminal from within the case directory
paraFoam
Alternatively, it can be launched from another directory location with an optional
-case argument giving the case directory, e.g.
paraFoam -case $FOAM RUN/tutorials/incompressible/icoFoam/cavity
This launches the ParaView window as shown in Figure 6.1. In the Pipeline Browser,
the user can see that ParaView has opened cavity.OpenFOAM, the module for the cavity
case. Before clicking the Apply button, the user needs to select some geometry from
the Region Status and panel. Because the case is small, it is easiest to select all the data
by checking the box adjacent to the Region Status panel title, which automatically checks
all individual components within the respective panel. The user should then click the
Apply button to load the geometry into ParaView.
some general settings are applied as described in section 6.1.5.1.Please consult this
section about these settings.
The user should then open the Display panel that controls the visual representation of
the selected module. Within the Display panel the user should do the following as shown
in Figure 2.3: (1) set Color by Solid Color; (2) click Set Solid Color and select an appro-
priate colour e.g. black (for a white background); (3) in the Style panel, select Wireframe
from the Representation menu. The background colour can be set by selecting View
Settings... from Edit in the top menu panel.
Especially the first time the user starts ParaView,it is recommended that they
manipulate the view as described in section 6.1.5. In particular, since this is a 2D case,
it is recommended that Use Parallel Projection is selected in the General panel of View
OpenFOAM-1.6
U-26 Tutorials
Open Display panel
Select Color by Solid Color
Set Solid Color,e.g. black
Select Wireframe
Figure 2.3: Viewing the mesh in paraFoam.
Settings window selected from the Edit menu. The Orientation Axes can be toggled on
and off in the Annotation window or moved by drag and drop with the mouse.
2.1.3 Running an application
Like any UNIX/Linux executable, OpenFOAM applications can be run in two ways: as
a foreground process, i.e. one in which the shell waits until the command has finished
before giving a command prompt; as a background process, one which does not have to
be completed before the shell accepts additional commands.
On this occasion, we will run icoFoam in the foreground. The icoFoam solver is exe-
cuted either by entering the case director034(h)-0.310405(e)-6.37 amwienononrgs
2.1 Lid-driven cavity flow U-27
Open Display panel
Rescale to Data Range
Select Surface
Select Color by interpolated p
Figure 2.4: Displaying pressure contours for the cavity case.
Figure 2.5: Pressures in the cavity case.
OpenFOAM-1.6
U-28 Tutorials
2.1.4 Post-processing
As soon as results are written to time directories, they can be viewed using paraFoam.
Return to the paraFoam window and select the Properties panel for the cavity.OpenFOAM
case module. If the correct window panels for the case module do not seem to be present
at any time, please ensure that: cavity.OpenFOAM is highlighted in blue; eye button
alongside it is switched on to show the graphics are enabled;
To prepare paraFoam to display the data of interest, we must first load the data at
the required run time of 0.5 s. If the case was run while ParaView was open, the output
data in time directories will not be automatically loaded within ParaView. To load the
data the user should select Update GUI in the Properties window and then click the green
Apply button. The time data will be loaded into ParaView.
2.1.4.1 Isosurface and contour plots
To view pressure, the user should open the Display panel since it that controls the visual
representation of the selected module. To make a simple plot of pressure, the user should
select the following, as described in detail in Figure 2.4: in the Style panel, select Surface
from the Representation menu; in the Color panel, select Color by and Rescale to
Data Range. Now in order to view the solution at t= 0.5 s, the user can use the VCR
Controls or Current Time Controls to change the current time to 0.5. These are
located in the toolbars below the menus at the top of the ParaView window, as shown in
Figure 6.4. The pressure field solution has, as expected, a region of low pressure at the
top left of the cavity and one of high pressure at the top right of the cavity as shown in
Figure 2.5.
With the point icon ( ) the pressure field is interpolated across each cell to give a
continuous appearance. Instead if the user selects the cell icon, , from the Color by
menu, a single value for pressure will be attributed to each cell so that each cell will be
denoted by a single colour with no grading.
A colour bar can be included by either by clicking the Toggle Color Legend Visibility
button in the Active Variable Controls toolbar, or by selecting Show Color Legend
from the View menu. Clicking the Edit Color Map button, either in the Active Variable
Controls toolbar or in the Color panel of the Display window, the user can set a range
of attributes of the colour bar, such as text size, font selection and numbering format for
the scale. The colour bar can be located in the image window by drag and drop with the
mouse.
New versions of ParaView default to using a colour scale of blue to white to red rather
than the more common blue to green to red (rainbow). Therefore the first time that the
user executes ParaView, they may wish to change the colour scale. This can be done by
selecting Choose Preset in the Color Scale Editor and selecting Blue to Red Rainbow. After
clicking the OK confirmation button, the user can click the Make Default button so that
ParaView will always adopt this type of colour bar.
If the user rotates the image, they can see that they have now coloured the complete
geometry surface by the pressure. In order to produce a genuine contour plot the user
should first create a cutting plane, or ‘slice’, through the geometry using the Slice filter
as described in section 6.1.6.1. The cutting plane should be centred at (0.05,0.05,0.005)
and its normal should be set to (0,0,1). Having generated the cutting plane, the contours
can be created using by the Contour filter described in section 6.1.6.
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-29
Open Parameters panel
Select Scale Mode off
Select Glyph Type Arrow
Specify Set Scale Factor 0.005
Figure 2.6: Properties panel for the Glyph filter.
Figure 2.7: Velocities in the cavity case.
OpenFOAM-1.6
U-30 Tutorials
2.1.4.2 Vector plots
Before we start to plot the vectors of the flow velocity, it may be useful to remove other
modules that have been created, e.g. using the Slice and Contour filters described above.
These can: either be deleted entirely, by highlighting the relevant module in the Pipeline
Browser and clicking Delete in their respective Properties panel; or, be disabled by toggling
the eye button for the relevant module in the Pipeline Browser.
We now wish to generate a vector glyph for velocity at the centre of each cell. We
first need to filter the data to cell centres as described in section 6.1.7.1. With the
cavity.OpenFOAM module highlighted in the Pipeline Browser, the user should select Cell
Centers from the Filter menu and then click Apply.
With these Centers highlighted in the Pipeline Browser, the user should then select
Glyph from the Filter menu. The Properties window panel should appear as shown in
Figure 2.6. In the resulting Properties panel, the velocity field, U, is automatically selected
in the vectors menu, since it is the only vector field present. By default the Scale Mode
for the glyphs will be Vector Magnitude of velocity but, since the we may wish to view
the velocities throughout the domain, the user should instead select off and Set Scale
Factor to 0.005. On clicking Apply, the glyphs appear but, probably as a single colour,
e.g. white. The user should colour the glyphs by velocity magnitude which, as usual, is
controlled by setting Color by U in the Display panel. The user should also select Show
Color Legend in Edit Color Map. The output is shown in Figure 2.7, in which uppercase
Times Roman fonts are selected for the Color Legend headings and the labels are specified
to 2 fixed significant figures by deselecting Automatic Label Format and entering %-#6.2f
in the Label Format text box. The background colour is set to white in the General panel
of View Settings as described in section 6.1.5.1.
2.1.4.3 Streamline plots
Again, before the user continues to post-process in ParaView, they should disable modules
such as those for the vector plot described above. We now wish to plot a streamlines of
velocity as described in section 6.1.8.
With the cavity.OpenFOAM module highlighted in the Pipeline Browser, the user
should then select Stream Tracer from the Filter menu and then click Apply. The
Properties window panel should appear as shown in Figure 2.8. The Seed points should
be specified along a Line Source running vertically through the centre of the geometry,
i.e. from (0.05,0,0.005) to (0.05,0.1,0.005). For the image in this guide we used: a point
Resolution of 21; Max Propagation by Length 0.5; Initial Step Length by Cell Length 0.01;
and, Integration Direction BOTH. The Runge-Kutta 2 IntegratorType was used with
default parameters.
On clicking Apply the tracer is generated. The user should then select Tube from the
Filter menu to produce high quality streamline images. For the image in this report, we
used: Num. sides 6; Radius 0.0003; and, Radius factor 10. The streamtubes are coloured
by velocity magnitude. On clicking Apply the image in Figure 2.9 should be produced.
2.1.5 Increasing the mesh resolution
The mesh resolution will now be increased by a factor of two in each direction. The results
from the coarser mesh will be mapped onto the finer mesh to use as initial conditions for
the problem. The solution from the finer mesh will then be compared with those from
the coarser mesh.
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-31
Open Parameters panel
Set Integration Direction to BOTH
Set Max Propagation to Length 0.5
Set Initial Step Length to Cell Length 0.01
Specify Line Source and set points and resolution
Figure 2.8: Properties panel for the Stream Tracer filter.
Figure 2.9: Streamlines in the cavity case.
OpenFOAM-1.6
U-32 Tutorials
2.1.5.1 Creating a new case using an existing case
We now wish to create a new case named cavityFine that is created from cavity. The user
should therefore clone the cavity case and edit the necessary files. First the user should
create a new case directory at the same directory level as the cavity case, e.g.
cd $FOAM RUN/tutorials/incompressible/icoFoam
mkdir cavityFine
The user should then copy the base directories from the cavity case into cavityFine, and
then enter the cavityFine case.
cp -r cavity/constant cavityFine
cp -r cavity/system cavityFine
cd cavityFine
2.1.5.2 Creating the finer mesh
We now wish to increase the number of cells in the mesh by using blockMesh. The user
should open the blockMeshDict file in an editor and edit the block specification. The blocks
are specified in a list under the blocks keyword. The syntax of the block definitions is
described fully in section 5.3.1.3; at this stage it is sufficient to know that following hex
is first the list of vertices in the block, then a list (or vector) of numbers of cells in each
direction. This was originally set to (20 20 1) for the cavity case. The user should now
change this to (40 40 1) and save the file. The new refined mesh should then be created
by running blockMesh as before.
2.1.5.3 Mapping the coarse mesh results onto the fine mesh
The mapFields utility maps one or more fields relating to a given geometry onto the cor-
responding fields for another geometry. In our example, the fields are deemed ‘consistent’
because the geometry and the boundary types, or conditions, of both source and tar-
get fields are identical. We use the -consistent command line option when executing
mapFields in this example.
The field data that mapFields maps is read from the time directory specified by
startFrom/startTime in the controlDict of the target case, i.e. those into which the
results are being mapped. In this example, we wish to map the final results of the coarser
mesh from case cavity onto the finer mesh of case cavityFine. Therefore, since these re-
sults are stored in the 0.5 directory of cavity, the startTime should be set to 0.5 s in the
controlDict dictionary and startFrom should be set to startTime.
The case is ready to run mapFields. Typing mapFields -help quickly shows that map-
Fields requires the source case directory as an argument. We are using the -consistent
option, so the utility is executed from withing the cavityFine directory by
mapFields ../cavity -consistent
The utility should run with output to the terminal including:
Source: ".." "cavity"
Target: "." "cavityFine"
Create databases as time
Source time: 0.5
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-33
Target time: 0.5
Create meshes
Source mesh size: 400 Target mesh size: 1681
Consistently creating and mapping fields for time 0.5
interpolating p
interpolating U
End
2.1.5.4 Control adjustments
To maintain a Courant number of less that 1, as discussed in section 2.1.1.4, the time
step must now be halved since the size of all cells has halved. Therefore deltaT should
be set to to 0.0025 s in the controlDict dictionary. Field data is currently written out at
an interval of a fixed number of time steps. Here we demonstrate how to specify data
output at fixed intervals of time. Under the writeControl keyword in controlDict, instead
of requesting output by a fixed number of time steps with the timeStep entry, a fixed
amount of run time can be specified between the writing of results using the runTime
entry. In this case the user should specify output every 0.1 and therefore should set
writeInterval to 0.1 and writeControl to runTime. Finally, since the case is starting
with a the solution obtained on the coarse mesh we only need to run it for a short period
to achieve reasonable convergence to steady-state. Therefore the endTime should be set
to 0.7 s. Make sure these settings are correct and then save the file.
2.1.5.5 Running the code as a background process
The user should experience running icoFoam as a background process, redirecting the
terminal output to a log file that can be viewed later. From the cavityFine directory, the
user should execute:
icoFoam > log &
cat log
2.1.5.6 Vector plot with the refined mesh
The user can open multiple cases simultaneously in ParaView; essentially because each new
case is simply another module that appears in the Pipeline Browser. There is one minor
inconvenience when opening a new case in ParaView because there is a prerequisite that
the selected data is a file with a name that has an extension. However, in OpenFOAM,
each case is stored in a multitude of files with no extensions within a specific directory
structure. The solution, that the paraFoam script performs automatically, is to create
a dummy file with the extension .OpenFOAM — hence, the cavity case module is called
cavity.OpenFOAM.
However, if the user wishes to open another case directly from within ParaView, they
need to create such a dummy file. For example, to load the cavityFine case the file would
be created by typing at the command prompt:
cd $FOAM RUN/tutorials/incompressible/icoFoam
touch cavityFine/cavityFine.OpenFOAM
Now the cavityFine case can be loaded into ParaView by selecting Open from the File
menu, and having navigated the directory tree, selecting cavityFine.OpenFOAM. The user
OpenFOAM-1.6
U-34 Tutorials
Open Display panel
Select Scatter Plot
Select Ux from Line Series
Select arc length
Figure 2.10: Selecting fields for graph plotting.
can now make a vector plot of the results from the refined mesh in ParaView. The plot can
be compared with the cavity case by enabling glyph images for both case simultaneously.
2.1.5.7 Plotting graphs
The user may wish to visualise the results by extracting some scalar measure of velocity
and plotting 2-dimensional graphs along lines through the domain. OpenFOAM is well
equipped for this kind of data manipulation. There are numerous utilities that do spe-
cialised data manipulations, and some, simpler calculations are incorporated into a single
utility foamCalc. As a utility, it is unique in that it is executed by
foamCalc <calcType> <fieldName1 ... fieldNameN>
The calculator operation is specified in <calcType>; at the time of writing, the following
operations are implemented: addSubtract;randomise;div;components;mag;magGrad;
magSqr;interpolate. The user can obtain the list of <calcType>by deliberately calling
one that does not exist, so that foamCalc throws up an error message and lists the types
available, e.g.
>> foamCalc xxxx
Selecting calcType xxxx
unknown calcType type xxxx, constructor not in hash table
Valid calcType selections are:
8
(
randomise
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-35
magSqr
magGrad
addSubtract
div
mag
interpolate
components
)
The components and mag calcTypes provide usefu l scalar measures of velocity. When
foamCalc components U” is run on a case, say cavity, it reads in the velocity vector field
from each time directory and, in the corresponding time directories, writes scalar fields
Ux,Uy and Uz representing the x,yand zcomponents of velocity. Similarly foamCalc
mag U” writes a scalar field magU to each time directory representing the magnitude of
velocity.
The user can run foamCalc with the components calcType on both cavity and cavityFine
cases. For example, for the cavity case the user should execute the following command:
foamCalc components U -case $FOAM RUN/tutorials1.5/icoFoam/cavity
The individual components can be plotted as a graph in ParaView. It is quick, con-
venient and has reasonably good control over labelling and formatting, so the printed
output is a fairly good standard. However, to produce graphs for publication, users may
prefer to write raw data and plot it with a dedicated graphing tool, such as gnuplot or
Grace/xmgr. To do this, we recommend using the sample utility, described in section 6.5
and section 2.2.3.
Before commencing plotting, the user needs to load the newly generated Ux,Uy and Uz
fields into ParaView. To do this, the user should check the Update GUI button at the top
of the Properties panel of the base module they are working on, e.g.cavity.OpenFOAM.
Clicking Apply will then cause the new fields to be loaded into ParaView which will appear
in the Vol Field Status window. Ensure the new fields are selected and the changes
are applied, i.e. click Apply again if necessary. Also, data is interpolated incorrectly at
boundaries if the boundary regions are selected in the Region Status panel. Therefore the
user should deselect the patches in the Region Status panel, i.e.movingWall,fixedWall
and frontAndBack, and apply the changes.
Now, in order to display a graph in ParaView the user should select the module of inter-
est, e.g.cavity.OpenFOAM and apply the Plot Over Line filter from the Filter->Data
Analysis menu. This opens up a new XY Plot window beside the existing 3D View win-
dow. A ProbeLine module is created in which the user can specify the end points of the
line in the Properties panel. In this example, the user should position the line vertically
up the centre of the domain, i.e. from (0.05,0,0.005) to (0.05,0.1,0.005), in the Point1
and Point2 text boxes. The Resolution can be set to 100.
On clicking Apply, a graph is generated in the XY Plot window. In the Display panel,
the user should choose Scatter Plot from the Plot Type menu, with Attribute Mode
Point Data. The Use Data Array option can be selected for the X Axis Data, taking the
arc length option so that the x-axis of the graph represents distance from the base of
the cavity.
The user can choose the fields to be displayed in the Line Series panel of the Display
window. From the list of scalar fields to be displayed, it can be seen that the magnitude
and components of vector fields are available by default, e.g. displayed as U:X, so that
it was not necessary to create Ux using foamCalc. Nevertheless, the user should deselect
all series except Ux (or U:x). A square colour box in the adjacent column to the selected
series indicates the line colour. The user can edit this most easily by a double click of the
mouse over that selection.
OpenFOAM-1.6
U-36 Tutorials
Figure 2.11: Plotting graphs in paraFoam.
In order to format the graph, the user should move over to the XY Plot itself. Now,
with the cursor over the graph, the user can click the right mouse-button and select
Properties from the small floating menu produced. A Chart Options window appears
with General settings for title and legend and menus for each axis. The menu for each
axis can be expanded by a double click to reveal individual menus for Layout and Title,
one for each axis. The user can set font, colour and alignment of the axes titles, and has
several options for axis range and labels in linear or logarithmic scales.
Figure 2.11 is a graph produced using ParaView. The user can produce a graph how-
ever he/she wishes. For information, the graph in Figure 2.11 was produced with the
options for axes of: Standard type of Notation;Specify Axis Range selected; titles in
Sans Serif 12 font. The graph is displayed as a set of points rather than a line by acti-
vating the Enable Line Series button in the Display window. Note: if this button appears to
be inactive by being “greyed out”, it can be made active by selecting and deselecting the
sets of variables in the Line Series panel. Once the Enable Line Series button is selected,
the Line Style and Marker Style can be adjusted to the user’s preference.
2.1.6 Introducing mesh grading
The error in any solution will be more pronounced in regions where the form of the
true solution differ widely from the form assumed in the chosen numerical schemes. For
example a numerical scheme based on linear variations of variables over cells can only
generate an exact solution if the true solution is itself linear in form. The error is largest
in regions where the true solution deviates greatest from linear form, i.e. where the change
in gradient is largest. Error decreases with cell size.
It is useful to have an intuitive appreciation of the form of the solution before setting
up any problem. It is then possible to anticipate where the errors will be largest and
to grade the mesh so that the smallest cells are in these regions. In the cavity case the
large variations in velocity can be expected near a wall and so in this part of the tutorial
the mesh will be graded to be smaller in this region. By using the same number of cells,
greater accuracy can be achieved without a significant increase in computational cost.
A mesh of 20 ×20 cells with grading towards the walls will be created for the lid-
driven cavity problem and the results from the finer mesh of section 2.1.5.2 will then be
mapped onto the graded mesh to use as an initial condition. The results from the graded
mesh will be compared with those from the previous meshes. Since the changes to the
blockMeshDict dictionary are fairly substantial, the case used for this part of the tutorial,
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-37
cavityGrade, is supplied in the $FOAM RUN/tutorials/incompressible/icoFoam directory.
2.1.6.1 Creating the graded mesh
The mesh now needs 4 blocks as different mesh grading is needed on the left and right and
top and bottom of the domain. The block structure for this mesh is shown in Figure 2.12.
The user can view the blockMeshDict file in the constant/polyMesh subdirectory of cavi-
0
z
x
y
3 4 5
6 87
1 2
1715
911
10
16
12 13 14
0 1
2 3
Figure 2.12: Block structure of the graded mesh for the cavity (block numbers encircled).
tyGrade; for completeness the key elements of the blockMeshDict file are also reproduced
below. Each block now has 10 cells in the xand ydirections and the ratio between largest
and smallest cells is 2.
17 convertToMeters 0.1;
18
19 vertices
20 (
21 (0 0 0)
22 (0.5 0 0)
23 (1 0 0)
24 (0 0.5 0)
25 (0.5 0.5 0)
26 (1 0.5 0)
27 (0 1 0)
28 (0.5 1 0)
29 (1 1 0)
30 (0 0 0.1)
31 (0.5 0 0.1)
32 (1 0 0.1)
33 (0 0.5 0.1)
34 (0.5 0.5 0.1)
35 (1 0.5 0.1)
36 (0 1 0.1)
37 (0.5 1 0.1)
38 (1 1 0.1)
39 );
40
41 blocks
42 (
43 hex (0 1 4 3 9 10 13 12) (10 10 1) simpleGrading (2 2 1)
44 hex (1 2 5 4 10 11 14 13) (10 10 1) simpleGrading (0.5 2 1)
45 hex (3 4 7 6 12 13 16 15) (10 10 1) simpleGrading (2 0.5 1)
46 hex (4 5 8 7 13 14 17 16) (10 10 1) simpleGrading (0.5 0.5 1)
47 );
48
49 edges
50 (
51 );
52
53 patches
54 (
55 wall movingWall
56 (
OpenFOAM-1.6
U-38 Tutorials
57 (6 15 16 7)
58 (7 16 17 8)
59 )
60 wall fixedWalls
61 (
62 (3 12 15 6)
63 (0 9 12 3)
64 (0 1 10 9)
65 (1 2 11 10)
66 (2 5 14 11)
67 (5 8 17 14)
68 )
69 empty frontAndBack
70 (
71 (0 3 4 1)
72 (1 4 5 2)
73 (3 6 7 4)
74 (4 7 8 5)
75 (9 10 13 12)
76 (10 11 14 13)
77 (12 13 16 15)
78 (13 14 17 16)
79 )
80 );
81
82 mergePatchPairs
83 (
84 );
85
86 // ************************************************************************* //
Once familiar with the blockMeshDict file for this case, the user can execute blockMesh
from the command line. The graded mesh can be viewed as before using paraFoam as
described in section 2.1.2.
2.1.6.2 Changing time and time step
The highest velocities and smallest cells are next to the lid, therefore the highest Courant
number will be generated next to the lid, for reasons given in section 2.1.1.4. It is therefore
useful to estimate the size of the cells next to the lid to calculate an appropriate time
step for this case.
When a nonuniform mesh grading is used, blockMesh calculates the cell sizes using a
geometric progression. Along a length l, if ncells are requested with a ratio of Rbetween
the last and first cells, the size of the smallest cell, δxs, is given by:
δxs=lr1
αr 1(2.5)
where ris the ratio between one cell size and the next which is given by:
r=R1
n1(2.6)
and
α=(Rfor R > 1,
1rn+r1for R < 1.(2.7)
For the cavityGrade case the number of cells in each direction in a block is 10, the ratio
between largest and smallest cells is 2 and the block height and width is 0.05 m. Therefore
the smallest cell length is 3.45 mm. From Equation 2.2, the time step should be less than
3.45 ms to maintain a Courant of less than 1. To ensure that results are written out
at convenient time intervals, the time step deltaT should be reduced to 2.5 ms and the
writeInterval set to 40 so that results are written out every 0.1 s. These settings can
be viewed in the cavityGrade/system/controlDict file.
The startTime 6(e)0.04.2450]TJ/R386(yF.049408307((e)0.04.245089(t)-)0.21(a)-0.252204(vi)-0.043906(t)26.813(i8.245057(i),89(c)0.05 Td[(R56490113(k)0.0817.00.218509(s)-325.95(s)-0.726.064(-0.732019(a)-0182261064(-0.732013(.)0.218509]TJ-230.1600.57(t)-420.00113]TJ/R4.0113]TJ/R47t)-0.34307(ro)0.245057(l)-0.04498.46n)-326.29.245057(716S45057(t)-347.955(c)0.0d)-34e-3.34304(sm)-0.088833(a0.34300490-0.342058(e)-0.343 Tf82)-326.291(t)-0.147034(h)-0.311426(e)0.0490113]TJ/R387 1)5.97758 Tf4.59883 0 T3(t)(h)-381.22728(l)0.218509(a)0.245057(-0.147034(i)0.0.218509(s)-335.06.58217 7.40e)0.0-0.147)0.0494mTd[(6(e)0.04.2450]TJ/R387 1F.049404214((e)0.04.245089(t)-)0.21(a)-0.252204(vi)-0.043906(t)26.8506.217 7.40e)0.0-0.147)(t)-0.147034]TJ-363.141 -14.4449 Td[(a)0..9526(w)27.3774(e)0.0495218(.147034(e)0.)-0..055 -14.4453 Td[(b)-2757(l)0.218509(l)6 Td13(q)0.343079(u)-0.310405(e)0.0490113(5Td11.9551 Tf16.ne)0.5 mt. 0b14.44450.218509(l)0.21850490113(e)0.0490113(f9.50391 0 034(i)0e)0.04900490517.4443(e)0.0490113(n)-0.311426(i)0.218509R56490113(k)0.04401178]TJ/R575 (-0.7166.064(-0.737119(a)-018175064(-0.7371151 Tf24.759 0 Td[(1)0.049)-381.227.6(t)-0.14707(m)-0.0898541(s)-347.788(a)0.245057(n)-0.3)0.1364.256 0 T(i)-0.342569(w)-0.349011(st)-0.14703.4352 0 Td[(s)-0.3 Td[mw)-0.349011(a)-0.342058(r)-0.343079(t)-0.3440.1421-0.343079(t)-0.343079(a)-0.(t)-041(e)-286.008(st)-0.147034079(i8157.546(t)-0.147034(h)-0788(a)0.245057(n)-0.35355127(t)-420.00113]T Td[.0113]T Td[8a)-0.342058(r)-0.343079(t)-0.3498.46n cr3
2.1 Lid-driven cavity flow U-39
2.1.6.3 Mapping fields
As in section 2.1.5.3, use mapFields to map the final results from case cavityFine onto the
mesh for case cavityGrade. Enter the cavityGrade directory and execute mapFields by:
cd $FOAM RUN/tutorials/incompressible/icoFoam/cavityGrade
mapFields ../cavityFine -consistent
Now run icoFoam from the case directory and monitor the run time information. View
the converged results for this case and compare with other results using post-processing
tools described previously in section 2.1.5.6 and section 2.1.5.7.
2.1.7 Increasing the Reynolds number
The cases solved so far have had a Reynolds number of 10. This is very low and leads
to a stable solution quickly with only small secondary vortices at the bottom corners of
the cavity. We will now increase the Reynolds number to 50, at which point the solution
takes a noticeably longer time to converge. The coarsest mesh in case cavity will be used
initially. The user should make a copy of the cavity case and name it cavityHighRe by
typing:
cd $FOAM_RUN/tutorials/incompressible/icoFoam
cp -r cavity cavityHighRe
2.1.7.1 Pre-processing
Enter the the cavityHighRe case and edit the transportProperties dictionary. Since the
Reynolds number is required to be increased by a factor of 10, decrease the kinematic
viscosity by a factor of 10, i.e. to 1 ×103m2s1. We can now run this case by restarting
from the solution at the end of the cavity case run. To do this we can use the option of
setting the startFrom keyword to latestTime so that icoFoam takes as its initial data
the values stored in the directory corresponding to the most recent time, i.e. 0.5. The
endTime should be set to 2 s.
2.1.7.2 Running the code
Run icoFoam for this case from the case directory and view the run time information.
When running a job in the background, the following UNIX commands can be useful:
nohup enables a command to keep running after the user who issues the command has
logged out;
nice changes the priority of the job in the kernel’s scheduler; a niceness of -20 is the
highest priority and 19 is the lowest priority.
This is useful, for example, if a user wishes to set a case running on a remote machine
and does not wish to monitor it heavily, in which case they may wish to give it low
priority on the machine. In that case the nohup command allows the user to log out of a
remote machine he/she is running on and the job continues running, while nice can set
the priority to 19. For our case of interest, we can execute the command in this manner
as follows:
OpenFOAM-1.6
U-40 Tutorials
cd $FOAM RUN/tutorials/incompressible/icoFoam/cavityHighRe
nohup nice -n 19 icoFoam > log &
cat log
In previous runs you may have noticed that icoFoam stops solving for velocity Uquite
quickly but continues solving for pressure pfor a lot longer or until the end of the run.
In practice, once icoFoam stops solving for Uand the initial residual of pis less than
the tolerance set in the fvSolution dictionary (typically 106), the run has effectively
converged and can be stopped once the field data has been written out to a time directory.
For example, at convergence a sample of the log file from the run on the cavityHighRe
case appears as follows in which the velocity has already converged after 1.62 s and
initial pressure residuals are small; No Iterations 0 indicates that the solution of Uhas
stopped:
1
2Time = 1.63
3
4Courant Number mean: 0.108642 max: 0.818175
5DILUPBiCG: Solving for Ux, Initial residual = 7.86044e-06, Final residual = 7.86044e-06,
6No Iterations 0
7DILUPBiCG: Solving for Uy, Initial residual = 9.4171e-06, Final residual = 9.4171e-06,
8No Iterations 0
9DICPCG: Solving for p, Initial residual = 3.54721e-06, Final residual = 7.13506e-07,
10 No Iterations 4
11 time step continuity errors : sum local = 6.46788e-09, global = -9.44516e-19,
12 cumulative = 1.04595e-17
13 DICPCG: Solving for p, Initial residual = 2.15824e-06, Final residual = 9.95068e-07,
14 No Iterations 3
15 time step continuity errors : sum local = 8.67501e-09, global = 7.54182e-19,
16 cumulative = 1.12136e-17
17 ExecutionTime = 1.02 s ClockTime = 1 s
18
19 Time = 1.635
20
21 Courant Number mean: 0.108643 max: 0.818176
22 DILUPBiCG: Solving for Ux, Initial residual = 7.6728e-06, Final residual = 7.6728e-06,
23 No Iterations 0
24 DILUPBiCG: Solving for Uy, Initial residual = 9.19442e-06, Final residual = 9.19442e-06,
25 No Iterations 0
26 DICPCG: Solving for p, Initial residual = 3.13107e-06, Final residual = 8.60504e-07,
27 No Iterations 4
28 time step continuity errors : sum local = 8.15435e-09, global = -5.84817e-20,
29 cumulative = 1.11552e-17
30 DICPCG: Solving for p, Initial residual = 2.16689e-06, Final residual = 5.27197e-07,
31 No Iterations 14
32 time step continuity errors : sum local = 3.45666e-09, global = -5.62297e-19,
33 cumulative = 1.05929e-17
34 ExecutionTime = 1.02 s ClockTime = 1 s
2.1.8 High Reynolds number flow
View the results in paraFoam and display the velocity vectors. The secondary vortices in
the corners have increased in size somewhat. The user can then increase the Reynolds
number further by decreasing the viscosity and then rerun the case. The number of
vortices increases so the mesh resolution around them will need to increase in order to
resolve the more complicated flow patterns. In addition, as the Reynolds number increases
the time to convergence increases. The user should monitor residuals and extend the
endTime accordingly to ensure convergence.
The need to increase spatial and temporal resolution then becomes impractical as
the flow moves into the turbulent regime, where problems of solution stability may also
occur. Of course, many engineering problems have very high Reynolds numbers and it
is infeasible to bear the huge cost of solving the turbulent behaviour directly. Instead
Reynolds-averaged stress (RAS) turbulence models are used to solve for the mean flow
behaviour and calculate the statistics of the fluctuations. The standard kεmodel
with wall functions will be used in this tutorial to solve the lid-driven cavity case with
a Reynolds number of 104. Two extra variables are solved for: k, the turbulent kinetic
energy; and, ε, the turbulent dissipation rate. The additional equations and models for
turbulent flow are implemented into a OpenFOAM solver called pisoFoam.
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-41
2.1.8.1 Pre-processing
Change directory to the cavity case in the $FOAM RUN/tutorials/incompressible/pisoFoam/-
ras directory (N.B: the pisoFoam/ras directory). Generate the mesh by running blockMesh
as before. Mesh grading towards the wall is not necessary when using the standard kε
model with wall functions since the flow in the near wall cell is modelled, rather than
having to be resolved.
From version 1.6 onwards, a range of wall function models is available in OpenFOAM
that are applied as boundary conditions on individual patches. This enables different
wall function models to be applied to different wall regions. The choice of wall function
models are specified through the turbulent viscosity field, νtin the 0/nut file:
17
18 dimensions [0 2 -1 0 0 0 0];
19
20 internalField uniform 0;
21
22 boundaryField
23 {
24 movingWall
25 {
26 type nutWallFunction;
27 value uniform 0;
28 }
29 fixedWalls
30 {
31 type nutWallFunction;
32 value uniform 0;
33 }
34 frontAndBack
35 {
36 type empty;
37 }
38 }
39
40
41 // ************************************************************************* //
This case uses standard wall functions, specified by the nutWallFunction keyword entry
one the movingWall and fixedWalls patches. Other wall function models include the
rough wall functions, specified though the nutRoughWallFunction keyword.
The user should now open the field files for kand ε(0/k and 0/epsilon) and examine
their boundary conditions. For a wall boundary condition, εis assigned a epsilonWall-
Function boundary condition and a kqRwallFunction boundary condition is assigned to k.
The latter is a generic boundary condition that can be applied to any field that are of a
turbulent kinetic energy type, e.g. k,qor Reynolds Stress R. The initial values for kand
εare set using an estimated fluctuating component of velocity Uand a turbulent length
scale, l.kand εare defined in terms of these parameters as follows:
k=1
2UU(2.8)
ε=C0.75
µk1.5
l(2.9)
where Cµis a constant of the kεmodel equal to 0.09. For a Cartesian coordinate
system, kis given by:
k=1
2(U2
x+U2
y+U2
z) (2.10)
where U2
x,U2
yand U2
zare the fluctuating components of velocity in the x,yand z
directions respectively. Let us assume the initial turbulence is isotropic, i.e. U2
x=U2
y=
U2
z, and equal to 5% of the lid velocity and that l, is equal to 20% of the box width, 0.1
OpenFOAM-1.6
U-42 Tutorials
m, then kand εare given by:
U
x=U
y=U
z=5
1001 m s1(2.11)
k=3
2µ5
1002
m2s2= 3.75 ×103m2s2(2.12)
ε=C0.75
µk1.5
l7.65 ×104m2s3(2.13)
These form the initial conditions for kand ε. The initial conditions for Uand pare
(0,0,0) and 0 respectively as before.
Prior to version 1.6 of OpenFOAM, the type of turbulence modelling method, e.g.
RAS or large-eddy simulation (LES), was declared within each solver. This resulted in
a lot of duplication of code in solver applications, where for most solvers that used RAS
turbulence modelling, there would be an equivalent LES solver.
From version 1.6 however, the choice of turbulence modelling method is selectable at
run-time through the simulationType keyword in turbulenceProperties dictionary. The
user can view this file in the constant directory:
17
18 simulationType RASModel;
19
20
21 // ************************************************************************* //
The options for simulationType are laminar,RASmodel and LESmodel. With RASmodel
selected in this case, the choice of RAS modelling is specified in a RASProperties file, also
in the constant directory. The turbulence model is selected by the RASModel entry from a
long list of available models that are listed in Table 3.9. The kEpsilon model should be
selected which is is the standard kεmodel; the user should also ensure that turbulence
calculation is switched on.
The coefficients for each turbulence model are stored within the respective code with
a set of default values. Setting the optional switch called printCoeffs to on will make
the default values be printed to standard output, i.e. the terminal, when the model
is called at run time. The coefficients are printed out as a subdictionary whose name
is that of the model name with the word Coeffs appended, e.g. kEpsilonCoeffs in
the case of the kEpsilon model. The coefficients of the model, e.g. kEpsilon, can be
modified by optionally including that subdictionary within the RASProperties dictionary
and adjusting values accordingly.
The user should next set the laminar kinematic viscosity in the transportProperties
dictionary. To achieve a Reynolds number of 104, a kinematic viscosity of 105m is
required based on the Reynolds number definition given in Equation 2.1.
Finally the user should set the startTime,stopTime,deltaT and the writeInterval
in the controlDict. Set deltaT to 0.005 s to satisfy the Courant number restriction and
the endTime to 10 s.
2.1.8.2 Running the code
Execute pisoFoam by entering the case directory and typing “pisoFoam”. In this case,
where the viscosity is low, the boundary layer next to the moving lid is very thin and
the cells next to the lid are comparatively large so the velocity at their centres are much
less than the lid velocity. In fact, after
2.1 Lid-driven cavity flow U-43
the solution time by increasing the time step to a level where the Courant number is
much closer to 1. Therefore reset deltaT to 0.02 s and, on this occasion, set startFrom
to latestTime. This instructs pisoFoam to read the start data from the latest time
directory, i.e.10.0. The endTime should be set to 20 s since the run converges a lot slower
than the laminar case. Restart the run as before and monitor the convergence of the
solution. View the results at consecutive time steps as the solution progresses to see if
the solution converges to a steady-state or perhaps reaches some periodically oscillating
state. In the latter case, convergence may never occur but this does not mean the results
are inaccurate.
2.1.9 Changing the case geometry
A user may wish to make changes to the geometry of a case and perform a new simulation.
It may be useful to retain some or all of the original solution as the starting conditions
for the new simulation. This is a little complex because the fields of the original solution
are not consistent with the fields of the new case. However the mapFields utility can map
fields that are inconsistent, either in terms of geometry or boundary types or both.
As an example, let us go to the cavityClipped case in the icoFoam directory which
consists of the standard cavity geometry but with a square of length 0.04 m removed from
the bottom right of the cavity, according to the blockMeshDict below:
17 convertToMeters 0.1;
18
19 vertices
20 (
21 (0 0 0)
22 (0.6 0 0)
23 (0 0.4 0)
24 (0.6 0.4 0)
25 (1 0.4 0)
26 (0 1 0)
27 (0.6 1 0)
28 (1 1 0)
29
30 (0 0 0.1)
31 (0.6 0 0.1)
32 (0 0.4 0.1)
33 (0.6 0.4 0.1)
34 (1 0.4 0.1)
35 (0 1 0.1)
36 (0.6 1 0.1)
37 (1 1 0.1)
38
39 );
40
41 blocks
42 (
43 hex (0 1 3 2 8 9 11 10) (12 8 1) simpleGrading (1 1 1)
44 hex (2 3 6 5 10 11 14 13) (12 12 1) simpleGrading (1 1 1)
45 hex (3 4 7 6 11 12 15 14) (8 12 1) simpleGrading (1 1 1)
46 );
47
48 edges
49 (
50 );
51
52 patches
53 (
54 wall lid
55 (
56 (5 13 14 6)
57 (6 14 15 7)
58 )
59 wall fixedWalls
60 (
61 (0 8 10 2)
62 (2 10 13 5)
63 (7 15 12 4)
64 (4 12 11 3)
65 (3 11 9 1)
66 (1 9 8 0)
67 )
OpenFOAM-1.6
U-44 Tutorials
68 empty frontAndBack
69 (
70 (0 2 3 1)
71 (2 5 6 3)
72 (3 6 7 4)
73 (8 9 11 10)
74 (10 11 14 13)
75 (11 12 15 14)
76 )
77 );
78
79 mergePatchPairs
80 (
81 );
82
83 // ************************************************************************* //
Generate the mesh with blockMesh. The patches are set accordingly as in previous cavity
cases. For the sake of clarity in describing the field mapping process, the upper wall patch
is renamed lid, previously the movingWall patch of the original cavity.
In an inconsistent mapping, there is no guarantee that all the field data can be mapped
from the source case. The remaining data must come from field files in the target case
itself. Therefore field data must exist in the time directory of the target case before
mapping takes place. In the cavityClipped case the mapping is set to occur at time 0.5 s,
since the startTime is set to 0.5 s in the controlDict. Therefore the user needs to copy
initial field data to that directory, e.g. from time 0:
cd $FOAM RUN/tutorials/incompressible/icoFoam/cavityClipped
cp -r 0 0.5
Before mapping the data, the user should view the geometry and fields at 0.5 s.
Now we wish to map the velocity and pressure fields from cavity onto the new fields
of cavityClipped. Since the mapping is inconsistent, we need to edit the mapFieldsDict
dictionary, located in the system directory. The dictionary contains 2 keyword entries:
patchMap and cuttingPatches. The patchMap list contains a mapping of patches from
the source fields to the target fields. It is used if the user wishes a patch in the target
field to inherit values from a corresponding patch in the source field. In cavityClipped, we
wish to inherit the boundary values on the lid patch from movingWall in cavity so we
must set the patchMap as:
patchMap
(
lid movingWall
);
The cuttingPatches list contains names of target patches whose values are to be
mapped from the source internal field through which the target patch cuts. In this case
we will include the fixedWalls to demonstrate the interpolation process.
cuttingPatches
(
fixedWalls
);
Now the user should run mapFields, from within the cavityClipped directory:
mapFields ../cavity
OpenFOAM-1.6
2.1 Lid-driven cavity flow U-45
Figure 2.13: cavity solution velocity field mapped onto cavityClipped.
Figure 2.14: cavityClipped solution for velocity field.
OpenFOAM-1.6
U-46 Tutorials
The user can view the mapped field as shown in Figure 2.13. The boundary patches
have inherited values from the source case as we expected. Having demonstrated this,
however, we actually wish to reset the velocity on the fixedWalls patch to (0,0,0). Edit
the Ufield, go to the fixedWalls patch and change the field from nonuniform to uniform
(0,0,0). The nonuniform field is a list of values that requires deleting in its entirety. Now
run the case with icoFoam.
2.1.10 Post-processing the modified geometry
Velocity glyphs can be generated for the case as normal, first at time 0.5 s and later at
time 0.6 s, to compare the initial and final solutions. In addition, we provide an outline of
the geometry which requires some care to generate for a 2D case. The user should select
Extract Block from the Filter menu and, in the Parameter panel, highlight the patches
of interest, namely the lid and fixedWalls. On clicking Apply, these items of geometry can
be displayed by selecting Wireframe in the Display panel. Figure 2.14 displays the patches
in black and shows vortices forming in the bottom corners of the modified geometry.
2.2 Stress analysis of a plate with a hole
This tutorial describes how to pre-process, run and post-process a case involving linear-
elastic, steady-state stress analysis on a square plate with a circular hole at its centre.
The plate dimensions are: side length 4 m and radius R= 0.5 m. It is loaded with a
uniform traction of σ= 10 kPa over its left and right faces as shown in Figure 2.15. Two
symmetry planes can be identified for this geometry and therefore the solution domain
need only cover a quarter of the geometry, shown by the shaded area in Figure 2.15.
xsymmetry plane
4.0 m
y
σ= 10 kPa
σ= 10 kPa
R= 0.5 m
symmetry plane
Figure 2.15: Geometry of the plate with a hole.
The problem can be approximated as 2-dimensional since the load is applied in the
plane of the plate. In a Cartesian coordinate system there are two possible assumptions
to take in regard to the behaviour of the structure in the third dimension: (1) the plane
OpenFOAM-1.6
2.2 Stress analysis of a plate with a hole U-47
stress condition, in which the stress components acting out of the 2D plane are assumed
to be negligible; (2) the plane strain condition, in which the strain components out of
the 2D plane are assumed negligible. The plane stress condition is appropriate for solids
whose third dimension is thin as in this case; the plane strain condition is applicable for
solids where the third dimension is thick.
An analytical solution exists for loading of an infinitely large, thin plate with a circular
hole. The solution for the stress normal to the vertical plane of symmetry is
(σxx)x=0 =
σµ1 + R2
2y2+3R4
2y4for |y| ≥ R
U-48 Tutorials
x
y x2
x1x1
x2
x2
x1
x1
x2
x2
x1
left
left
up 7up
right
3
down
hole
0
down
right
6
9
8
4
10
10 2
5
2
1
4 3
Figure 2.16: Block structure of the mesh for the plate with a hole.
52 );
53
54 edges
55 (
56 arc 0 5 (0.469846 0.17101 0)
57 arc 5 10 (0.17101 0.469846 0)
58 arc 1 4 (0.939693 0.34202 0)
59 arc 4 9 (0.34202 0.939693 0)
60 arc 11 16 (0.469846 0.17101 0.5)
61 arc 16 21 (0.17101 0.469846 0.5)
62 arc 12 15 (0.939693 0.34202 0.5)
63 arc 15 20 (0.34202 0.939693 0.5)
64 );
65
66 patches
67 (
68 symmetryPlane left
69 (
70 (8 9 20 19)
71 (9 10 21 20)
72 )
73 patch right
74 (
75 (2 3 14 13)
76 (3 6 17 14)
77 )
78 symmetryPlane down
79 (
80 (0 1 12 11)
81 (1 2 13 12)
82 )
83 patch up
84 (
85 (7 8 19 18)
86 (6 7 18 17)
87 )
88 patch hole
89 (
90 (10 5 16 21)
OpenFOAM-1.6
2.2 Stress analysis of a plate with a hole U-49
91 (5 0 11 16)
92 )
93 empty frontAndBack
94 (
95 (10 9 4 5)
96 (5 4 1 0)
97 (1 4 3 2)
98 (4 7 6 3)
99 (4 9 8 7)
100 (21 16 15 20)
101 (16 11 12 15)
102 (12 13 14 15)
103 (15 14 17 18)
104 (15 18 19 20)
105 )
106 );
107
108 mergePatchPairs
109 (
110 );
111
112 // ************************************************************************* //
Until now, we have only specified straight edges in the geometries of previous tutorials but
here we need to specify curved edges. These are specified under the edges keyword entry
which is a list of non-straight edges. The syntax of each list entry begins with the type
of curve, including arc,simpleSpline,polyLine etc., described further in section 5.3.1.
In this example, all the edges are circular and so can be specified by the arc keyword
entry. The following entries are the labels of the start and end vertices of the arc and a
point vector through which the circular arc passes.
The blocks in this blockMeshDict do not all have the same orientation. As can be seen
in Figure 2.16 the x2direction of block 0 is equivalent to the x1direction for block 4.
This means care must be taken when defining the number and distribution of cells in each
block so that the cells match up at the block faces.
6 patches are defined: one for each side of the plate, one for the hole and one for the
front and back planes. The left and down patches are both a symmetry plane. Since this
is a geometric constraint, it is included in the definition of the mesh, rather than being
purely a specification on the boundary condition of the fields. Therefore they are defined
as such using a special symmetryPlane type as shown in the blockMeshDict.
The frontAndBack patch represents the plane which is ignored in a 2D case. Again
this is a geometric constraint so is defined within the mesh, using the empty type as shown
in the blockMeshDict. For further details of boundary types and geometric constraints,
the user should refer to section 5.2.1.
The remaining patches are of the regular patch type. The mesh should be generated
using blockMesh and can be viewed in paraFoam as described in section 2.1.2. It should
appear as in Figure 2.17.
2.2.1.1 Boundary and initial conditions
Once the mesh generation is complete, the initial field with boundary conditions must be
set. For a stress analysis case without thermal stresses, only displacement Dneeds to be
set. The 0/D is as follows:
17 dimensions [0 1 0 0 0 0 0];
18
19 internalField uniform (0 0 0);
20
21 boundaryField
22 {
23 left
24 {
25 type symmetryPlane;
26 }
27 right
28 {
OpenFOAM-1.6
U-50 Tutorials
Figure 2.17: Mesh of the hole in a plate problem.
29 type tractionDisplacement;
30 traction uniform ( 10000 0 0 );
31 pressure uniform 0;
32 value uniform (0 0 0);
33 }
34 down
35 {
36 type symmetryPlane;
37 }
38 up
39 {
40 type tractionDisplacement;
41 traction uniform ( 0 0 0 );
42 pressure uniform 0;
43 value uniform (0 0 0);
44 }
45 hole
46 {
47 type tractionDisplacement;
48 traction uniform ( 0 0 0 );
49 pressure uniform 0;
50 value uniform (0 0 0);
51 }
52 frontAndBack
53 {
54 type empty;
55 }
56 }
57
58 // ************************************************************************* //
Firstly, it can be seen that the displacement initial conditions are set to (0,0,0) m. The
left and down patches must be both of symmetryPlane type since they are specified
as such in the mesh description in the constant/polyMesh/boundary file. Similarly the
frontAndBack patch is declared empty.
The other patches are traction boundary conditions, set by a specialist traction bound-
ary type. The traction boundary conditions are specified by a linear combination of: (1)
a boundary traction vector under keyword traction; (2) a pressure that produces a trac-
tion normal to the boundary surface that is defined as negative when pointing out of
the surface, under keyword pressure. The up and hole patches are zero traction so the
boundary traction and pressure are set to zero. For the right patch the traction should
be (1e4,0,0) Pa and the pressure should be 0 Pa.
OpenFOAM-1.6
2.2 Stress analysis of a plate with a hole U-51
2.2.1.2 Mechanical properties
The physical properties for the case are set in the mechanicalProperties dictionary in the
constant directory. For this problem, we need to specify the mechanical properties of
steel given in Table 2.1. In the mechanical properties dictionary, the user must also set
planeStress to yes.
Property Units Keyword Value
Density kg m3rho 7854
Young’s modulus Pa E2×1011
Poisson’s ratio nu 0.3
Table 2.1: Mechanical properties for steel
2.2.1.3 Thermal properties
The temperature field variable Tis present in the solidDisplacementFoam solver since the
user may opt to solve a thermal equation that is coupled with the momentum equation
through the thermal stresses that are generated. The user specifies at run time whether
OpenFOAM should solve the thermal equation by the thermalStress switch in the ther-
malProperties dictionary. This dictionary also sets the thermal properties for the case,
e.g. for steel as listed in Table 2.2.
Property Units Keyword Value
Specific heat capacity Jkg1K1C434
Thermal conductivity Wm1K1k60.5
Thermal expansion coeff. K1alpha 1.1×105
Table 2.2: Thermal properties for steel
In this case we do not want to solve for the thermal equation. Therefore we must set
the thermalStress keyword entry to no in the thermalProperties dictionary.
2.2.1.4 Control
As before, the information relating to the control of the solution procedure are read in
from the controlDict dictionary. For this case, the startTime is 0 s. The time step is
not important since this is a steady state case; in this situation it is best to set the time
step deltaT to 1 so it simply acts as an iteration counter for the steady-state case. The
endTime, set to 100, then acts as a limit on the number of iterations. The writeInterval
can be set to 20.
The controlDict entries are as follows:
17
18 application solidDisplacementFoam;
19
20 startFrom startTime;
21
22 startTime 0;
23
24 stopAt endTime;
25
26 endTime 100;
27
28 deltaT 1;
29
30 writeControl timeStep;
OpenFOAM-1.6
U-52 Tutorials
31
32 writeInterval 20;
33
34 purgeWrite 0;
35
36 writeFormat ascii;
37
38 writePrecision 6;
39
40 writeCompression uncompressed;
41
42 timeFormat general;
43
44 timePrecision 6;
45
46 graphFormat raw;
47
48 runTimeModifiable yes;
49
50
51 // ************************************************************************* //
2.2.1.5 Discretisation schemes and linear-solver control
Let us turn our attention to the fvSchemes dictionary. Firstly, the problem we are
analysing is steady-state so the user should select SteadyState for the time derivatives
in timeScheme. This essentially switches off the time derivative terms. Not all solvers,
especially in fluid dynamics, work for both steady-state and transient problems but solid-
DisplacementFoam does work, since the base algorithm is the same for both types of
simulation.
The momentum equation in linear-elastic stress analysis includes several explicit terms
containing the gradient of displacement. The calculations benefit from accurate and
smooth evaluation of the gradient. Normally, in the finite volume method the discreti-
sation is based on Gauss’s theorem The Gauss method is sufficiently accurate for most
purposes but, in this case, the least squares method will be used. The user should there-
fore open the fvSchemes dictionary in the system directory and ensure the leastSquares
method is selected for the grad(U) gradient discretisation scheme in the gradSchemes
sub-dictionary:
17
18 d2dt2Schemes
19 {
20 default steadyState;
21 }
22
23 gradSchemes
24 {
25 default leastSquares;
26 grad(D) leastSquares;
27 grad(T) leastSquares;
28 }
29
30 divSchemes
31 {
32 default none;
33 div(sigmaD) Gauss linear;
34 }
35
36 laplacianSchemes
37 {
38 default none;
39 laplacian(DD,D) Gauss linear corrected;
40 laplacian(DT,T) Gauss linear corrected;
41 }
42
43 interpolationSchemes
44 {
45 default linear;
46 }
47
48 snGradSchemes
49 {
50 default none;
OpenFOAM-1.6
2.2 Stress analysis of a plate with a hole U-53
51 }
52
53 fluxRequired
54 {
55 default no;
56 D yes;
57 T no;
58 }
59
60
61 // ************************************************************************* //
The fvSolution dictionary in the system directory controls the linear equation solvers and
algorithms used in the solution. The user should first look at the solvers sub-dictionary
and notice that the choice of solver for Dis GAMG. The solver tolerance should be set to
106for this problem. The solver relative tolerance, denoted by relTol, sets the required
reduction in the residuals within each iteration. It is uneconomical to set a tight (low)
relative tolerance within each iteration since a lot of terms in each equation are explicit
and are updated as part of the segregated iterative procedure. Therefore a reasonable
value for the relative tolerance is 0.01, or possibly even higher, say 0.1, or in some cases
even 0.9 (as in this case).
17
18 solvers
19 {
20 D
21 {
22 solver GAMG;
23 tolerance 1e-06;
24 relTol 0.9;
25 smoother GaussSeidel;
26 cacheAgglomeration true;
27 nCellsInCoarsestLevel 20;
28 agglomerator faceAreaPair;
29 mergeLevels 1;
30 }
31
32 T
33 {
34 solver GAMG;
35 tolerance 1e-06;
36 relTol 0.9;
37 smoother GaussSeidel;
38 cacheAgglomeration true;
39 nCellsInCoarsestLevel 20;
40 agglomerator faceAreaPair;
41 mergeLevels 1;
42 }
43 }
44
45 stressAnalysis
46 {
47 compactNormalStress yes;
48 nCorrectors 1;
49 D 1e-06;
50 }
51
52
53 // ************************************************************************* //
The fvSolution dictionary contains a sub-dictionary, stressAnalysis that contains some con-
trol parameters specific to the application solver. Firstly there is nCorrectors which
specifies the number of outer loops around the complete system of equations, including
traction boundary conditions within each time step. Since this problem is steady-state,
we are performing a set of iterations towards a converged solution with the ’time step’
acting as an iteration counter. We can therefore set nCorrectors to 1.
The Dkeyword specifies a convergence tolerance for the outer iteration loop, i.e. sets
a level of initial residual below which solving will cease. It should be set to the desired
solver tolerance specified earlier, 106for this problem.
OpenFOAM-1.6
U-54 Tutorials
2.2.2 Running the code
The user should run the code here in the background from the command line as specified
below, so he/she can look at convergence information in the log file afterwards.
cd $FOAM RUN/tutorials/stressAnalysis/solidDisplacementFoam/plateHole
solidDisplacementFoam > log &
The user should check the convergence information by viewing the generated log file which
shows the number of iterations and the initial and final residuals of the displacement in
each direction being solved. The final residual should always be less than 0.9 times the
initial residual as this iteration tolerance set. Once both initial residuals have dropped
below the convergence tolerance of 106the run has converged and can be stopped by
killing the batch job.
2.2.3 Post-processing
Post processing can be performed as in section 2.1.4. The solidDisplacementFoam solver
outputs the stress field σas a symmetric tensor field sigma. This is consistent with the
way variables are usually represented in OpenFOAM solvers by the mathematical symbol
by which they are represented; in the case of Greek symbols, the variable is named
phonetically.
For post-processing individual scalar field components, σxx,σxy etc., can be generated
by running the foamCalc utility as before in section 2.1.5.7, this time on sigma:
foamCalc components sigma
Components named sigmaxx,sigmaxy etc. are written to time directories of the case.
The σxx stresses can be viewed in paraFoam as shown in Figure 2.18.
0
5
10
15
20
25
30
σxx (kPa)
Figure 2.18: σxx stress field in the plate with hole.
We would like to compare the analytical solution of Equation 2.14 to our solution.
We therefore must output a set of data of σxx along the left edge symmetry plane of
our domain. The user may generate the required graph data using the sample utility.
The utility uses a sampleDict dictionary located in the system directory, whose entries are
summarised in Table 6.3. The sample line specified in sets is set between (0.0,0.5,0.25)
and (0.0,2.0,0.25), and the fields are specified in the fields list:
OpenFOAM-1.6
2.2 Stress analysis of a plate with a hole U-55
0
5
10
15
20
25
30
35
0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0
Stress (σxx)x=0 (kPa)
Distance, y(m)
Numerical prediction Analytical solution
Figure 2.19: Normal stress along the vertical symmetry (σxx)x=0
17
18 interpolationScheme cellPoint;
19
20 setFormat raw;
21
22 sets
23 (
24 leftPatch
25 {
26 type uniform;
27 axis y;
28 start ( 0 0.5 0.25 );
29 end ( 0 2 0.25 );
30 nPoints 100;
31 }
32 );
33
34 surfaces ();
35
36 fields ( sigmaxx );
37
38
39 // ************************************************************************* //
The user should execute sample as normal. The writeFormat is raw 2 column format.
The data is written into files within time subdirectories of a sets directory, e.g. the data
at t= 100 s is found within the file sets/100/leftPatch sigmaxx.xy. In an application such
as GnuPlot, one could type the following at the command prompt would be sufficient to
plot both the numerical data and analytical solution:
plot [0.5:2] [0:] ’sets/100/leftPatch sigmaxx.xy’,
1e4*(1+(0.125/(x**2))+(0.09375/(x**4)))
An example plot is shown in Figure 2.19.
2.2.4 Exercises
The user may wish to experiment with solidDisplacementFoam by trying the following
exercises:
2.2.4.1 Increasing mesh resolution
Increase the mesh resolution in each of the xand ydirections. Use mapFields to map the
final coarse mesh results from section 2.2.3 to the initial conditions for the fine mesh.
OpenFOAM-1.6
U-56 Tutorials
2.2.4.2 Introducing mesh grading
Grade the mesh so that the cells near the hole are finer than those away from the hole.
Design the mesh so that the ratio of sizes between adjacent cells is no more than 1.1
and so that the ratio of cell sizes between blocks is similar to the ratios within blocks.
Mesh grading is described in section 2.1.6. Again use mapFields to map the final coarse
mesh results from section 2.2.3 to the initial conditions for the graded mesh. Compare
the results with those from the analytical solution and previous calculations. Can this
solution be improved upon using the same number of cells with a different solution?
2.2.4.3 Changing the plate size
The analytical solution is for an infinitely large plate with a finite sized hole in it. There-
fore this solution is not completely accurate for a finite sized plate. To estimate the error,
increase the plate size while maintaining the hole size at the same value.
2.3 Breaking of a dam
In this tutorial we shall solve a problem of simplified dam break in 2 dimensions using
the interFoam.The feature of the problem is a transient flow of two fluids separated by
a sharp interface, or free surface. The two-phase algorithm in interFoam is based on the
volume of fluid (VOF) method in which a specie transport equation is used to determine
the relative volume fraction of the two phases, or phase fraction α1, in each computational
cell. Physical properties are calculated as weighted averages based on this fraction. The
nature of the VOF method means that an interface between the species is not explicitly
computed, but rather emerges as a property of the phase fraction field. Since the phase
fraction can have any value between 0 and 1, the interface is never sharply defined, but
occupies a volume around the region where a sharp interface should exist.
The test setup consists of a column of water at rest located behind a membrane on
the left side of a tank. At time t= 0 s, the membrane is removed and the column of
water collapses. During the collapse, the water impacts an obstacle at the bottom of the
tank and creates a complicated flow structure, including several captured pockets of air.
The geometry and the initial setup is shown in Figure 2.20.
2.3.1 Mesh generation
The user should go to the damBreak case in their $FOAM RUN/tutorials/multiphase/inter-
Foam/laminar directory. Generate the mesh running blockMesh as described previously.
The damBreak mesh consist of 5 blocks; the blockMeshDict entries are given below.
17 convertToMeters 0.146;
18
19 vertices
20 (
21 (0 0 0)
22 (2 0 0)
23 (2.16438 0 0)
24 (4 0 0)
25 (0 0.32876 0)
26 (2 0.32876 0)
27 (2.16438 0.32876 0)
28 (4 0.32876 0)
29 (0 4 0)
30 (2 4 0)
31 (2.16438 4 0)
32 (4 4 0)
33 (0 0 0.1)
34 (2 0 0.1)
35 (2.16438 0 0.1)
OpenFOAM-1.6
2.3 Breaking of a dam U-57
U-58 Tutorials
83 (9 21 22 10)
84 (10 22 23 11)
85 )
86 );
87
88 mergePatchPairs
89 (
90 );
91
92 // ************************************************************************* //
2.3.2 Boundary conditions
The user can examine the boundary geometry generated by blockMesh by viewing the
boundary file in the constant/polyMesh directory. The file contains a list of 5 boundary
patches: leftWall,rightWall,lowerWall,atmosphere and defaultFaces. The user
should notice the type of the patches. The atmosphere is a standard patch,i.e. has no
special attributes, merely an entity on which boundary conditions can be specified. The
defaultFaces patch is empty since the patch normal is in the direction we will not solve
in this 2D case. The leftWall,rightWall and lowerWall patches are each a wall. Like
the plain patch, the wall type contains no geometric or topological information about the
mesh and only differs from the plain patch in that it identifies the patch as a wall, should
an application need to know, e.g. to apply special wall surface modelling.
A good example is that the interFoam solver includes modelling of surface tension at
the contact point between the interface and wall surface. The models are applied by
specifying the alphaContactAngle boundary condition on the alpha1 (α1) field. With it,
the user must specify the following: a static contact angle, theta0 θ0; leading and trailing
edge dynamic contact angles, thetaA θAand thetaR θRrespectively; and a velocity scaling
function for dynamic contact angle, uTheta.
In this tutorial we would like to ignore surface tension effects between the wall and
interface. We can do this by setting the static contact angle, θ0= 90and the velocity
scaling function to 0. However, the simpler option which we shall choose here is to specify
azeroGradient type on alpha1, rather than use the alphaContactAngle boundary condition.
The top boundary is free to the atmosphere and so is given an atmosphere boundary
type; the defaultFaces representing the front and back planes of the 2D problem, is, as
usual, an empty type.
2.3.3 Setting initial field
Unlike the previous cases, we shall now specify a non-uniform initial condition for the
phase fraction α1where
α1=(1 for the liquid phase
0 for the gas phase (2.15)
This will be done by running the setFields utility. It requires a setFieldsDict dictionary,
located in the system directory, whose entries for this case are shown below.
17
18 defaultFieldValues
19 (
20 volScalarFieldValue alpha1 0
21 );
22
23 regions
24 (
25 boxToCell
26 {
27 box (0 0 -1) (0.1461 0.292 1);
28 fieldValues
OpenFOAM-1.6
2.3 Breaking of a dam U-59
29 (
30 volScalarFieldValue alpha1 1
31 );
32 }
33 );
34
35
36 // ************************************************************************* //
The defaultFieldValues sets the default value of the fields, i.e. the value the field
takes unless specified otherwise in the regions sub-dictionary. That sub-dictionary con-
tains a list of subdictionaries containing fieldValues that override the defaults in a
specified region. The region is expressed in terms of a topoSetSource that creates a set
of points, cells or faces based on some topological constraint. Here, boxToCell creates
a bounding box within a vector minimum and maximum to define the set of cells of the
liquid region. The phase fraction α1is defined as 1 in this region.
The user should execute setFields as any other utility is executed. Using paraFoam,
check that the initial alpha1 field corresponds to the desired distribution as in Figure 2.21.
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Phase fraction, α1
Figure 2.21: Initial conditions for phase fraction alpha1.
2.3.4 Fluid properties
Let us examine the transportProperties file in the constant directory. It dictionary con-
tains the material properties for each fluid, separated into two subdictionaries phase1
and phase2. The transport model for each phase is selected by the transportModel
keyword. The user should select Newtonian in which case the kinematic viscosity is sin-
gle valued and specified under the keyword nu. The viscosity parameters for the other
models, e.g.CrossPowerLaw, are specified within subdictionaries with the generic name
<model>Coeffs,i.e.CrossPowerLawCoeffs in this example. The density is specified under
the keyword rho.
The surface tension between the two phases is specified under the keyword sigma.
The values used in this tutorial are listed in Table 2.3.
Gravitational acceleration is uniform across the domain and is specified in a file named
gin the constant directory. Unlike a normal field file, e.g. Uand p,gis a uniformDimen-
sionedVectorField and so simply contains a set of dimensions and a value that represents
(0,9.81,0) m s2for this tutorial:
OpenFOAM-1.6
U-60 Tutorials
phase1 properties
Kinematic viscosity m2s1nu 1.0×106
Density kg m3rho 1.0×103
phase2 properties
Kinematic viscosity m2s1nu 1.48 ×105
Density kg m3rho 1.0
Properties of both phases
Surface tension N m1sigma 0.07
Table 2.3: Fluid properties for the damBreak tutorial
17
18 dimensions [0 1 -2 0 0 0 0];
19 value ( 0 -9.81 0 );
20
21
22 // ************************************************************************* //
2.3.5 Turbulence modelling
As in the cavity example, the choice of turbulence modelling method is selectable at run-
time through the simulationType keyword in turbulenceProperties dictionary. In this
example, we wish to run without turbulence modelling so we set laminar:
17
18 simulationType laminar;
19
20
21 // ************************************************************************* //
2.3.6 Time step control
Time step control is an important issue in free surface tracking since the surface-tracking
algorithm is considerably more sensitive to the Courant number Co than in standard fluid
flow calculations. Ideally, we should not exceed an upper limit Co 0.5 in the region
of the interface. In some cases, where the propagation velocity is easy to predict, the
user should specify a fixed time-step to satisfy the Co criterion. For more complex cases,
this is considerably more difficult. interFoam therefore offers automatic adjustment of the
time step as standard in the controlDict. The user should specify adjustTimeStep to be
on and the the maximum Co,maxCo to be 0.5. The upper limit on time step maxDeltaT
can be set to a value that will not be exceeded in this simulation, e.g. 1.0.
By using automatic time step control, the steps themselves are never rounded to a
convenient value. Consequently if we request that OpenFOAM saves results at a fixed
number of time step intervals, the times at which results are saved are somewhat arbitrary.
However even with automatic time step adjustment, OpenFOAM allows the user to specify
that results are written at fixed times; in this case OpenFOAM forces the automatic time
stepping procedure to adjust time steps so that it ‘hits’ on the exact times specified for
write output. The user selects this with the adjustableRunTime option for writeControl
in the controlDict dictionary. The controlDict dictionary entries should be:
17
18 application interFoam;
19
20 startFrom startTime;
21
OpenFOAM-1.6
2.3 Breaking of a dam U-61
22 startTime 0;
23
24 stopAt endTime;
25
26 endTime 1;
27
28 deltaT 0.001;
29
30 writeControl adjustableRunTime;
31
32 writeInterval 0.05;
33
34 purgeWrite 0;
35
36 writeFormat ascii;
37
38 writePrecision 6;
39
40 writeCompression uncompressed;
41
42 timeFormat general;
43
44 timePrecision 6;
45
46 runTimeModifiable yes;
47
48 adjustTimeStep yes;
49
50 maxCo 0.5;
51
52 maxDeltaT 1;
53
54
55 // ************************************************************************* //
2.3.7 Discretisation schemes
The free surface treatment in OpenFOAM does not account for the effects of turbulence.
This is a consequence of the fact that the Reynolds averaged approach to turbulence
modelling does not match the notion of an infinitesimally thin interface between air and
water. As a consequence, all free surface simulations can be viewed as a direct numerical
simulation (DNS) of fluid flow. DNS is associated with certain requirements on the mesh
size, far beyond the mesh resolution of our test case.
This solver uses the multidimensional universal limiter for explicit solution (MULES)
method, created by OpenCFD, to maintain boundedness of the phase fraction indepen-
dent of underlying numerical scheme, mesh structure, etc. The choice of schemes for
convection are therfore not restricted to those that are strongly stable or bounded, e.g.
upwind differencing.
The convection schemes settings are made in the divSchemes sub-dictionary of the
fvSchemes dictionary. In this example, the convection term in the momentum equation
((ρUU)), denoted by the div(rho*phi,U) keyword, uses Gauss limitedLinearV
1.0 to produce good accuracy. The limited linear schemes require a coefficient φas
described in section 4.4.1. Here, we have opted for best stability with φ= 1.0. The
(Uα1) term, represented by the div(phi,alpha) keyword uses the vanLeer scheme.
The (Urbα1) term, represeniv(
U-62 Tutorials
25 default Gauss linear;
26 grad(U) Gauss linear;
27 grad(alpha1) Gauss linear;
28 }
29
30 divSchemes
31 {
32 div(rho*phi,U) Gauss limitedLinearV 1;
33 div(phi,alpha) Gauss vanLeer;
34 div(phirb,alpha) Gauss interfaceCompression;
35 }
36
37 laplacianSchemes
38 {
39 default Gauss linear corrected;
40 }
41
42 interpolationSchemes
43 {
44 default linear;
45 }
46
47 snGradSchemes
48 {
49 default corrected;
50 }
51
52 fluxRequired
53 {
54 default no;
55 p;
56 pcorr;
57 alpha1;
58 }
59
60
61 // ************************************************************************* //
2.3.8 Linear-solver control
In the fvSolution, the PISO sub-dictionary contains elements that are specific to interFoam.
There are the usual correctors to the momentum equation but also correctors to a PISO
loop around the α1phase equation. Of particular interest are the nAlphaSubCycles and
cAlpha keywords. nAlphaSubCycles represents the number of sub-cycles within the α1
equation; sub-cycles are additional solutions to an equation within a given time step. It
is used to enable the solution to be stable without reducing the time step and vastly
increasing the solution time. Here we specify 2 sub-cycles, which means that the α1
equation is solved in 2×half length time steps within each actual time step.
The cAlpha keyword is a factor that controls the compression of the interface where: 0
corresponds to no compression; 1 corresponds to conservative compression; and, anything
larger than 1, relates to enhanced compression of the interface. We generally recommend
a value of 1.0 which is employed in this example.
2.3.9 Running the code
Running of the code has been described in detail in previous tutorials. Try the following,
that uses tee, a command that enables output to be written to both standard output and
files:
cd $FOAM RUN/tutorials/multiphase/interFoam/laminar/damBreak
interFoam | tee log
The code will now be run interactively, with a copy of output stored in the log file.
OpenFOAM-1.6
2.3 Breaking of a dam U-63
2.3.10 Post-processing
Post-processing of the results can now be done in the usual way. The user can monitor
the development of the phase fraction alpha1 in time; Figure 2.22.
2.3.11 Running in parallel
The results from the previous example are generated using a fairly coarse mesh. We now
wish to increase the mesh resolution and re-run the case. The new case will typically
take a few hours to run with a single processor so, should the user have access to multiple
processors, we can demonstrate the parallel processing capability of OpenFOAM.
The user should first make a copy of the damBreak case, e.g. by
cd $FOAM RUN/tutorials/multiphase/interFoam/laminar
mkdir damBreakFine
cp -r damBreak/0 damBreakFine
cp -r damBreak/system damBreakFine
cp -r damBreak/constant damBreakFine
Enter the new case directory and change the blocks description in the blockMeshDict
dictionary to
blocks
(
hex (0 1 5 4 12 13 17 16) (46 10 1) simpleGrading (1 1 1)
hex (2 3 7 6 14 15 19 18) (40 10 1) simpleGrading (1 1 1)
hex (4 5 9 8 16 17 21 20) (46 76 1) simpleGrading (1 2 1)
hex (5 6 10 9 17 18 22 21) (4 76 1) simpleGrading (1 2 1)
hex (6 7 11 10 18 19 23 22) (40 76 1) simpleGrading (1 2 1)
);
Here, the entry is presented as printed from the blockMeshDict file; in short the user must
change the mesh densities, e.g. the 46 10 1 entry, and some of the mesh grading entries
to 121. Once the dictionary is correct, generate the mesh.
As the mesh has now changed from the damBreak example, the user must re-initialise
the phase field alpha1 in the 0time directory since it contains a number of elements that
is inconsistent with the new mesh. Note that there is no need to change the Uand p
fields since they are specified as uniform which is independent of the number of elements
U-64 Tutorials
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Phase fraction, α1
(a) At t= 0.25 s.
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Phase fraction, α1
(b) At t= 0.50 s.
Figure 2.22: Snapshots of phase α1.
OpenFOAM-1.6
2.3 Breaking of a dam U-65
case is therefore to decompose the domain using the decomposePar utility. There is a
dictionary associated with decomposePar named decomposeParDict which is located in
the system directory of the tutorial case; also, like with many utilities, a default dic-
tionary can be found in the directory of the source code of the specific utility, i.e. in
$FOAM UTILITIES/parallelProcessing/decomposePar for this case.
The first entry is numberOfSubdomains which specifies the number of subdomains into
which the case will be decomposed, usually corresponding to the number of processors
available for the case.
In this tutorial, the method of decomposition should be simple and the corresponding
simpleCoeffs should be edited according to the following criteria. The domain is split
into pieces, or subdomains, in the x,yand zdirections, the number of subdomains in
each direction being given by the vector n. As this geometry is 2 dimensional, the 3rd
direction, z, cannot be split, hence nzmust equal 1. The nxand nycomponents of n
split the domain in the xand ydirections and must be specified so that the number
of subdomains specified by nxand nyequals the specified numberOfSubdomains,i.e.
nxny=numberOfSubdomains. It is beneficial to keep the number of cell faces adjoining
the subdomains to a minimum so, for a square geometry, it is best to keep the split
between the xand ydirections should be fairly even. The delta keyword should be set
to 0.001.
For example, let us assume we wish to run on 4 processors. We would set number-
OfSubdomains to 4 and n= (2,2,1). When running decomposePar, we can see from the
screen messages that the decomposition is distributed fairly even between the processors.
The user should consult section 3.4 for details of how to run a case in parallel; in
this tutorial we merely present an example of running in parallel. We use the openMPI
implementation of the standard message-passing interface (MPI). As a test here, the user
can run in parallel on a single node, the local host only, by typing:
mpirun -np 4 interFoam -parallel >log &
The user may run on more nodes over a network by creating a file that lists the host
names of the machines on which the case is to be run as described in section 3.4.2. The
case should run in the background and the user can follow its progress by monitoring the
log file as usual.
Figure 2.23: Mesh of processor 2 in parallel processed case.
OpenFOAM-1.6
U-66 Tutorials
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Phase fraction, α1
(a) At t= 0.25 s.
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Phase fraction, α1
(b) At t= 0.50 s.
Figure 2.24: Snapshots of phase α1with refined mesh.
OpenFOAM-1.6
2.3 Breaking of a dam U-67
2.3.12 Post-processing a case run in parallel
Once the case has completed running, the decomposed fields and mesh must be reassem-
bled for post-processing using the reconstructPar utility. Simply execute it from the com-
mand line. The results from the fine mesh are shown in Figure 2.24. The user can see
that the resolution of interface has improved significantly compared to the coarse mesh.
The user may also post-process a segment of the decomposed domain individually by
simply treating the individual processor directory as a case in its own right. For example
if the user starts paraFoam by
paraFoam -case processor1
then processor1 will appear as a case module in ParaView.Figure 2.23 shows the mesh
from processor 1 following the decomposition of the domain using the simple method.
OpenFOAM-1.6
U-68 Tutorials
OpenFOAM-1.6
Chapter 3
Applications and libraries
We should reiterate from the outset that OpenFOAM is a C++ library used primarily to
create executables, known as applications. OpenFOAM is distributed with a large set of
precompiled applications but users also have the freedom to create their own or modify
existing ones. Applications are split into two main categories:
solvers that are each designed to solve a specific problem in computational continuum
mechanics;
utilities that perform simple pre-and post-processing tasks, mainly involving data ma-
nipulation and algebraic calculations.
OpenFOAM is divided into a set of precompiled libraries that are dynamically linked
during compilation of the solvers and utilities. Libraries such as those for physical models
are supplied as source code so that users may conveniently add their own models to the
libraries.
This chapter gives an overview of solvers, utilities and libraries, their creation, mod-
ification, compilation and execution. The actual writing of code for solvers and utilities
is not described here but is within the Programmer’s Guide. The Programmer’s Guide is
currently under development so, if users have any queries, further information may also
available at the OpenFOAM web site.
3.1 The programming language of OpenFOAM
In order to understand the way in which the OpenFOAM library works, some background
knowledge of C++, the base language of OpenFOAM, is required; the necessary infor-
mation will be presented in this chapter. Before doing so, it is worthwhile addressing the
concept of language in general terms to explain some of the ideas behind object-oriented
programming and our choice of C++ as the main programming language of OpenFOAM.
3.1.1 Language in general
The success of verbal language and mathematics is based on efficiency, especially in
expressing abstract concepts. For example, in fluid flow, we use the term “velocity field”,
which has meaning without any reference to the nature of the flow or any specific velocity
data. The term encapsulates the idea of movement with direction and magnitude and
relates to other physical properties. In mathematics, we can represent velocity field by
a single symbol, e.g. U, and express certain concepts using symbols, e.g. “the field of
velocity magnitude” by |U|. The advantage of mathematics over verbal language is its
greater efficiency, making it possible to express complex concepts with extreme clarity.
U-70 Applications and libraries
The problems that we wish to solve in continuum mechanics are not presented in
terms of intrinsic entities, or types, known to a computer, e.g. bits, bytes, integers. They
are usually presented first in verbal language, then as partial differential equations in 3
dimensions of space and time. The equations contain the following concepts: scalars,
vectors, tensors, and fields thereof; tensor algebra; tensor calculus; dimensional units.
The solution to these equations involves discretisation procedures, matrices, solvers, and
solution algorithms. The topics of tensor mathematics and numerics are the subjects of
chapter 1 and chapter 2 of the Programmer’s Guide.
3.1.2 Object-orientation and C++
Progamming languages that are object-oriented, such as C++, provide the mechanism
classes — to declare types and associated operations that are part of the verbal and
mathematical languages used in science and engineering. Our velocity field introduced
earlier can be represented in programming code by the symbol Uand “the field of velocity
magnitude” can be mag(U). The velocity is a vector field for which there should exist,
in an object-oriented code, a vectorField class. The velocity field Uwould then be an
instance, or object, of the vectorField class; hence the term object-oriented.
The clarity of having objects in programming that represent physical objects and
abstract entities should not be underestimated. The class structure concentrates code
development to contained regions of the code, i.e. the classes themselves, thereby making
the code easier to manage. New classes can be derived or inherit properties from other
classes, e.g. the vectorField can be derived from a vector class and a Field class. C++
provides the mechanism of template classes such that the template class Field<Type>can
represent a field of any <Type>,e.g.scalar,vector,tensor. The general features of the
template class are passed on to any class created from the template. Templating and
inheritance reduce duplication of code and create class hierarchies that impose an overall
structure on the code.
3.1.3 Equation representation
A central theme of the OpenFOAM design is that the solver applications, written using the
OpenFOAM classes, have a syntax that closely resembles the partial differential equations
being solved. For example the equation
ρU
t +φU− ∇µU=−∇p
is represented by the code
solve
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
- fvm::laplacian(mu, U)
==
- fvc::grad(p)
);
This and other requirements demand that the principal programming language of Open-
FOAM has object-oriented features such as inheritance, template classes, virtual functions
OpenFOAM-1.6
3.2 Compiling applications and libraries U-71
and operator overloading. These features are not available in many languages that pur-
port to be object-orientated but actually have very limited object-orientated capability,
such as FORTRAN-90. C++, however, possesses all these features while having the ad-
ditional advantage that it is widely used with a standard specification so that reliable
compilers are available that produce efficient executables. It is therefore the primary
language of OpenFOAM.
3.1.4 Solver codes
Solver codes are largely procedural since they are a close representation of solution algo-
rithms and equations, which are themselves procedural in nature. Users do not need a
deep knowledge of object-orientation and C++ programming to write a solver but should
know the principles behind object-orientation and classes, and to have a basic knowledge
of some C++ code syntax. An understanding of the underlying equations, models and
solution method and algorithms is far more important.
There is often little need for a user to immerse themselves in the code of any of the
OpenFOAM classes. The essence of object-orientation is that the user should not have
to; merely the knowledge of the class’ existence and its functionality are sufficient to use
the class. A description of each class, its functions etc. is supplied with the OpenFOAM
distribution in HTML documentation generated withtrn1- 301107uonntp er-14.78381 0 0 1 70.86853714245057(b)/R235113(nC)0.0878122.1488 0 Td170012145057(t)de se 9551325949054(c)0.0495218(o)0.245057(m)-0.311426(d)-32696..6atmattpe
U-72 Applications and libraries
int main()
...
...
return(0);
{
}
nc.so
Library
option-I
#include "nc.H"
Main code
Code...
Compiled
nc.H
nc.C
#include "nc.H"
nc class
Definition...
Compiled
Executable
Header file
Linked
option-l
newApp.C
newApp
Figure 3.1: Header files, source files, compilation and linking.
of header files for all the classes on which the top level .C code ultimately depends; these
.H files are known as the dependencies. With a dependency list, a compiler can check
whether the source files have been updated since their last compilation and selectively
compile only those that need to be.
Header files are included in the code using # include statements, e.g.
# include "otherHeader.H";
causes the compiler to suspend reading from the current file to read the file specified.
Any self-contained piece of code can be put into a header file and included at the rel-
evant location in the main code in order to improve code readability. For example, in
most OpenFOAM applications the code for creating fields and reading field input data is
included in a file createFields.H which is called at the beginning of the code. In this way,
header files are not solely used as class declarations. It is wmake that performs the task
of maintaining file dependency lists amongst other functions listed below.
Automatic generation and maintenance of file dependency lists, i.e. lists of files
which are included in the source files and hence on which they depend.
Multi-platform compilation and linkage, handled through appropriate directory
structure.
Multi-language compilation and linkage, e.g. C, C++, Java.
Multi-option compilation and linkage, e.g. debug, optimised, parallel and profiling.
Support for source code generation programs, e.g. lex, yacc, IDL, MOC.
Simple syntax for source file lists.
Automatic creation of source file lists for new codes.
Simple handling of multiple shared or static libraries.
Extensible to new machine types.
OpenFOAM-1.6
3.2 Compiling applications and libraries U-73
Extremely portable, works on any machine with: make;sh,ksh or csh;lex,cc.
Has been tested on Apollo, SUN, SGI, HP (HPUX), Compaq (DEC), IBM (AIX),
Cray, Ardent, Stardent, PC Linux, PPC Linux, NEC, SX4, Fujitsu VP1000.
3.2.2 Compiling with wmake
OpenFOAM applications are organised using a standard convention that the source code
of each application is placed in a directory whose name is that of the application. The
top level source file takes the application name with the .C extension. For example, the
source code for an application called newApp would reside is a directory newApp and the
top level file would be newApp.C as shown in Figure 3.2. The directory must also contain
newApp
newApp.C
otherHeader.H
Make
files
options
Figure 3.2: Directory structure for an application
aMake subdirectory containing 2 files, options and files, that are described in the following
sections.
3.2.2.1 Including headers
The compiler searches for the included header files in the following order, specified with
the -I option in wmake:
1. the $WM PROJECT DIR/src/OpenFOAM/lnInclude directory;
2. a local lnInclude directory, i.e.newApp/lnInclude;
3. the local directory, i.e.newApp;
4. platform dependent paths set in files in the $WM PROJECT DIR/wmake/rules/-
$WM ARCH/ directory, e.g./usr/X11/include and $(MPICH ARCH PATH)/include;
5. other directories specified explicitly in the Make/options file with the -I option.
The Make/options file contains the full directory paths to locate header files using the
syntax:
EXE INC = \
-I<directoryPath1>\
-I<directoryPath2>\
... \
-I<directoryPathN>
Notice first that the directory names are preceeded by the -I flag and that the syntax
uses the \to continue the EXE INC across several lines, with no \after the final entry.
OpenFOAM-1.6
U-74 Applications and libraries
3.2.2.2 Linking to libraries
The compiler links to shared object library files in the following directory paths, specified
with the -L option in wmake:
1. the $FOAM LIBBIN directory;
2. platform dependent paths set in files in the $WM DIR/rules/$WM ARCH/ directory,
e.g./usr/X11/lib and $(MPICH ARCH PATH)/lib;
3. other directories specified in the Make/options file.
The actual library files to be linked must be specified using the -l option and removing
the lib prefix and .so extension from the library file name, e.g.libnew.so is included with
the flag -lnew. By default, wmake loads the following libraries:
1. the libOpenFOAM.so library from the $FOAM LIBBIN directory;
2. platform dependent libraries specified in set in files in the $WM DIR/rules/$WM ARCH/
directory, e.g.libm.so from /usr/X11/lib and liblam.so from $(LAM ARCH PATH)/lib;
3. other libraries specified in the Make/options file.
The Make/options file contains the full directory paths and library names using the syntax:
EXE LIBS = \
-L<libraryPath1>\
-L<libraryPath2>\
... \
-L<libraryPathN>\
-l<library1>\
-l<library2>\
... \
-l<libraryN>
Let us reiterate that the directory paths are preceeded by the -L flag, the library names
are preceeded by the -l flag.
3.2.2.3 Source files to be compiled
The compiler requires a list of .C source files that must be compiled. The list must contain
the main .C file but also any other source files that are created for the specific application
but are not included in a class library. For example, users may create a new class or
some new functionality to an existing class for a particular application. The full list of
.C source files must be included in the Make/files file. As might be expected, for many
applications the list only includes the name of the main .C file, e.g.newApp.C in the case
of our earlier example.
The Make/files file also includes a full path and name of the compiled executable,
specified by the EXE = syntax. Standard convention stipulates the name is that of the ap-
plication, i.e.newApp in our example. The OpenFOAM release offers two useful choices for
path: standard release applications are stored in $FOAM APPBIN; applications developed
by the user are stored in $FOAM USER APPBIN.
If the user is developing their own applications, we recommend they create an appli-
cations subdirectory in their $WM PROJECT USER DIR directory containing the source
OpenFOAM-1.6
3.2 Compiling applications and libraries U-75
code for personal OpenFOAM applications. As with standard applications, the source
code for each OpenFOAM application should be stored within its own directory. The
only difference between a user application and one from the standard release is that the
Make/files file should specify that the user’s executables are written into their $FOAM -
USER APPBIN directory. The Make/files file for our example would appear as follows:
newApp.C
EXE = $(FOAM_USER_APPBIN)/newApp
3.2.2.4 Running wmake
The wmake script is executed by typing:
wmake <optionalArguments> <optionalDirectory>
The <optionalDirectory>is the directory path of the application that is being com-
piled. Typically, wmake is executed from within the directory of the application being
compiled, in which case <optionalDirectory>can be omitted.
If a user wishes to build an application executable, then no <optionalArguments>
are required. However <optionalArguments>may be specified for building libraries etc.
as described in Table 3.1.
Argument Type of compilation
lib Build a statically-linked library
libso Build a dynamically-linked library
libo Build a statically-linked object file library
jar Build a JAVA archive
exe Build an application independent of the specified project
Table 3.1: Optional compilation arguments to wmake.
3.2.2.5 wmake environment variables
For information, the environment variable settings used by wmake are listed in Table 3.2.
3.2.3 Removing dependency lists: wclean and rmdepall
On execution, wmake builds a dependency list file with a .dep file extension, e.g.newApp.dep
in our example, and a list of files in a Make/$WM OPTIONS directory. If the user wishes
to remove these files, perhaps after making code changes, the user can run the wclean
script by typing:
wclean <optionalArguments> <optionalDirectory>
Again, the <optionalDirectory>is a path to the re applicat ta.216461840.20
U-76 Applications and libraries
Main paths
$WM PROJECT INST DIR Full path to installation directory,
e.g.$HOME/OpenFOAM
$WM PROJECT Name of the project being compiled: OpenFOAM
$WM PROJECT VERSION Version of the project being compiled: 1.6
$WM PROJECT DIR Full path to locate binary executables of OpenFOAM
release, e.g.$HOME/OpenFOAM/OpenFOAM-1.6
$WM PROJECT USER DIR Full path to locate binary executables of the user
e.g.$HOME/OpenFOAM/${USER}-1.6
Other paths/settings
$WM ARCH Machine architecture: cray decAlpha dec ibm linux
linuxPPC sgi3 sgi32 sgi64 sgiN32 solaris sx4 t3d
$WM COMPILER Compiler being used: Gcc3 -gcc 4.3.3, KAI - KAI
$WM COMPILER DIR Compiler installation directory
$WM COMPILER BIN Compiler installation binaries $WM COMPILER BIN/bin
$WM COMPILER LIB Compiler installation libraries $WM COMPILER BIN/lib
$WM COMPILE OPTION Compilation option: Debug - debugging, Opt optimisa-
tion.
$WM DIR Full path of the wmake directory
$WM JAVAC OPTION Compilation option for JAVA:Debug - debugging, Opt
optimisation.
$WM LINK LANGUAGE Compiler used to link libraries and executables. In multi-
language projects a $WM LINK LANGUAGE is set to the
primary language.
$WM MPLIB Parallel communications library: LAM,MPI,MPICH,PVM
$WM OPTIONS =$WM ARCH$WM COMPILER...
...$WM COMPILE OPTION$WM MPLIB
e.g.linuxGcc3OptMPICH
$WM PROJECT LANGUAGE Programming language of project, e.g.c++
$WM SHELL Shell used for the wmake scripts bash,csh,ksh,tcsh
Table 3.2: Environment variable settings for wmake.
If a user wishes to remove the dependency files and files from the Make directory, then
no <optionalArguments>are required. However if lib is specified in <optionalArguments>
a local lnInclude directory will be deleted also.
An additional script, rmdepall removes all dependency .dep files recursively down the
directory tree from the point at which it is executed. This can be useful when updating
OpenFOAM libraries.
3.2.4 Compilation example: the pisoFoam application
The source code for application pisoFoam is in the $FOAM APP/solvers/incompressible/pisoFoam
directory and the top level source file is named pisoFoam.C. The pisoFoam.C source code
is:
1/*---------------------------------------------------------------------------*\
2========= |
3\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4\\ / O peration |
OpenFOAM-1.6
3.2 Compiling applications and libraries U-77
5\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
6\\/ M anipulation |
7-------------------------------------------------------------------------------
8License
9This file is part of OpenFOAM.
10
11 OpenFOAM is free software; you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by the
13 Free Software Foundation; either version 2 of the License, or (at your
14 option) any later version.
15
16 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with OpenFOAM; if not, write to the Free Software Foundation,
23 Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25 Application
26 pisoFoam
27
28 Description
29 Transient solver for incompressible flow.
30
31 Turbulence modelling is generic, i.e. laminar, RAS or LES may be selected.
32
33 \*---------------------------------------------------------------------------*/
34
35 #include "fvCFD.H"
36 #include "singlePhaseTransportModel.H"
37 #include "turbulenceModel.H"
38
39 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
40
41 int main(int argc, char *argv[])
42 {
43 #include "setRootCase.H"
44
45 #include "createTime.H"
46 #include "createMesh.H"
47 #include "createFields.H"
48 #include "initContinuityErrs.H"
49
50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
51
52 Info<< "\nStarting time loop\n" << endl;
53
54 while (runTime.loop())
55 {
56 Info<< "Time = " << runTime.timeName() << nl << endl;
57
58 #include "readPISOControls.H"
59 #include "CourantNo.H"
60
61 // Pressure-velocity PISO corrector
62 {
63 // Momentum predictor
64
65 fvVectorMatrix UEqn
66 (
67 fvm::ddt(U)
68 + fvm::div(phi, U)
69 + turbulence->divDevReff(U)
70 );
71
72 UEqn.relax();
73
74 if (momentumPredictor)
75 {
76 solve(UEqn == -fvc::grad(p));
77 }
78
79 // --- PISO loop
80
81 for (int corr=0; corr<nCorr; corr++)
82 {
83 volScalarField rUA = 1.0/UEqn.A();
84
85 U = rUA*UEqn.H();
86 phi = (fvc::interpolate(U) & mesh.Sf())
87 + fvc::ddtPhiCorr(rUA, U, phi);
88
OpenFOAM-1.6
U-78 Applications and libraries
89 adjustPhi(phi, U, p);
90
91 // Non-orthogonal pressure corrector loop
92 for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
93 {
94 // Pressure corrector
95
96 fvScalarMatrix pEqn
97 (
98 fvm::laplacian(rUA, p) == fvc::div(phi)
99 );
100
101 pEqn.setReference(pRefCell, pRefValue);
102
103 if
104 (
105 corr == nCorr-1
106 && nonOrth == nNonOrthCorr
107 )
108 {
109 pEqn.solve(mesh.solver("pFinal"));
110 }
111 else
112 {
113 pEqn.solve();
114 }
115
116 if (nonOrth == nNonOrthCorr)
117 {
118 phi -= pEqn.flux();
119 }
120 }
121
122 #include "continuityErrs.H"
123
124 U -= rUA*fvc::grad(p);
125 U.correctBoundaryConditions();
126 }
127 }
128
129 turbulence->correct();
130
131 runTime.write();
132
133 Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
134 << " ClockTime = " << runTime.elapsedClockTime() << " s"
135 << nl << endl;
136 }
137
138 Info<< "End\n" << endl;
139
140 return 0;
141 }
142
143
144 // ************************************************************************* //
The code begins with a brief description of the application contained within comments
over 1 line (//) and multiple lines (/*...*/). Following that, the code contains several
# include statements, e.g.# include "fvCFD.H", which causes the compiler to suspend
reading from the current file, pisoFoam.C to read the fvCFD.H.
pisoFoam resources the cfdTools,incompressibleRASModels and incompressibleTransport-
Models libraries and therefore requires the necessary header files, specified by the EXE INC
= -I... option, and links to the libraries with the EXE LIBS = -l... option. The
Make/options therefore contains the following:
1EXE_INC = \
2-I$(LIB_SRC)/turbulenceModels/incompressible/turbulenceModel \
3-I$(LIB_SRC)/transportModels \
4-I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
5-I$(LIB_SRC)/finiteVolume/lnInclude
6
7EXE_LIBS = \
8-lincompressibleRASModels \
9-lincompressibleLESModels \
10 -lincompressibleTransportModels \
11 -lfiniteVolume \
12 -lmeshTools
OpenFOAM-1.6
3.2 Compiling applications and libraries U-79
pisoFoam contains only the pisoFoam.C source and the executable is written to the $FOAM APPBIN
directory as all standard applications are. The Make/files therefore contains:
1pisoFoam.C
2
3EXE = $(FOAM_APPBIN)/pisoFoam
The user can compile pisoFoam by going to the $FOAM CFD/pisoFoam directory and
typing:
wmake
The code should compile and produce a message similar to the following
Making dependency list for source file pisoFoam.C
SOURCE DIR=.
SOURCE=pisoFoam.C ;
g++ -DFOAM EXCEPTION -Dlinux -DlinuxOptMPICH
-DscalarMachine -DoptSolvers -DPARALLEL -DUSEMPI -Wall -O2 -DNoRepository
-ftemplate-depth-17 -I.../OpenFOAM/OpenFOAM-1.6/src/OpenFOAM/lnInclude
-IlnInclude
-I.
......
-lmpich -L/usr/X11/lib -lm
-o .../OpenFOAM/OpenFOAM-1.6/applications/bin/linuxOptMPICH/pisoFoam
The user can now try recompiling and will receive a message similar to the following to
say that the executable is up to date and compiling is not necessary:
make: Nothing to be done for ‘allFiles’.
make: ‘Make/linuxOptMPICH/dependencies’ is up to date.
make: ‘.../OpenFOAM/OpenFOAM-1.6/applications/bin/linuxOptMPICH/pisoFoam’
is up to date.
The user can compile the application from scratch by removing the dependency list with
wclean
and running wmake.
3.2.5 Debug messaging and optimisation switches
OpenFOAM provides a system of messaging that is written during runtime, most of which
are to help debugging problems encountered during running of a OpenFOAM case. The
switches are listed in the $WM PROJECT DIR/etc/controlDict file; should the user wish
to change the settings they should make a copy to their $HOME directory, i.e.$HOME/-
.OpenFOAM/1.6/controlDict file. The list of possible switches is extensive and can be
viewed by running the foamDebugSwitches
U-80 Applications and libraries
fileModificationSkew. OpenFOAM scans the write time of data files to check for mod-
ification. When running over a NFS with some disparity in the clock settings on different
machines, field data files appear to be modified ahead of time. This can cause a problem
if OpenFOAM views the files as newly modified and attempting to re-read this data. The
fileModificationSkew keyword is the time in seconds that OpenFOAM will subtract
from the file write time when assessing whether the file has been newly modified.
High level debugging switches - sub-dictionary DebugSwitches
level Overall level of debugging messaging for OpenFOAM- - 3 levels 0,
1,2
lduMatrix Messaging for solver convergence during a run - 3 levels 0,1,2
Optimisation switches - sub-dictionary OptimisationSwitches
fileModific-
ationSkew
A time in seconds that should be set higher than the maximum
delay in NFS updates and clock difference for running OpenFOAM
over a NFS.
nProcsSimpleSum Optimises global sum for parallel processing; sets number of pro-
cessors above which hierarchical sum is performed rather than a
linear sum (default 16)
Table 3.3: Runtime message switches.
3.2.6 Linking new user-defined libraries to existing applications
The situation may arise that a user creates a new library, say new, and wishes the features
within that library to be available across a range of applications. For example, the
user may create a new boundary condition, compiled into new, that would need to be
recognised by a range of solver applications, pre- and post-processing utilities, mesh tools,
etc. Under normal circumstances, the user would need to recompile every application with
the new linked to it.
Instead there is a simple mechanism to link one or more shared object libraries dy-
namically at run-time in OpenFOAM. Simply add the optional keyword entry libs to
the controlDict file for a case and enter the full names of the libraries within a list (as
quoted string entries). For example, if a user wished to link the libraries new1 and new2
at run-time, they would simply need to add the following to the case controlDict file:
libs
(
"libnew1.so"
"libnew2.so"
);
3.3 Running applications
Each application is designed to be executed from a terminal command line, typically
reading and writing a set of data files associated with a particular case. The data files
for a case are stored in a directory named after the case as described in section 4.1; the
directory name with full path is here given the generic name <caseDir>.
OpenFOAM-1.6
3.4 Running applications in parallel U-81
For any application, the form of the command line entry for any can be found by
simply entering the application name at the command line with the -help option, e.g.
typing
blockMesh -help
returns the usage
Usage: blockMesh [-region region name] [-case dir] [-blockTopology]
[-help] [-doc] [-srcDoc]
The arguments in square brackets, [ ], are optional flags. If the application is exe-
cuted from within a case directory, it will operate on that case. Alternatively, the -case
<caseDir>option allows the case to be specified directly so that the application can be
executed from anywhere in the filing system.
Like any UNIX/Linux executable, applications can be run as as a background process,
i.e. one which does not have to be completed before the user can give the shell additional
commands. If the user wished to run the blockMesh example as a background process
and output the case progress to a log file, they could enter:
blockMesh > log &
3.4 Running applications in parallel
This section describes how to run OpenFOAM in parallel on distributed processors. The
method of parallel computing used by OpenFOAM is known as domain decomposition, in
which the geometry and associated fields are broken into pieces and allocated to separate
processors for solution. The process of parallel computation involves: decomposition of
mesh and fields; running the application in parallel; and, post-processing the decomposed
case as described in the following sections. The parallel running uses the public domain
openMPI implementation of the standard message passing interface (MPI).
3.4.1 Decomposition of mesh and initial field data
The mesh and fields are decomposed using the decomposePar utility. The underlying
aim is to break up the domain with minimal effort but in such a way to guarantee a
fairly economic solution. The geometry and fields are broken up according to a set of
parameters specified in a dictionary named decomposeParDict that must be located in
the system directory of the case of interest. An example decomposeParDict dictionary can
be copied from the interFoam/damBreak tutorial if the user requires one; the dictionary
entries within it are reproduced below:
17
18 numberOfSubdomains 4;
19
20 method simple;
21
22 simpleCoeffs
23 {
24 n ( 2 2 1 );
25 delta 0.001;
26 }
27
28 hierarchicalCoeffs
29 {
30 n ( 1 1 1 );
OpenFOAM-1.6
U-82 Applications and libraries
31 delta 0.001;
32 order xyz;
33 }
34
35 metisCoeffs
36 {
37 processorWeights ( 1 1 1 1 );
38 }
39
40 manualCoeffs
41 {
42 dataFile "";
43 }
44
45 distributed no;
46
47 roots ( );
48
49
50 // ************************************************************************* //
The user has a choice of four methods of decomposition, specified by the method keyword
as described below.
simple Simple geometric decomposition in which the domain is split into pieces by di-
rection, e.g. 2 pieces in the xdirection, 1 in yetc.
hierarchical
3.4 Running applications in parallel U-83
Compulsory entries
numberOfSubdomains Total number of subdomains N
method Method of decomposition simple/
hierarchical/
scotch/metis/
manual/
simpleCoeffs entries
nNumber of subdomains in x,y,z(nxnynz)
delta Cell skew factor Typically, 103
hierarchicalCoeffs entries
nNumber of subdomains in x,y,z(nxnynz)
delta Cell skew factor Typically, 103
order Order of decomposition xyz/xzy/yxz...
scotchCoeffs entries
processorWeights List of weighting factors for allocation
of cells to processors; <wt1>is the
weighting factor for processor 1, etc.;
weights are normalised so can take any
range of values.
(<wt1>...<wtN>)
strategy Decomposition strategy; defaults to
"b"
metisCoeffs entries
processorWeights As above (<wt1>...<wtN>)
manualCoeffs entries
dataFile Name of file containing data of alloca-
tion of cells to processors
"<fileName>"
Distributed data entries (optional) — see section 3.4.3
distributed Is the data distributed across several
disks?
yes/no
roots Root paths to case directories; <rt1>
is the root path for node 1, etc.
(<rt1>...<rtN>)
Table 3.4: Keywords in decompositionDict dictionary.
3.4.2 Running a decomposed case
A decomposed OpenFOAM case is run in parallel using the openMPI implementation of
MPI.
openMPI can be run on a local multiprocessor machine very simply but when run-
ning on machines across a network, a file must be created that contains the host names
of the machines. The file can be given any name and located at any path. In the fol-
lowing description we shall refer to such a file by the generic name, including full path,
<machines>.
The <machines>file contains the names of the machines listed one machine per line.
OpenFOAM-1.6
U-84 Applications and libraries
The names must correspond to a fully resolved hostname in the /etc/hosts file of the
machine on which the openMPI is run. The list must contain the name of the machine
running the openMPI. Where a machine node contains more than one processor, the node
name may be followed by the entry cpu=nwhere nis the number of processors openMPI
should run on that node.
For example, let us imagine a user wishes to run openMPI from machine aaa on the
following machines: aaa;bbb, which has 2 processors; and ccc. The <machines>would
contain:
aaa
bbb cpu=2
ccc
An application is run in parallel using mpirun.
mpirun --hostfile <machines>-np <nProcs>
<foamExec> <otherArgs>-parallel > log &
where: <nProcs>is the number of processors; <foamExec>is the executable, e.g.icoFoam;
and, the output is redirected to a file named log. For example, if icoFoam is run on 4
nodes, specified in a file named machines, on the cavity tutorial in the $FOAM RUN/-
tutorials/incompressible/icoFoam directory, then the following command should be exe-
cuted:
mpirun --hostfile machines -np 4 icoFoam -parallel > log &
3.4.3 Distributing data across several disks
Data files may need to be distributed if, for example, if only local disks are used in
order to improve performance. In this case, the user may find that the root path to the
case directory may differ between machines. The paths must then be specified in the
decomposeParDict dictionary using distributed and roots keywords. The distributed
entry should read
distributed yes;
and the roots entry is a list of root paths, <root0>,<root1>, . . . , for each node
roots
<nRoots>
(
"<root0>"
"<root1>"
...
);
where <nRoots>is the number of roots.
Each of the processorNdirectories should be placed in the case directory at each of
the root paths specified in the decomposeParDict dictionary. The system directory and
files within the constant directory must also be present in each case directory. Note: the
files in the constant directory are needed, but the polyMesh directory is not.
OpenFOAM-1.6
3.5 Standard solvers U-85
3.4.4 Post-processing parallel processed cases
When post-processing cases that have been run in parallel the user has two options:
reconstruction of the mesh and field data to recreate the complete domain and fields,
which can be post-processed as normal;
post-processing each segment of decomposed domain individually.
3.4.4.1 Reconstructing mesh and data
After a case has been run in parallel, it can be reconstructed for post-processing. The case
is reconstructed by merging the sets of time directories from each processorNdirectory into
a single set of time directories. The reconstructPar utility performs such a reconstruction
by executing the command:
reconstructPar
When the data is distributed across several disks, it must be first copied to the local case
directory for reconstruction.
3.4.4.2 Post-processing decomposed cases
The user may post-process decomposed cases using the paraFoam post-processor, de-
scribed in section 6.1. The whole simulation can be post-processed by reconstructing the
case or alternatively it is possible to post-process a segment of the decomposed domain
individually by simply treating the individual processor directory as a case in its own
right.
3.5 Standard solvers
The solvers with the OpenFOAM distribution are in the $FOAM SOLVERS directory,
reached quickly by typing app at the command line. This directory is further subdivided
into several directories by category of continuum mechanics, e.g. incompressible flow,
combustion and solid body stress analysis. Each solver is given a name that is reasonably
descriptive, e.g.icoFoam solves incompressible, laminar flow. The current list of solvers
distributed with OpenFOAM is given in Table 3.5.
‘Basic’ CFD codes
laplacianFoam Solves a simple Laplace equation, e.g. for thermal diffusion
in a solid
potentialFoam Simple potential flow solver which can be used to generate
starting fields for full Navier-Stokes codes
scalarTransportFoam Solves a transport equation for a passive scalar
Incompressible flow
boundaryFoam Steady-state solver for 1D turbulent flow, typically to generate
boundary layer conditions at an inlet, for use in a simulation
channelFoam Incompressible LES solver for flow in a channel
icoFoam Transient solver for incompressible, laminar flow of Newtonian
fluids
Continued on next page
OpenFOAM-1.6
U-86 Applications and libraries
Continued from previous page
nonNewtonianIcoFoam Transient solver for incompressible, laminar flow of non-
Newtonian fluids
pimpleDyMFoam Transient solver for incompressible, flow of Newtonian flu-
ids on a moving mesh using the PIMPLE (merged PISO-
SIMPLE) algorithm
pimpleFoam Large time-step transient solver for incompressible, flow using
the PIMPLE (merged PISO-SIMPLE) algorithm
pisoFoam Transient solver for incompressible flow
shallowWaterFoam Transient solver for inviscid shallow-water equations with ro-
tation
simpleFoam Steady-state solver for incompressible, turbulent flow
Compressible flow
rhoCentralFoam Density-based compressible flow solver based on central-
upwind schemes of Kurganov and Tadmor
rhoPimpleFoam Transient solver for laminar or turbulent flow of compressible
fluids for HVAC and similar applications
rhoPisoFoam Transient PISO solver for compressible, laminar or turbulent
flow
rhoPorousSimpleFoam Steady-state solver for turbulent flow of compressible fluids
with RANS turbulence modelling, and implicit or explicit
porosity treatment
rhopSonicFoam Pressure-density-based compressible flow solver
rhoSimpleFoam Steady-state SIMPLE solver for laminar or turbulent RANS
flow of compressible fluids
rhoSonicFoam Density-based compressible flow solver
sonicDyMFoam Transient solver for trans-sonic/supersonic, laminar or turbu-
lent flow of a compressible gas with mesh motion
sonicFoam Transient solver for trans-sonic/supersonic, laminar or turbu-
lent flow of a compressible gas
sonicLiquidFoam Transient solver for trans-sonic/supersonic, laminar flow of a
compressible liquid
Multiphase flow
bubbleFoam Solver for a system of 2 incompressible fluid phases with one
phase dispersed, e.g. gas bubbles in a liquid
cavitatingFoam Transient cavitation code based on the barotropic equation of
state
compressibleInterDyM-
Foam
Solver for 2 compressible, isothermal immiscible fluids using a
VOF (volume of fluid) phase-fraction based interface captur-
ing approach, with optional mesh motion and mesh topology
changes including adaptive re-meshing
compressibleInterFoam Solver for 2 compressible, isothermal immiscible fluids using
a VOF (volume of fluid) phase-fraction based interface cap-
turing approach
interDyMFoam Solver for 2 incompressible, isothermal immiscible fluids using
a VOF (volume of fluid) phase-fraction based interface captur-
ing approach, with optional mesh motion and mesh topology
changes including adaptive re-meshing
Continued on next page
OpenFOAM-1.6
3.5 Standard solvers U-87
Continued from previous page
interFoam Solver for 2 incompressible, isothermal immiscible fluids us-
ing a VOF (volume of fluid) phase-fraction based interface
capturing approach
interPhaseChangeFoam Solver for 2 incompressible, isothermal immiscible fluids with
phase-change (e.g. cavitation). Uses a VOF (volume of fluid)
phase-fraction based interface capturing approach
multiphaseInterFoam Solver for nincompressible fluids which captures the interfaces
and includes surface-tension and contact-angle effects for each
phase
settlingFoam Solver for 2 incompressible fluids for simulating the settling
of the dispersed phase
twoLiquidMixingFoam Solver for mixing 2 incompressible fluids
twoPhaseEulerFoam Solver for a system of 2 incompressible fluid phases with one
phase dispersed, e.g. gas bubbles in a liquid
Direct numerical simulation (DNS)
dnsFoam Direct numerical simulation solver for boxes of isotropic tur-
bulence
Combustion
coldEngineFoam Solver for cold-flow in internal combustion engines
dieselEngineFoam Solver for diesel engine spray and combustion
dieselFoam Solver for diesel spray and combustion
engineFoam Solver for internal combustion engines
PDRFoam Solver for compressible premixed/partially-premixed combus-
tion with turbulence modelling
reactingFoam Solver for combustion with chemical reactions
rhoReactingFoam Solver for combustion with chemical reactions using density
based thermodynamics package
XiFoam Solver for compressible premixed/partially-premixed combus-
tion with turbulence modelling
Heat transfer and buoyancy-driven flows
buoyantBoussinesqPi-
soFoam
Transient solver for buoyant, turbulent flow of incompressible
fluids
U-88 Applications and libraries
Continued from previous page
coalChemistryFoam Transient solver for compressible, turbulent flow with coal and
limestone parcel injections, and combustion
porousExplicitSource-
ReactingParcelFoam
Transient PISO solver for compressible, laminar or turbulent
flow with reacting Lagrangian parcels for porous media, in-
cluding explicit sources
reactingParcelFoam Transient PISO solver for compressible, laminar or turbulent
flow with reacting Lagrangian parcels
uncoupledKinematic-
ParcelFoam
Transient solver for the passive transport of a single kinematic
particle could
Molecular dynamics methods
mdEquilibrationFoam Equilibrates and/or preconditions molecular dynamics sys-
tems
mdFoam Molecular dynamics solver for fluid dynamics
Direct simulation Monte Carlo methods
dsmcFoam Direct simulation Monte Carlo (DSMC) solver for 3D, tran-
sient, multi- species flows
Electromagnetics
electrostaticFoam Solver for electrostatics
mhdFoam Solver for magnetohydrodynamics (MHD): incompressible,
laminar flow of a conducting fluid under the influence of a
magnetic field
Stress analysis of solids
solidDisplacement-
Foam
Transient segregated finite-volume solver of linear-elastic,
small-strain deformation of a solid body, with optional ther-
mal diffusion and thermal stresses
solidEquilibriumDis-
placementFoam
Steady-state segregated finite-volume solver of linear-elastic,
small-strain deformation of a solid body, with optional ther-
mal diffusion and thermal stresses
Finance
financialFoam Solves the Black-Scholes equation to price commodities
Table 3.5: Standard library solvers.
3.6 Standard utilities U-89
Continued from previous page
Pre-processing
applyBoundaryLayer Apply a simplified boundary-layer model to the velocity and
turbulence fields based on the 1/7th power-law
applyWallFunction-
BoundaryConditions
Updates OpenFOAM RAS cases to use the new wall function
framework Attempts to determine whether case is compress-
ible or incompressible, or can be supplied with -compressible
command line argument
boxTurb Makes a box of turbulence which conforms to a given energy
spectrum and is divergence free
changeDictionary Utility to change dictionary entries, e.g. can be used to change
the patch type in the field and polyMesh/boundary files
dsmcInitialise Initialise a case for dsmcFoam by reading the initialisation
dictionary system/dsmcInitialise
engineSwirl Generates a swirling flow for engine calulations
foamUpgradeFvSolution Simple tool to upgrade the syntax of system/fvSolution::solvers
mapFields Maps volume fields from one mesh to another, reading and
interpolating all fields present in the time directory of both
cases. Parallel and non-parallel cases are handled without the
need to reconstruct them first
mdInitialise Initialises fields for a molecular dynamics (MD) simulation
setFields Selects a cell set through a dictionary
Mesh generation
blockMesh A multi-block mesh generator
extrude2DMesh Takes 2D mesh (all faces 2 points only, no front and back
faces) and creates a 3D mesh by extruding with specified
thickness
extrudeMesh Extrude mesh from existing patch (by default outwards facing
normals; optional flips faces) or from patch read from file
snappyHexMesh Automatic split hex mesher. Refines and snaps to surface
Mesh conversion
ansysToFoam Converts an ANSYS input mesh file, exported from I-DEAS,
to OpenFOAM format
cfx4ToFoam Converts a CFX 4 mesh to OpenFOAM format
fluent3DMeshToFoam Converts a Fluent mesh to OpenFOAM format
fluentMeshToFoam Converts a Fluent mesh to OpenFOAM format including mul-
tiple region and region boundary handling
foamMeshToFluent Writes out the OpenFOAM mesh in Fluent mesh format
foamToStarMesh Reads an OpenFOAM mesh and writes a PROSTAR (v4)
bnd/cel/vrt format
gambitToFoam Converts a GAMBIT mesh to OpenFOAM format
gmshToFoam Reads .msh file as written by Gmsh
ideasUnvToFoam I-Deas unv format mesh conversion
kivaToFoam Converts a KIVA grid to OpenFOAM format
mshToFoam Converts .msh file generated by the Adventure system
netgenNeutralToFoam Converts neutral file format as written by Netgen v4.4
plot3dToFoam Plot3d mesh (ascii/formatted format) converter
Continued on next page
OpenFOAM-1.6
U-90 Applications and libraries
Continued from previous page
polyDualMesh Calculate the dual of a polyMesh. Adheres to all the feature
and patch edges
sammToFoam Converts a STAR-CD SAMM mesh to OpenFOAM format
star4ToFoam Converts a STAR-CD (v4) PROSTAR mesh into OpenFOAM
format
starToFoam Converts a STAR-CD PROSTAR mesh into OpenFOAM for-
mat
tetgenToFoam Converts .ele and .node and .face files, written by tetgen
writeMeshObj For mesh debugging: writes mesh as three separate OBJ files
which can be viewed with e.g. javaview
Mesh manipulation
attachMesh Attach topologically detached mesh using prescribed mesh
modifiers
autoPatch Divides external faces into patches based on (user supplied)
feature angle
cellSet Selects a cell set through a dictionary
checkMesh Checks validity of a mesh
createBaffles Makes internal faces into boundary faces. Does not duplicate
points, unlike mergeOrSplitBaffles
createPatch Utility to create patches out of selected boundary faces. Faces
come either from existing patches or from a faceSet
deformedGeom Deforms a polyMesh using a displacement field Uand a scaling
factor supplied as an argument
faceSet Selects a face set through a dictionary
flattenMesh Flattens the front and back planes of a 2D cartesian mesh
insideCells Picks up cells with cell centre ’inside’ of surface. Requires
surface to be closed and singly connected
mergeMeshes Merge two meshes
mergeOrSplitBaffles Detects faces that share points (baffles). Either merge them
or duplicate the points
mirrorMesh Mirrors a mesh around a given plane
moveDynamicMesh Mesh motion and topological mesh changes utility
moveEngineMesh Solver for moving meshes for engine calculations.
moveMesh Solver for moving meshes
objToVTK Read obj line (not surface!) file and convert into vtk
pointSet Selects a point set through a dictionary
refineMesh Utility to refine cells in multiple directions
renumberMesh Renumbers the cell list in order to reduce the bandwidth,
reading and renumbering all fields from all the time directories
rotateMesh Rotates the mesh and fields from the direcion n1to the direc-
tion n2
setSet Manipulate a cell/face/point set interactively
setsToZones Add pointZones/faceZones/cellZones to the mesh from similar
named pointSets/faceSets/cellSets
splitMesh Splits mesh by making internal faces external. Uses attachDe-
tach
splitMeshRegions Splits mesh into multiple regions
stitchMesh ’Stitches’ a mesh
Continued on next page
OpenFOAM-1.6
3.6 Standard utilities U-91
Continued from previous page
subsetMesh Selects a section of mesh based on a cellSet
transformPoints Transforms the mesh points in the polyMesh directory accord-
ing to the translate, rotate and scale options
zipUpMesh Reads in a mesh with hanging vertices and zips up the cells
to guarantee that all polyhedral cells of valid shape are closed
Other mesh tools
autoRefineMesh Utility to refine cells near to a surface
collapseEdges Collapse short edges and combines edges that are in line
combinePatchFaces Checks for multiple patch faces on same cell and combines
them. These result from e.g. refined neighbouring cells get-
ting removed, leaving 4 exposed faces with same owner
modifyMesh Manipulates mesh elements
refineHexMesh Refines a hex mesh by 2x2x2 cell splitting
refinementLevel Tries to figure out what the refinement level is on refined
cartesian meshes. Run before snapping
refineWallLayer Utility to refine cells next to patches
removeFaces Utility to remove faces (combines cells on both sides)
selectCells Select cells in relation to surface
splitCells Utility to split cells with flat faces
Post-processing graphics
ensightFoamReader EnSight library module to read OpenFOAM data directly
without translation
fieldview9Reader Reader module for Fieldview 9 to read OpenFOAM mesh and
data
PV3FoamReader ParaView 3 reader module
PVFoamReader ParaView reader module
Post-processing data converters
foamDataToFluent Translates OpenFOAM data to Fluent format
foamToEnsight Translates OpenFOAM data to EnSight format
foamToEnsightParts Translates OpenFOAM data to Ensight format. An Ensight
part is created for each cellZone and patch
foamToFieldview9 Write out the OpenFOAM mesh in Version 3.0 Fieldview-UNS
format (binary)
foamToGMV Translates foam output to GMV readable files
foamToVTK Legacy VTK file format writer
smapToFoam Translates a STAR-CD SMAP data file into OpenFOAM field
format
Post-processing velocity fields
Co Configurable graph drawing program
enstrophy Calculates and writes the enstrophy of the velocity field U
flowType Calculates and writes the flowType of velocity field U
Lambda2 Calculates and writes the second largest eigenvalue of the sum
of the square of the symmetrical and anti-symmetrical parts
of the velocity gradient tensor
Continued on next page
OpenFOAM-1.6
U-92 Applications and libraries
Continued from previous page
Mach Calculates and optionally writes the local Mach number from
the velocity field Uat each time
Pe Calculates and writes the Pe number as a
surfaceScalarField obtained from field phi
QCalculates and writes the second invariant of the velocity gra-
dient tensor
streamFunction Calculates and writes the stream function of velocity field U
at each time
uprime Calculates and writes the scalar field of uprime (p2k/3)
vorticity Calculates and writes the vorticity of velocity field U
Post-processing stress fields
stressComponents Calculates and writes the scalar fields of the six components
of the stress tensor sigma for each time
Post-processing scalar fields
pPrime2 Calculates and writes the scalar field of pPrime2 ([pp]2) at
each time
Post-processing at walls
wallGradU Calculates and writes the gradient of Uat the wall
wallHeatFlux Calculates and writes the heat flux for all patches as the
boundary field of a volScalarField and also prints the inte-
grated flux for all wall patches
wallShearStress Calculates and writes the wall shear stress, for the specified
times
yPlusLES Calculates and reports yPlus for all wall patches, for the spec-
ified times
yPlusRAS Calculates and reports yPlus for all wall patches, for the spec-
ified times
Post-processing turbulence
createTurbulenceFields Creates a full set of turbulence fields
RCalculates and writes the Reynolds stress Rfor the current
time step
Post-processing patch data
patchAverage Calculates the average of the specified field over the specified
patch
patchIntegrate Calculates the integral of the specified field over the specified
patch
Post-processing Lagrangian simulation
particleTracks Generates a VTK file of particle tracks for cases that were
computed using a tracked-parcel-type cloud
Sampling post-processing
probeLocations Probe locations
Continued on next page
OpenFOAM-1.6
3.6 Standard utilities U-93
Continued from previous page
sample Sample field data with a choice of interpolation schemes, sam-
pling options and write formats
Miscellaneous post-processing
dsmcFieldsCalc Calculate intensive fields (Uand T) from averaged extensive
fields from a DSMC calculation
engineCompRatio Calculate the geometric compression ratio. Note that if you
have valves and/or extra volumes it will not work, since it
calculates the volume at BDC and TCD
execFlowFunctionObjects Execute the set of functionObjects specified in the selected
dictionary (which defaults to system/controlDict) for the se-
lected set of times
pdfPlot Generates an .obj file to plot a probability distribution func-
tion
postChannel Post-processes data from channel flow calculations
ptot For each time: calculate the total pressure
wdot Calculates and writes wdot for each time
writeCellCentres Write the three components of the cell centres as
volScalarFields so they can be used in postprocessing in
thresholding
Parallel processing
decomposePar Automatically decomposes a mesh and fields of a case for
parallel execution of OpenFOAM
reconstructPar Reconstructs a mesh and fields of a case that is decomposed
for parallel execution of OpenFOAM
reconstructParMesh Reconstructs a mesh using geometric information only
redistributeMeshPar Redistributes existing decomposed mesh and fields according
to the current settings in the decomposeParDict file
Thermophysical-related utilities
adiabaticFlameT Calculates the adiabatic flame temperature for a given fuel
over a range of unburnt temperatures and equivalence ratios
chemkinToFoam Converts CHEMKIN 3 thermodynamics and reaction data files
into OpenFOAM format
equilibriumCO Calculates the equilibrium level of carbon monoxide
equilibriumFlameT Calculates the equilibrium flame temperature for a given fuel
and pressure for a range of unburnt gas temperatures and
equivalence ratios; the effects of dissociation on O2, H2O and
CO2are included
mixtureAdiabaticFlameT Calculates the adiabatic flame temperature for a given mix-
ture at a given temperature
Error estimation
estimateScalarError Estimates the error in the solution for a scalar transport equa-
tion in the standard form
icoErrorEstimate Estimates error for the incompressible laminar CFD applica-
tion icoFoam
Continued on next page
OpenFOAM-1.6
U-94 Applications and libraries
Continued from previous page
icoMomentError Estimates error for the incompressible laminar CFD applica-
tion icoFoam
momentScalarError Estimates the error in the solution for a scalar transport equa-
tion in the standard form
Miscellaneous utilities
expandDictionary Read the dictionary provided as an argument, expand the
macros etc. and write the resulting dictionary to standard
output
foamDebugSwitches Write out all library debug switches
foamFormatConvert Converts all IOobjects associated with a case into the format
specified in the controlDict
foamInfoExec Interrogates a case and prints information to screen
patchSummary Writes fields and boundary condition info for each patch at
each requested time instance
Table 3.6: Standard library utilities.
3.7 Standard libraries
The libraries with the OpenFOAM distribution are in the $FOAM LIB/$WM OPTIONS
directory, reached quickly by typing lib at the command line. Again, the names are
prefixed by lib and reasonably descriptive, e.g.incompressibleTransportModels contains
the library of incompressible transport models. For ease of presentation, the libraries are
separated into two types:
General libraries those that provide general classes and associated functions listed in
Table 3.7;
Model libraries those that specify models used in computational continuum mechanics,
listed in Table 3.8,Table 3.9 and Table 3.10.
Library of basic OpenFOAM tools OpenFOAM
algorithms Algorithms
containers Container classes
db Database classes
dimensionedTypes dimensioned<Type>class and derivatives
dimensionSet dimensionSet class
fields Field classes
global Global settings
graph graph class
interpolations Interpolation schemes
matrices Matrix classes
memory Memory management tools
meshes Mesh classes
primitives Primitive classes
Continued on next page
OpenFOAM-1.6
3.7 Standard libraries U-95
Continued from previous page
Finite volume method library finiteVolume
cfdTools CFD tools
fields Volume, surface and patch field classes; includes boundary
conditions
finiteVolume Finite volume discretisation
fvMatrices Matrices for finite volume solution
fvMesh Meshes for finite volume discretisation
interpolation Field interpolation and mapping
surfaceMesh Mesh surface data for finite volume discretisation
Mesh volume (cell) data for finite volume discretisation
Post-processing libraries
fieldFunctionObjects Field function objects including field averaging, min/max, etc.
foamCalcFunctions Functions for the foamCalc utility
forces Tools for post-processing force/lift/drag data with function
objects
postCalc For using functionality of a function object as a post-
processing activity
sampling Tools for sampling field data at prescribed locations in a do-
main
systemCall General function object for making system calls while running
a case
utilityFunctionObjects Utility function objects
Solution and mesh manipulation libraries
autoMesh Library of functionality for the snappyHexMesh utility
dynamicMesh For solving systems with moving meshes
dynamicFvMesh Library for a finite volume mesh that can move and undergo
topological changes
edgeMesh For handling edge-based mesh descriptions
errorEstimation Error estimation tools
fvMotionSolver Finite volume mesh motion solvers
ODE Solvers for ordinary differential equations
meshTools Tools for handling a OpenFOAM mesh
surfMesh Library for handling surface meshes of different formats
triSurface For handling standard triangulated surface-based mesh de-
scriptions
topoChangerFvMesh Topological changes functionality (largely redundant)
Lagrangian particle tracking libraries
coalCombustion Coal dust combustion modelling
dieselSpray Diesel spray and injection modelling
dsmc Direct simulation Monte Carlo method modelling
lagrangian Basic Lagrangian, or particle-tracking, solution scheme
lagrangianIntermediate Particle-tracking kinematics, thermodynamics, multispecies
reactions, particle forces, etc.
potential Intermolecular potentials for molecular dynamics
molecule Molecule classes for molecular dynamics
molecularMeasurements For making measurements in molecular dynamics
Continued on next page
OpenFOAM-1.6
U-96 Applications and libraries
Continued from previous page
solidParticle Solid particle implementation
Miscellaneous libraries
conversion Tools for mesh and data conversions
decompositionMethods Tools for domain decomposition
engine Tools for engine calculations
MGridGenGAMGAgglomerationLibrary for cell agglomeration using the MGridGen algorithm
OSspecific Operating system specific functions
randomProcesses Tools for analysing and generating random processes
Table 3.7: Shared object libraries for general use.
Basic thermophysical models basicThermophysicalModels
hPsiThermo General thermophysical model calculation based on en-
thalpy hand compressibility ψ
ePsiThermo General thermophysical model calculation based on inter-
nal energy eand compressibility ψ
hRhoThermo General thermophysical model calculation based on en-
thalpy h
pureMixture General thermophysical model calculation for passive gas
mixtures
Reaction models reactionThermophysicalModels
hPsiMixtureThermo Calculates enthalpy for combustion mixture based on ψ
hRhoMixtureThermo Calculates enthalpy for combustion mixture based on ρ
hhuMixtureThermo Calculates enthalpy for unburnt gas and combustion mix-
ture
homogeneousMixture Combustion mixture based on normalised fuel mass frac-
tion b
inhomogeneousMixture Combustion mixture based on band total fuel mass fraction
ft
veryInhomogeneousMixture Combustion mixture based on b,ftand unburnt fuel mass
fraction fu
dieselMixture Combustion mixture based on ftand fu
basicMultiComponent-
Mixture
Basic mixture based on multiple components
multiComponentMixture Derived mixture based on multiple components
reactingMixture Combustion mixture using thermodynamics and reaction
schemes
egrMixture Exhaust gas recirculation mixture
Radiation models radiation
P1 P1 model
fvDOM Finite volume discrete ordinate method
Continued on next page
OpenFOAM-1.6
3.7 Standard libraries U-97
Continued from previous page
Laminar flame speed models laminarFlameSpeedModels
constLaminarFlameSpeed Constant laminar flame speed
GuldersLaminarFlameSpeed G¨ulder’s laminar flame speed model
GuldersEGRLaminar-
FlameSpeed
G¨ulder’s laminar flame speed model with exhaust gas re-
circulation modelling
Barotropic compressibility models barotropicCompressibilityModels
linear Linear compressibility model
Chung Chung compressibility model
Wallis Wallis compressibility model
Thermophysical properties of gaseous species specie
icoPolynomial Incompressible polynomial equation of state, e.g. for liquids
perfectGas Perfect gas equation of state
eConstThermo Constant specific heat cpmodel with evaluation of internal
energy eand entropy s
hConstThermo Constant specific heat cpmodel with evaluation of enthalpy
hand entropy s
hPolynomialThermo cpevaluated by a function with coefficients from polynomi-
als, from which h,sare evaluated
janafThermo cpevaluated by a function with coefficients from JANAF
thermodynamic tables, from which h,sare evaluated
specieThermo Thermophysical properties of species, derived from cp,h
and/or s
constTransport Constant transport properties
polynomialTransport Polynomial based temperature-dependent transport prop-
erties
sutherlandTransport Sutherland’s formula for temperature-dependent transport
properties
Functions/tables of thermophysical properties thermophysicalFunctions
NSRDSfunctions National Standard Reference Data System (NSRDS) -
American Institute of Chemical Engineers (AICHE) data
compilation tables
APIfunctions American Petroleum Institute (API) function for vapour
mass diffusivity
Probability density functions pdf
RosinRammler Rosin-Rammler distribution
normal Normal distribution
uniform Uniform distribution
exponential Exponential distribution
general General distribution
Chemistry model chemistryModel
chemistryModel Chemical reaction model
chemistrySolver Chemical reaction solver
Continued on next page
OpenFOAM-1.6
U-98 Applications and libraries
Continued from previous page
Other libraries
liquids Thermophysical properties of liquids
liquidMixture Thermophysical properties of liquid mixtures
solids Thermophysical properties of solids
solidMixture Thermophysical properties of solid mixtures
Table 3.8: Libraries of thermophysical models.
RAS turbulence models for incompressible fluids incompressibleRASModels
laminar Dummy turbulence model for laminar flow
kEpsilon Standard high-Re k εmodel
kOmega Standard high-Re k ωmodel
kOmegaSST