OpenFOAM Tutorial

See
discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/282272911
OpenFOAM step by step tutorial
Technical Report · April 2015
CITATIONS READS
0 7,041
1 author:
Victor Pozzobon
Ecole Centrale Paris
7 PUBLICATIONS 8 CITATIONS
SEE PROFILE
Some of the authors of this publication are also working on these related projects:
Microalgae Lagragian tracking in photobioreactor View project
Available from: Victor Pozzobon

Retrieved on: 23 September 2016
OpenFOAM tutorial
OpenFOAM tutorial
Discover it, tame it, use it
by Victor Pozzobon
(victor.pozzobon@mines-albi.fr)
14th March 2016 Version 1.02

Disclaimer
“This offering is not approved or endorsed by

OpenCFD Limited, the producer of the
OpenFOAM software and owner of the
OPENFOAM® and OpenCFD® trade marks.”
14th March 2016 Pozzobon Victor 2

Introduction
● This tutorial is a brief introduction to

OpenFOAM
● This document is a step by step guide
● It was done to be used on its own, there should
be no need for a presenter (myself)
● It was designed for OpenFOAM 3.0.1 (changes
may appear in superior versions)

OpenFOAM
● OpenFOAM (Open Field Operation And

Manipulation) is a versatile equations solver
● Why do I use OpenFOAM ?
- free
- powerful
- opensource
- allows a lot of freedom
- no GUI (helps to focus on the equations)

How to use this tutorial
● Almost every command will passed through the

temrinal. For example, when you see:
gedit system/controlDict
you type it in the terminal
● As OpenFOAM has no GUI, we will modify files.
For example, when you see this kind of picture:
modify the file so that
its content is the same
before you save it

Battle plan
● Ex. 1: Cavity ● Ex. 6: Tubular reactor

- getting started - solver modifying (1/2)
● Ex. 2: Square tube ● Ex. 7: Tubular reactor
- mesh manipulation - solver modifying (2/2)
- steady state
● Ex. 8: Heating pipe
● Ex. 3: 1D beam - custom boundary
- 1D problem condition
- transient
● Ex. 9: Cake backing
● Ex. 4: 2D flat plate - field affectation
- 2D problem
● Ex. 10: Tank filling
● Ex. 5: 2D pipe - importing a mesh
- axisymmetric problem - run in parallel
Ex. 1: Cavity - Objectives
● Accessing your work directory

● Accessing OpenFOAM tutorials
● Understanding case architecture
● Running your first OpenFOAM case
● Postprocessing with ParaFoam: data modifying,
line date / point data extraction

Ex. 1: Cavity - Run
● To access your directory type in a terminal:

run
● To get the full path type:
pwd
● You will see:
/home/YourName/OpenFOAM/YourName-OpenFOAMVersion/run

Ex. 1: Cavity - Tutorials
● To copy official tutorials to your run:

cp -r $FOAM_TUTORIALS Tutorials
● Go to the case directory:
cd Tutorials/incompressible/icoFoam/cavity

Ex. 1: Cavity - Architecture
Case directory
Initial conditions directory
Pressure / Velocity initial conditions
Mesh directory
Mesh instructions
Physical properties values

Solving parameters directory
Parameters file
Ex. 1: Cavity – Run the case
● Once in 'cavity' directory, create the mesh:

blockMesh
● Call the solver:
icoFoam
(you can note that the solver created several
directories e.g. '0.1'. These directories contain
data for a given time)
● Watch the results:
paraFoam

Ex. 1: Cavity – Postprocessing
Data analysis pipeline
Load the case
Load geometric fields
Load the fields

Current
time
step
Plotted Observation tools

data
Plot Rescale
legend legend Time
step
tool
Legend
Scene

● Make it look shinier:

Filters / Alphabetical / Cell data to point data
● Calculate something:
Filters / Common / Calculator OR
● Extract profiles:
Filters / Data Analysis / Plot Over Line
● Extract histories:
Filters / Data Analysis / Plot Selection Over Time

Battle plan
● From Ex. 2 to Ex. 5, we are going to learn how

to use existing solvers in different
configurations.
● We are going to set 3D, 2D planar, 2D
axisymmetrical and 1D cases
● We are going to explore postprocessor basic
functions

Ex. 2: Square tube - Objectives
● Creating your own case

● Creating a mesh
● Specifying initial / boundary conditions
● Specifying physical properties values
● Solving a steady state problem
● Postprocessing with ParaFoam: integrating
variable / checking mass conservation

Ex. 2: Square tube – Case setup
● Solving steady state incompressible

Navier-Stokes equation, in a fourth of a square
pipe
⃗
dU p 2
⃗ ⃗
+ U ∇ . U =−∇ ρ +η ∇ U⃗
dt
2 cm 20 cm

Ex. 2: Square tube – A new case
● Go to your 'run' directory:

run
● Copy an existing case:
cp -r
$FOAM_TUTORIALS/incompressible/simpleFoam/pitzDaily/ Ex2
● Move to the case directory:
cd Ex2
● Open the mesh file:
gedit system/blockMeshDict

Ex. 2: Square tube – A new mesh
● A fourth of a square tube with symmetry plane

● Points have to be prescribed in order to bluid a
mesh (consider doing a sketch) 5 6 x
Wall 2
7 1
4
Inlet Outlet
y
Symmetry
0 3
14th March 2016 plane Pozzobon Victor 19
● Beware, the
points are to be Scaling
prescribed in factor
order not to
back cross a line Block division
● Do (0 4 7 3) along axis
Points
locations Division grading
4 7
0 3 Points needed to
14th March 2016 Pozzobon Victor build a block 20
Face
● Avoid (0 3 4 7) name
4 7
Face
type
0 3 Point sequence
delimiting the
face
Wall
Inlet Outlet

● Compile your mesh:

blockMesh
● Check its quality:
checkMesh

Ex. 2: Square tube – Turbulence
model and parameters
● Choose the turbulence
model. In this case, there
is no turbulence:
gedit constant/turbulenceProperties
● Because we disabled the
turbulence, there will
be no need to specify:
epsilon, k, nut and nuTilda
fields:
rm 0/epsilon 0/k 0/nut 0/nuTilda
0/f 0/omega 0/v2

Ex. 2: Square tube – IC / BC
● Open initial / boundary conditions files in the

'0' directory:
gedit 0/p
gedit 0/U
Physical field
Physical field unit

[ kg m s K mol A Cd]
Initial condition
Boundary condition
on 'inlet' patch
Ex. 2: Square tube – IC / BC, p
● Open initial / boundary

conditions for the pressure
field
Field type, here

scalar

Ex. 2: Square tube – IC / BC, U
● Open initial / boundary

conditions for the velocity
field
Field type, here

vector

Ex. 2: Square tube – Setting values
● Open transportProperties
file, this is where physical
properties value (e.g.
viscosity) are specified:
gedit constant/transportProperties
Property name
Property dimension
[ kg m s K mol A Cd]
Property value
Subdictionaries for some viscosity laws,
can be removed in our case
Ex. 2: Square tube – Control values
● Open case control file:

● Erase the “functions” and
below
End time = maximum

number of iteration
Constant “time step”

equals to 1

Ex. 2: Square tube – Control values
● In steady state, the maximum number of

iteration is prescribed using “endTime”. Yet, there
is no variation in time. It is a “trick”, nothing
more
Data are extracted every

50 iterations

Ex. 2: Square tube – Run the case
● The mesh has already been built, so let's run

the case:
simpleFoam
(it should converge in about 20 iterations)
● Have a look at the results:
paraFoam

Ex. 2: Square tube – Postprocessing
● Check mass conservation:

Filters / Common / Slice
Filters / Data Analysis / Integrate Variables
● Check velocity profile:
Filters / Data Analysis / Plot Over Line

Ex. 3: 1D beam - Objectives
● Setting a 1D case
● Solving a transient problem
● Postprocessing with ParaFOAM: importing
variables (other than p and U)

Ex. 3: 1D beam – Case setup
● Solving transient heat conduction a 1D beam

dT 2
=α ∇ T
dt Symmetry
planes
Hot side Cold side
20 cm

Ex. 3: 1D beam – Case creation
● Reach 'run' directory:

run
● Copy an existing heat transfer case:
cp -r $FOAM_TUTORIALS/basic/laplacianFoam/flange Ex3
cd Ex3
● Clean the case directory:
rm Allclean Allrun flange.ans
● Copy Ex2 mesh:
cp ../Ex2/system/blockMeshDict system/.

Ex. 3: 1D beam – Modifying mesh
● Modify file:
gedit system/blockMeshDict
● Build mesh:
blockMesh

Ex. 3: 1D beam – IC / BC
● Modify temperature file:

gedit 0/T

Ex. 3: 1D beam – Diffusivity
● Modify transport property

file:

Ex. 3: 1D beam – Control value
● Modify control dictionary:

● Run the case:
laplacianFoam
● Postprocess the case:
paraFoam

Ex. 3: 1D beam – Postprocessing
● Check T, as a 'Volume field' when loading data

Ex. 4: 2D flat plate - Objectives
● Setting a 2D case
● Building a 2 block mesh
● Changing convergence criterion
● Postprocessing with ParaFoam: plotting
streamlines

Ex. 4: 2D flat plate – Case setup
● Solving incompressible air flow above a flat

plate, in steady state
⃗
dU p 2 ⃗
⃗ ⃗
+ U ∇ . U =−∇ ρ +η∇ U
dt
3m
2m
2m
Ex. 4: 2D flat plate – Case creation

run
● Copy an existing case:
cp -r Ex2 Ex4
cd Ex4
rm -r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9*
(consider creating an alias)

Ex. 4: 2D flat plate – Mesh
● We will create a mesh made of two blocks.

●
Modify file: gedit system/blockMeshDict
Top
Inlet Outlet
Symmetry
wall
Block 1
Down Plate
Block 2
Ex. 4: 2D flat plate – Creating mesh
● Create the two blocks

●
blockMesh will
merge them

Ex. 4: 2D flat plate – Creating mesh
● Set the faces

● Build mesh:
blockMesh

Ex. 4: 2D flat plate – IC / BC
● Modify velocity file:

gedit 0/U

Ex. 4: 2D flat plate – IC / BC
● Modify pressure file:

gedit 0/p

Ex. 4: 2D flat plate – Viscosity
● Modify the kinematic viscosity:


Ex. 4: 2D flat plate – Convergence
● Modify pressure / velocity convergence criteria:

gedit system/fvSolution
● In this case, there are a
lot of options. Some
solvers are much
simpler
Solver
Solved type and
field options
Ex. 4: 2D flat plate – Convergence
● Simulations can be stopped automatically once

residues values have been reached
● For 2D cases, the unsolved
component of the velocity
vector prevents the solver from
reaching the tolerance most of
time. Therefore, a number of
iterations has to be
prescribed
Residues values
set for convergence
Ex. 4: 2D flat plate – Run the case
● The mesh has already been built

● The controlDict has not changed from Ex2. The solver
will run for 100 iterations. It is enough to get the
residues below 10-6
● Run the case:
simpleFoam
paraFoam

Ex. 4: 2D flat plate – Postprocessing
● Lower the first scene opacity:

'Click on the filter' / Display / Styling / Opacity
● Plot the streamline from the inlet:
Filters / Common / Stream Tracer
● Set streamlines' sources as a line, not a point:
'Click on stream tracer' / Properties / Seeds / Seed type =>
High resolution line source
● Set the line you want using the coordinates

Ex. 4: 2D flat plate – Postprocessing

Ex. 5: 2D pipe - Objectives
● Creating a 2D axisymmetrical mesh

● Nothing fancy ...

Ex. 5: 2D pipe – Case setup
● Solving incompressible flow in a 2D

axisymmetrical pipe, in steady state
⃗
dU p 2 ⃗
⃗ ⃗
+ U ∇ . U =−∇ ρ +η∇ U
dt 10 cm
1 cm

Ex. 5: 2D pipe – Case creation

run
● Copy an existing heat transfer case:
cp -r Ex2 Ex5
● Go to the new case directory:
cd Ex5
rm -r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9*

Ex. 5: 2D pipe – Mesh
● Modify file: gedit system/blockMeshDict
Axis
Outlet
Inlet
5°
Front and
Back
Wall
Ex. 5: 2D pipe – Block creation
● Draw a wegde,
with a 5° angle
(twice 2.5°)
● Points 1, 2 and 3 are
not used to build the cos(2.5°)
geometry. OpenFOAM
uses them to define sin(2.5°)
x, y and z directions :
- point 0 to point 1 = x
- point 1 to point 2 = y
- point 0 to point 4 = z
Ex. 5: 2D pipe – Patches creation
● In order to do things
by the book, create
two 'wedge' patches
(here, 'front' and
'back')
● It would have worked
with only one, but
checkMesh would have
returned an error

Ex. 5: 2D pipe – IC / BC p
● Set pressure boundary /

initial conditions:
gedit 0/p

Ex. 5: 2D pipe – IC / BC U
● Set veolicty boundary /

initial conditions:
gedit 0/U

Ex. 5: 2D pipe – Run the case
● (As usual now) The mesh has already been built,

the controlDict has not changed from Ex2. As for
Ex4, we have to set the desired number of
iterations:
● So let's run the case:
simpleFoam
paraFoam

Ex. 5: 2D pipe – Postprocessing
● E.g. check velocity profile

Battle plan
● We have used two different builtin solvers

(icoFoam, simpleFoam and laplacianFoam)
● We have set cases in 3D, 2D planar, 2D
axisymmetrical and 1D configurations
● We have learnt how to process data with
Paraview (paraFoam)
● We are going to learn how to solve our own
equations and set fancy cases

Ex. 6: Tubular reactor – Objectives
● Create our own solver

● Use basic operators
● Create the associated case

Ex. 6: Tubular reactor – Case setup
● 1D tubular reactor with heterogeneous catalysis

on porous media without chemical reaction in
steady state / hydrodynamics only
⃗ =0
∇ .U ⃗ = −κ
U μ ∇p ∇ 2 p=0
Symmetry
planes
Inlet Outlet
100 cm
Ex. 6: Tubular reactor – Solver
directory creation
run
● Create a solver directory:
mkdir solvers
● Copy an existing solver:
cp -r $FOAM_APP/solvers/basic/laplacianFoam solvers/.
● Rename the solver directory:
mv solvers/laplacianFoam solvers/tubeFoam

cleaning up
● Move to solver directory:
cd solvers/tubeFoam
● Clean the directory:
wclean
rm write.H
● Rename the file:
mv laplacianFoam.C tubeFoam.C

modification
● Modify compilation file:
gedit Make/files
● You can specify compilation options:
gedit Make/options
(None need to be applied here)

modification / createFields.H
● Modify createFields.H to
create the new fields:
gedit createFields.H
Pressure field
(scalar field)
Velocity field
(vector field)

read the physical
properties:
Physical property
called 'Mu'

modification / tubeFoam.C
● Modify tubeFoam.C
to specify the
equations that will
be solved:
gedit tubeFoam.C
Time loop
Correction loop
(not mandatory)
Solved equations
(implicit '=0')

compilation
● Clean the directory and compile:
wclean; wmake
● If you get an error, here is what to do:
1. Read the expection message
2. Get error file and line number
Error file
and line number
3. Take care of it

Ex. 6: Tubular reactor – Case
creation
● Now that the solver has been compiled, let's create
the case we are going to solve. Since it is a 1D
case, copy Ex3 (1D thermal beam) case directory:
run
cp -r Ex3 Ex6
● Go to the case directory, clean it:
cd Ex6
rm -r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9*
(consider creating an alias)

Ex. 6: Tubular reactor – Mesh
creation
● Create the mesh:
gedit system
/blockMeshDict

Ex. 6: Tubular reactor – IC / BC
● Build the mesh:

blockMesh
● Create IC / BC files:
mv 0/T 0/p
cp 0/p 0/U
gedit 0/p 0/U

Pressure field Velocity field
(scalar field) (vector field)

Ex. 6: Tubular reactor – Physical
properties
● Modify physical properties file:
gedit contant/transportProperties

Ex. 6: Tubular reactor – Numerical
schemes
● Modify numerical schemes in order to specify a
steady state resolution:
gedit system/fvSchemes

parameters
● Modify solver parameters:
Specify tolerance on pressure equation
as single iteration stopping criterion
Number of correction
iteration (used for non
orthogonal meshes)
Specify tolerance on pressure equation

as simulation stopping criterion

Ex. 6: Tubular reactor – Control
parameters
● Modify solver parameters:
● In this case, the solver is
only calculating a Laplacian
operator, Thus, a 10-6 residue
is reached quite fast
(2 iterations)
Changing it is not
mandatory

Ex. 6: Tubular reactor – Run it
● Let's run the case:

tubeFoam
● Process it:
paraFoam

Ex. 7: Tubular reactor – Objectives
● Create our own solver with more complex

equations
● Use common operators
● Evolving a case

Ex. 7: Tubular reactor – Case setup
● 1D tubular reactor with chemical reaction, in

transient state A +B=C
dA ⃗ 2
ω=v AB
+ ∇ .( U A)= D ∇ A−ω
dt
dB ⃗ 2
⃗ =0 2
+∇ .( U B)=D ∇ B−ω ∇ .U ∇ p=0
dt
dC ⃗ = −κ
U μ ∇p
2
⃗
+ ∇ .( U C)=D ∇ C +ω Symmetry
dt planes
Inlet Outlet
100 cm
directory creation
run
cd solvers
● Copy the existing solver:
cp -r tubeFoam tubeChemFoam
● Move to and clean the directory:
cd tubeChemFoam
wclean

modification
● Rename the file:
mv tubeFoam.C tubeChemFoam.C
● Modify compilation file:
gedit Make/files

● Modify createFields.H to create the species fields:
Defined in
the source
14th March 2016 Pozzobon Victor code 87
read the physical
properties:

modification / tubeChemFoam.C
● Modify
tubeChemFoam.C
to add species fields:
gedit tubeChemFoam.C
Interpolates the
velocity field on the
mesh in order to
later calculate the
divergence operator

compilation / Case creation
wclean; wmake
● Move to cases directory:
run
● Copy Ex6 directory:
cp -r Ex6 Ex7
cd Ex7

Ex. 7: Tubular reactor – Case
creation
rm -r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9*
● Build the mesh:
blockMesh
● Modify physical
properties:
gedit constant/transportPropeties

● Create file for the species fields: A field

cp 0/p 0/A
cp 0/p 0/B
cp 0/p 0/C
● Keep the existing files
for pressure and velocity
● Modify species files:
gedit 0/A
gedit 0/B
gedit 0/C
B field C field

Ex. 7: Tubular reactor – Numerical
schemes
● Set numerical schemes:

parameters
● Add solvers:
● Due to the use of the
divergence, we need to
use asymmetric solvers
for the species fields

Ex. 7: Tubular reactor – Control
parameters
● Add solvers:
● Run the case:
tubeChemFoam
● Process it:
paraFoam

Ex. 7: Tubular reactor – Nice pics

Ex. 8: Heating pipe – Objectives
● Modify an existing solver

● Create a variating boundary condition
● Evolve a case

Ex. 8: Heating pipe – Case setup

axisymmetrical pipe with heat transfer , in
steady state
10 cm
1 cm
⃗
dU p 2 ⃗
⃗ ⃗
+ U ∇ . U =−∇ ρ +η∇ U
dt
Ex. 8: Heating pipe – Case setup

axisymmetrical pipe with heat transfer, in
steady state
dT ⃗ T =−∇ .(−k ∇ T )
ρ Cp +ρ Cp ∇ . U
dt
T inlet = 20 °C
T surrounding = 80 °C
−k ∇ T . ⃗n =−h(T −T sur )
Ex. 8: Heating pipe – Solver
creation
run
cd solvers
●
Copy simpleFoam:
cp -r $FOAM_APP/solvers/incompressible/simpleFoam .
mv simpleFoam simpleThermFoam
● Move to the new solver directory:
cd simpleThermFoam

creation / modification
rm -r porousSimpleFoam/ SRFSimpleFoam/ simpleFoam.dep
wclean
● Rename icoFoam:
mv simpleFoam.C simpleThermFoam.C
● Change compilation file:
gedit Make/files

● Add temperature field
and related physical
properties to createFields.H:

● Carry on ...
Loading turbulence
model (we do not
use it in this case)
Add temperature
field

● Carry on ...
Loading
transportProperties
dictionary
Loading physical values

modification / simpleThermFoam.C
● Modify solver to add temperature equation:
gedit simpleThermFoam.C

compilation / boundary condition
wclean; wmake
run
● Create a directory to store boundary condition:
mkdir boundaryConditions
● Move to this directory:
cd boundaryConditions

Ex. 8: Heating pipe – Create
boundary condition
● Copy an existing boundary condition:
cp -r
$FOAM_SRC/finiteVolume/fields/fvPatchFields/derived/tot
alTemperature convectiveHeatFlux
● Move to the convectiveHeatFlux directory and
clean it (if need be):
cd convectiveHeatFlux
rm totalTemperatureFvPatchScalarField.dep

Ex. 8: Heating pipe – Modify
boundary condition
● Renane the boundary condition files:
mv totalTemperatureFvPatchScalarField.C
convectiveHeatFluxFvPatchScalarField.C
mv totalTemperatureFvPatchScalarField.H
convectiveHeatFluxFvPatchScalarField.H

Ex. 8: Heating pipe – Compilation
rules
● Create Make folder:
mkdir Make
● Create rule files:
gedit Make/files Make/options
files
options

boundary condition .H file
● Modify convectiveHeatFluxFvPatchScalarField.H:
gedit convectiveHeatFluxFvPatchScalarField.H
● Replace all “totalTemperature” occurences by
“convectiveHeatFlux” (consider using ctrl + H)



boundary condition .C file
● Modify convectiveHeatFluxFvPatchScalarField.C:
gedit convectiveHeatFluxFvPatchScalarField.C
● Replace all “totalTemperature” occurences by
“convectiveHeatFlux” (consider using ctrl + H)
● Change scalar affection to a gradient
affectation
● Set thermal gradient equation




● Compile the boundary condition:

wclean; wmake OR wclean; wmake libso

Ex. 8: Heating pipe – Create case
directory
run
● Copy Ex5 directory:
cp -r Ex5 Ex8
cd Ex8

Ex. 8: Heating pipe – Create case
directory
● Clean the cases directory:
rm -r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9*
● Modify physical properties:
gedit constant/transportPropeties

Ex. 8: Heating pipe – IC / BC
● Create temperature field:

cp 0/p 0/T
● Edit the field:
gedit 0/T

● Pick a solver for the temperature field:

Deliberately high to
prevent the problem
with the unsolved
component of the
velocity field (cf. Ex 4)

Ex. 8: Heating pipe – Schemes
● Choose numerical scheme for temperature

divergence:
● Keep the default
Laplacian scheme

Ex. 8: Heating pipe – Specify library
use
● Modify controlDict to specify
the use of convectiveHeatFlux
boundary condition:
● 1000 iterations maximum
should be enough
(mine converged after
402 iterations)

Ex. 8: Heating pipe – Run the case

blockMesh
● Run the case:
simpleThermFoam
● Open paraFoam:
paraFoam

Ex. 8: Heating pipe – Process the
case
● Have a look at the temperature field:

Ex. 9: Cake baking – Objectives
● Modify an existing solver

● Set a field that depend on another field
● Set custom field
● Use an existing case as initial condition
● We are going to simulate the backing of a cake:
- heating up with chocolate melting (20 min, 180°C)
- cooling down with chocolate solidification (1 hour)

Ex. 9: Cake baking – Case setup
● 2D cake backing, with chocolate phase change

dT 1 dC dLC
ρ Cp =−∇ .(−k ∇ T )+Q Q= ( − )Δ H
dt 2 dt dt
−Ea 1
dC RT −Ea T T surrounding = 180 °C
=− A 1 e C + A2 e LC
2
dt −k ∇ T . ⃗n =−h(T −T sur )
−Ea
d LC
1
−Ea T
=−A 2 e LC + A 1 e RT C
2
dt
Chocolate
Ex. 9: Cake baking – Solver
directory creation
run
cd solvers
● Copy the existing solver:
cp -r tubeFoam cakeFoam
● Move to and clean the directory:
cd cakeFoam
wclean

Ex. 9: Cake baking – Set
compilation rules
● Rename tubeFoam:
mv tubeFoam.C cakeFoam.C
● Change compilation file:
gedit Make/files

Ex. 9: Cake baking – Modiy
createFields.H
● Modify fields and physical properties:

Ex. 9: Cake baking – Modiy
createFields.H

Ex. 9: Cake baking – Modify the
solver
● Rename tubeFoam:
gedit cakeFoam.C

Ex. 9: Cake baking – Compile the
solver / create case
● Compile the solver:
wclean; wmake
● Move to 'run':
run
● Create the case directory:
cp -r Ex4 Ex9
cd Ex9

Ex. 9: Cake baking – Prepare case
● Clean the case:

rm -r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9* (I hope you created
that alias)
rm 0/U
● Create fields files:
cp 0/p 0/C
cp 0/p 0/LC
mv 0/p 0/T

Ex. 9: Cake baking – Create mesh
● Boundary name and location:
Top
Left
Down Right
SymmetryWall

Ex. 9: Cake baking – Create mesh
● Modify the mesh:

gedit system/blochMeshDict

Ex. 9: Cake baking – IC / BC

gedit 0/T


gedit 0/C


gedit 0/LC

Ex. 9: Cake baking – Chocolate
● We have to specify the position of every

chocolate chip. In this case, only three pieces
will be set. First, copy an existing dictionary:
cp
$FOAM_TUTORIALS/multiphase/interFoam/ras/damBrea
k/system/setFieldsDict system/.

Ex. 9: Cake baking – Chocolate
● Set the chips location

and shape:
gedit system/setFieldsDict

Ex. 9: Cake baking – Set properties
for the heating phase
● Set the physical properties for the heating
phase
● Chocolate solidification parameter are set to 0:

Ex. 9: Cake baking – Set properties
for the heating phase
● Set the case to transient
and specify solver features:

Ex. 9: Cake baking – Set control
parameters
● The heating phase
lasts 20 min (1800 s):

Ex. 9: Cake baking – Run the case

blockMesh
● Set chocolate field:
setFields
● Solve the case:
cakeFoam

Ex. 9: Cake baking – Modify the
case
● Now that the heating phase has been run,
modify physical properties value:
● This time, chocolate melting is disabled and
chocolate solidification is enabled

Ex. 9: Cake baking – Reset control
parameters
● The cooling phase
lasts 60 min (3600 s):
The last iteration will be

used as initialization

Ex. 9: Cake baking – Rerun the
case
● Solve the last part of the case:
cakeFoam
● Process the case:
paraFoam

Ex. 9: Cake baking – Process the
case
Temperature during the

Chocolate chips cooldown
location

Ex. 10: Tank filling - Objectives
● This case is really basic. Its purpose is only to

discuss topics that were left uncovered
● Import a mesh created with an external tool
● Run a case in parallel
● Exporting an animation

Ex. 10: Tank filling – Case setup
● Transient filling of a tank. Initially, it is full of air,

then, we are going to fill it using the two phases
flow solver interFoam
Air outlet
Water inlet
Tank walls

Ex. 10: Tank filling – A new case
● Go to your 'run' directory:

run
● Copy 'damBreak':
cp -r
$FOAM_TUTORIALS/multiphase/interFoam/laminar/dam
Break/ Ex10
cd Ex10

Ex. 10: Tank filling – Importing the
mesh
●
The mesh is called 'Tank.unv'. It was drawn using
salome. It should have already been provided to
you, if this is not the case, you can find it here:
http://perso.mines-albi.fr/~vpozzobo/dl/Tank.unv
● Move the mesh file to the case directory:
mv 'somewhere'/Tank.unv Ex10/.
● Import the mesh:
ideasUnvToFoam Tank.unv

Ex. 10: Tank filling – Importing the
mesh
● There is no need to build the mesh using
blockMesh, is has already been done when
importing it. Yet, it has to be resized: atmosphere
transformPoints -scale '(0.001 0.001 0.001)'
● You can check the
mesh using paraFoam: inlet
paraFoam
fixedWalls

Ex. 10: Tank filling – IC / BC
● Modify velocity
boundary conditions
according to the case
setup:
gedit 0/U
Negative because of
axis orientation

● Modify the pressure

boundary conditions:
gedit 0/p_rgh

● Copy the water phase file:

cp 0/alpha.water.org 0/alpha.water
● Keep the '.org' file. It is used as a backup in
case you would have modified the initial
condition using setFields
●
To prevent any problem, move the '.org' file to
the case root
mv 0/alpha.water.org .

● Modify the water

boundary conditions:
gedit 0/alpha.water

Ex. 10: Tank filling – Setting gravity
● Modify gravity orientation, so that the tank will

be vertical:
gedit constant/g
Negative because of
axis orientation

Ex. 10: Tank filling – Running
parallel
● OpenFOAM runs in parallel using a decomposition of
mesh and fields. You can specify the cut yourself or ask
scotch to do it for you (our call here). As a good rule of
thumb, each processor should at least have 30000 cells
to compute, if you want to see an increase in
computational speed.
● Copy the decomposition dictionary from an existing case:
cp
$FOAM_TUTORIALS/multiphase/interDyMFoam/ras/damBreakWithO
bstacle/system/decomposeParDict system/.

Ex. 10: Tank filling – Running
parallel
● Modify the decomposition dictionary:
gedit system/decomposeParDict
● Once it is done, decompose the case:
decomposePar
Number of processors
that are going to be
used

Ex. 10: Tank filling – Control values
● Open case control file:

● The tank takes about 40s to
fill up, which represented a
cpu time of 2 days for me.
So set endTime according to
your liking. I would advice
0.30s. It still requires
30 minutes to run

Ex. 10: Tank filling – Control values
● Note that interFoam uses an

adaptive time step
Maximum Courant
number
Maximum time step

(in second)

Ex. 10: Tank filling – Run the case
● The mesh has already been built. The case has

been split between processors, so let's run the
case:
mpirun -np 2 interFoam
Number of processors
you want to use (has to
be in agreement with
decomposeParDict)

Ex. 10: Tank filling – Post
processing the case
● The case can then be processed. First, create a
new directory to store the pictures that we will
use to build the animation:
mkdir Extraction
● Then launch the post processor:
paraFoam

Ex. 10: Tank filling – Postprocessing
● Load all the fields, then set opacity of the base

filter to 0.1:
Ex10.OpenFOAM / Style / Opacity
● Add a contour filter, on alpha.water field, with a
threshold of 0.1:
Filters / Common / Contour
● Change the background color to white:
Edit / View Settings ... / Choose color

● Set the camera angle to your liking by using the

mouse or the 'Adjust Camera' tool:
Adjust Camera
button

● Save the individual picture:

File / Save Animation ...
● Click 'Save Animation' on the prompted form
(the settings do not matter here)
● Pick 'Extraction' folder and choose a name for
the pictures (I chose 'Water')
●
Now paraFoam is filling 'Extraction' directory with
frames of the animation

● Close paraFoam and go 'Extraction' folder:

cd Extraction
● Create your .gif file:
convert -delay 10 -loop 0 Water.*.png Your.gif
Time between two

frames in milliseconds

It's over
● This tutorial is over, thank you for your attention

● I hope you enjoyed it
● It was just a brief and partial overview of
OpenFOAM possibilities
● Please feel free to contact me:
Victor.pozzobon@centralesupelec.fr

The extra mile
● The open source software, I use to draw and

mesh complex geometries:
SALOME: www.salome-platform.org
● Another open source software which can be
used to process high volume results:
VisIt: https://visit.llnl.gov
● Where I ask for help:
CFD Online: www.cfd-online.com/Forums/openfoam

It's over
Again, thank you for your attention.

OpenFOAM Tutorial

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

OpenFOAM Tutorial

Uploaded by

Copyright:

Available Formats

See

OpenFOAM step by step tutorial

Technical Report · April 2015

Microalgae Lagragian tracking in photobioreactor View project

Available from: Victor Pozzobon

14th March 2016 Version 1.02

“This offering is not approved or endorsed by

14th March 2016 Pozzobon Victor 2

● This tutorial is a brief introduction to

14th March 2016 Pozzobon Victor 3

● OpenFOAM (Open Field Operation And

14th March 2016 Pozzobon Victor 4

● Almost every command will passed through the

14th March 2016 Pozzobon Victor 5

● Ex. 1: Cavity ● Ex. 6: Tubular reactor

● Accessing your work directory

14th March 2016 Pozzobon Victor 7

● To access your directory type in a terminal:

14th March 2016 Pozzobon Victor 8

● To copy official tutorials to your run:

14th March 2016 Pozzobon Victor 9

Physical properties values

● Once in 'cavity' directory, create the mesh:

14th March 2016 Pozzobon Victor 11

Data analysis pipeline

Load the case

Load geometric fields

Load the fields

Plotted Observation tools

14th March 2016 Pozzobon Victor 13

● Make it look shinier:

14th March 2016 Pozzobon Victor 14

● From Ex. 2 to Ex. 5, we are going to learn how

14th March 2016 Pozzobon Victor 15

● Creating your own case

14th March 2016 Pozzobon Victor 16

● Solving steady state incompressible

14th March 2016 Pozzobon Victor 17

● Go to your 'run' directory:

14th March 2016 Pozzobon Victor 18

● A fourth of a square tube with symmetry plane

14th March 2016 Pozzobon Victor 21

● Compile your mesh:

14th March 2016 Pozzobon Victor 22

14th March 2016 Pozzobon Victor 23

● Open initial / boundary conditions files in the

Physical field unit

● Open initial / boundary

Field type, here

14th March 2016 Pozzobon Victor 25

● Open initial / boundary

Field type, here

14th March 2016 Pozzobon Victor 26

● Open case control file:

End time = maximum

Constant “time step”

14th March 2016 Pozzobon Victor 28

● In steady state, the maximum number of

Data are extracted every

14th March 2016 Pozzobon Victor 29

● The mesh has already been built, so let's run

14th March 2016 Pozzobon Victor 30

● Check mass conservation: