Académique Documents
Professionnel Documents
Culture Documents
1/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline I
1
Introduction
About this presentation
What are we working with
Before we start
Advanced processing
Case preparation
Bernhard F.W. Gschaider
2/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline II
Adding our own evaluations
Evaluations after the fact
Function plugins
4
Data extraction
Distributions
Bernhard F.W. Gschaider
3/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline III
Exporting data
Conclusions
4/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
5/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
6/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
7/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
8/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
9/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Limitation
packages
It is not sure whether well even be able to complete it
10/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
11/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
What is PyFoam
PyFoam is a library for
Manipulating OpenFOAM-cases
Controlling OpenFOAM-runs
It is written in Python
Based upon that library there is a number of utilities
For case manipulation
Running simulations
Looking at the results
All utilities start with pyFoam (so TAB-completion gives you an
overview)
Each utility has an online help that is shown when using the
--help-option
12/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
What is swak4Foam
From
http://openfoamwiki.net/index.php/Contrib/swak4Foam
swak4Foam stands for SWiss Army Knife for Foam. Like that knife
it rarely is the best tool for any given task, but sometimes it is
more convenient to get it out of your pocket than going to the
tool-shed to get the chain-saw.
It is the result of the merge of
funkySetFields
groovyBC
simpleFunctionObjects
unnecessary
Even for complex boundary conditions etc
Bernhard F.W. Gschaider
13/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
14/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
15/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
line. Short examples will be a single line (without output but a ">" to
indicate input)
> ls $HOME
Long examples will be a white box
Input will be prefixed with a > and blue
Long lines will be broken up
A pair of <brk> and <cont> indicates that this is still the same line in
the input/output
snip in the middle means: "There is more. But it is boring"
> this is an example for a very long command line that does not fit onto one line of <brk>
<cont> the slide but we have to write it anyway
first line of output ( short )
Second line of output which is too long for this slide but we got to read it in all <brk>
<cont> its glory
16/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Work environment
You will use two programs
A terminal
A text-editor
For the text-editor you have the choice (these should be
installed):
17/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
18/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
19/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
> zsh
You should see a more colorful prompt with (OF:-) on the left
Only with correct environment set (probably only on the stick)
Switch on Foam-Extend-3.1
> foamExtend
Now the prompt should show (OF:3.1-Opt)
Create a working directory and go there
20/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
21/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
pyFoamVersion.py
Information the utility gives
Machine
Used python
PYTHONPATH (where additional libraries are searched)
Information about the used PyFoam
Where configuration files are sought
Installed libraries relevant for PyFoam
With version if possible
22/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
23/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
24/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
25/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The case
Were going to use a plain tutorial case
Add stuff to it until the original author wont recognize it
anymore
The case is counterFlowFlame2D for the reactingFoam
solver
Simple combustion case
Plain blockMesh
On one side 100% mixture of CH4 comes in
On the other side 23% of O2
Burns in the middle
Products leave on top and bottom
CH4 + 2O2
CO2 + 2H2 O
Bernhard F.W. Gschaider
26/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
counterFlowFlame2D overview
27/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Cloning
First we get us the case
But only the things that are important
We use the first PyFoam-utility for it
And afterwards check the results
> p y Fo am C loneCase . py $FOAM_TUTORIALS / combustion / reactingFoam / ras /<brk>
<cont> c ou n te r Fl o wF la m e2 D counterFlameBase
PyFoam WARNING on line 117 of file / Users / bgschaid / OpenFOAM / foam - extend <brk>
<cont> -3.1/ ThirdParty / packages / PyFoam -0.6.3/ platforms / noarch / lib /<brk>
<cont> python2 .7/ site - packages / PyFoam / Applications / CloneCase . py : <brk>
<cont> Directory does not exist . Creating
> ls c o u n terFlameBase
0/
PyFoamHistory
counterFlameBase . foam
Allrun
constant /
system /
28/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
What is cloned
Files essential for the case
Initial directory 0 (but not other times)
system
constant
Files like Allrun
Some files are created
29/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
If the <brk>
Default
--- ---Options common to all PyFoam - applications
-- psyco - accelerated
-- profile - python
<cont> ) -- profile - cpython
<cont> )
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
31/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
> cd counterFlameBase
Prepare the mesh
> blockMesh
Check that everything is alright
> checkMesh
Bernhard F.W. Gschaider
32/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
33/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
34/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Window Nr 1 popping up
35/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
36/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
37/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Added files
PyFoam adds a number of files to the directory:
38/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
39/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Methan
40/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Oxygen
41/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The flame
42/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The products
43/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The flow
44/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
45/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
46/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Text)
Can be converted with a number of utilities
47/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
48/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
49/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
50/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Friends of pyFoamPlotRunner.py
The functionality of pyFoamPlotRunner.py can be found in two
other utilities:
pyFoamRunner.py Does all the PlotRunner does . . . except
plotting
Applications:
running on text-only displays
long runs
instance)
Bernhard F.W. Gschaider
51/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
52/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Use the plot watcher to plot data from the log file
In addition to the defaults plot at least the time-step
53/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Timestep plot
54/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Courant number
55/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Executiong time
56/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Iterations
57/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
58/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Parallel running
Decompose cases in one line
Create decomposeParDict
Run decomposePar
> pyFoamDecompose.py . 2
Runner-utilities know how to handle parallel cases
Prepend mpirun (or different utilities if configured)
Automatically append -parallel
--autosense-parallel checks whether the case is decomposed or
not and acts accordingly
Automatically gets the correct number of processors
59/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
60/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
"Simple" executing
Sometimes things should be executed in a different
OpenFOAM-environment
Without log-files
Without assuming the Foam calling convention
working Paraview
Fall back to the paraview of the other Version
61/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
62/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
63/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Temperature extremes
temperature range
DILUPBiCG : Solving for hs , Initial residual = 0.00546778 , Final residual =<brk>
<cont> 8.5528 e -08 , No Iterations 4
T gas min / max
= 292.977 , 983.056
DICPCG : Solving for p , Initial residual = 0.11851 , Final residual = <brk>
<cont> 8.22411 e -07 , No Iterations 49
64/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Regular expressions
Regular expressions are very popular for analyzing textual data
(pattern matching)
For instance in OpenFOAM for flexible boundary conditions
Python comes with a library for analyzing them
There are slightly different dialects
For instance there are slight differences between the regular expressions
of Python and OpenFOAM
But in 90% of all cases they behave the same
65/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
a((b+)a) would match "abba" with group 1 being "bba" and group 2 "bb"
To match "(aa)" youve got to write \(aa\)
Other special characters that occur frequently in OpenFOAM-output are []\{\}
66/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
T gas min/max
= 292.977, 983.056
T gas min\/max
= (.+), (.+)
T gas min\/max
= (.+)
67/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
68/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
"%f%"
In our example:
T gas min\/max
= (%f%), (%f%)
69/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The customRegexp-file
If a file customRegexp is found in the case by a Plot-utility it is read
It is in OpenFOAM-format:
a dictionary
all entries are dictionaries too
The name of the entry is used to identify the data (for instance during writing)
Most frequent entry in the dictionaries are:
expr This is required. A regular expression that a line must match. All
groups (enclosed by ()) are interpreted as data and plotted
theTitle String with the title of the plot
titles List of words/strings. The names that the data items will get in
the legend
customRegexp is important enough for PyFoam to be automatically cloned by
pyFoamCloneCase.py
70/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
First customRegexp
In the case create with the text-editor of choice a
customRegexp
customRegexp
temperatureExtremes {
expr " T gas min \/ max = (% f %) , (% f %) " ;
theTitle " Temperature Extremes " ;
titles (
min
max
);
}
PyFoamRunner.reactingFoam.logfile)
customRegexp is automatically found and used
Bernhard F.W. Gschaider
71/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Temperature curve
72/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
73/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
74/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
75/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
> mv 0 0.org
Run the preparation utility
> pyFoamPrepareCase.py .
This does
1 clears old data from the case
2 Copies 0.org to 0
3 Runs blockMesh
Could do a number of other things
evaluate templates
execute scripts
Details on this in my other talk today
Bernhard F.W. Gschaider
76/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
77/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
78/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
then on
79/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Adding simpleFunctionObjects
oldest part of swak4Foam
used to be an independent project
controlDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
);
functions {
carbonDioxide {
type banana ;
}
}
80/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
81/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Range of carbon-dioxide
volumeMinMax gets a list of fields
Calculates the minimum and maximum value of them and
outputs it
To a file in special directory
To the terminal . . . sometimes
controlDict
functions {
carbonDioxide {
type volumeMinMax ;
o u tpu tCo ntr olM ode timeStep ;
outputInterval 1;
verbose true ;
fields (
CO2
);
}
}
82/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
83/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Output of CO2
84/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
85/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
information
For all we know maximum could be only in one cell (all other
86/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
expressions
With some exceptions
Some additional OpenFOAM-specific things (like & for dot vector
product)
Should be easy to understand even if youre not familiar with these
programming languages
Let me repeat myself: a complete documentation for them is in the
87/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Adding swak-functionObjects
controlDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
" l i b s i m p l e S w a k F u n c t i o n O b j e c t s . so "
);
88/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
controlDict
specieCH4 {
type swakExpression ;
valueType internalField ;
o u t p u tCo nt rol Mod e timeStep ;
out putInterval 1;
expression " CH4 " ;
accumulations (
min
w e igh ted Qua nti le0 .25
w eightedAverage
w e igh ted Qua nti le0 .75
max
);
verbose true ;
}
89/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
accumulations
90/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
91/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
weighted accumulations
Take a weight of the values into account
For the internalField the weights are the cell volume
Weighted values are usually physically more meaningful
Especially for mesh with large differences in cell sizes
For average a tiny cell would contribute as much as a huge cell
This is usally not what we mean with "average temperature" as it
depends on the discretization
weightedAverage does
P
TV
Pi i i
i Vi
or as we say in swak for a internalField
"sum(T*vol())/sum(vol())"
92/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
93/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Fields
When swak finds an unknown name in an expression then it
94/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Autowrite
=========
Yes
No
Yes
No
Yes
No
Yes
Yes
No
No
No
Yes
95/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
controlDict
specieO2 {
$specieCH4 ;
expression " O2 " ;
}
specieH2O {
$specieCH4 ;
expression " H2O " ;
}
specieCO2 {
$specieCH4 ;
expression " CO2 " ;
}
96/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
ClockTime = 194 s
97/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
customRegexp
This would be tedious
Wed get four different plot windows
With more complicated chemical reactions the problem gets
worse
But as the outputs look quite similar the regular expressions
offer a solution
98/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Dynamic Plotting
99/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
100/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
101/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
102/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
axis"
Useful if values of different scale should be in one scale
103/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
104/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Setting GnuPlot-options
A number of options usually set with the set-keyword in Gnuplot can be set in the
105/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
106/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Variables
107/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
expressionField
The library swakFunctionObjects adds function objects that
"only" use expressions
No timeline-recording etc
controlDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
" l i b s i m p l e S w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k F u n c t i o n O b j e c t s . so "
);
108/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Calculating
controlDict
The molar masses (12.0107 etc) are hard-coded here
stoe chiometric {
type expressionField ;
fieldName lambda ;
autowrite true ;
outputControl timeStep ;
out putInterval 1;
variables (
" MCH4 = 1 2 . 0 1 0 7 + 4* 1 . 0 0 7 9 4 ; "
" MO2 =2*15.9994; "
);
expression " (0.5* O2 / MO2 ) /( max ( CH4 ,1 e -10) / MCH4 ) " ;
}
109/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
110/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
111/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
one face
Summing it up gives the total mass flow on a patch
112/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
controlDict
massFlows {
type patchExpression ;
valueType internalField ;
o u t p u tCo nt rol Mod e timeStep ;
out putInterval 1;
patches (
" .* "
);
expression " phi " ;
accumulations (
sum
);
verbose true ;
}
113/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
114/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
<name>{<type><ename>}=<expression>;
Meaning: Calculate expression on entity ename of type type
115/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
"#<name>;"
means "Get variable list from name and insert it here"
This allows splitting and reusing variable lists
116/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
117/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
118/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
customRegexp
massFlowSum {
type slave ;
master massFlows ;
expr " Expression massFlowSum : average =(% f %) " ;
titles (
sum
);
}
119/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
controlDict
rel at i ve Deficit {
$massFlowSum ;
variables (
" # patchMF ; "
" sumMass { internalField }= sum ( vol () * rho ) ; "
);
expression " ( sum ( phi ) + fuelMF + airMF ) / sumMass " ;
}
120/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
customRegexp
rel at i ve Deficit {
type slave ;
master massFlows ;
expr " Expression relativeDeficit : average =(% f %) " ;
titles (
deficit
);
}
121/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
customRegexp
massFlows {
theTitle " Mass flows " ;
expr " Expression massFlows on (.+) : sum =(% f %) " ;
type dynamic ;
idNr 1;
titles (
sum
);
alternateAxis (
deficit
);
}
122/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Mass-flows plotted
123/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
124/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
4000
0.000518583
0.0942368
376.947
0.0932
|
|
|
|
|
8e -08
0.188743
0.0942368
7.53895 e -09
0.0932
End
125/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Fancy numbers
126/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
127/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Why plugins
There are functions that are of interest for some
But not for all
Adding them to the regular grammar would
Complicate the grammar
Would bloat the basic swak library
be problematic because the solver may not have the required
fields
Turbulence for instance
Would not solve the problem something very special is required
For instance a wrapper for a in-house chemistry solver
128/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
The first time the parser is called it prints a list of all available
functions
With parameter descriptions
Bernhard F.W. Gschaider
129/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
constrolDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
" l i b s i m p l e S w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k C h e m i s t r y M o d e l F u n c t i o n P l u g i n . so "
);
130/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
131/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
132/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
controlDict
rea ct i on RateCH4 {
type expressionField ;
fieldName RRCH4 ;
outputControl outputTime ;
autowrite true ;
expression " psiChem_RR ( CH4 ) " ;
}
133/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
134/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
135/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Reaction rate O2
136/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Exercise
137/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
constrolDict
r e a c t i o n R at eE rro r {
$ r e a c tionRateCH4 ;
fieldName RRError ;
expression " psiChem_RRError () " ;
}
reactionTime {
$ r e a c tionRateCH4 ;
fieldName tc ;
expression " psiChem_tc () " ;
}
138/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
139/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Time of chemistry
140/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
RR =
Ynew Yold
t
141/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
reaction rate
Function psiChem_updateChemistry triggers a recalculation
of the chemistry
Argument is t
Returns 0
Subsequent calls to psiChe_ use the new reaction rates
controlDict
reactionRateCH4Small {
$ r e a c tionRateCH4 ;
fieldName RRCH4Small ;
expression " p s i C h e m _ u p d a t e C h e m i s t r y (0.0000001) + psiChem_RR ( CH4 ) " ;
}
142/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
143/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Case preparation
Adding our own evaluations
Evaluations after the fact
Function plugins
Exercise
144/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
145/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
146/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
147/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
groovyBC
This is probably the most popular part of swak
It allows setting boundary conditions by writing
swak-expressions
constrolDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
" l i b s i m p l e S w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k C h e m i s t r y M o d e l F u n c t i o n P l u g i n . so "
" libgroovyBC . so "
);
148/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Using groovyBC
Set the type of the boundary condition to groovyBC
The three entries used are:
149/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
150/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
151/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Running
Important: First do
> pyFoamPrepareCase.py .
This copies 0.org to 0
Then run reactingFoam
152/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Changed velocity
153/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Exercises
154/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
155/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Adding feedback
156/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
topoSources in swak
Utilities like setSet or topoSet use sub-classes of
topoSource
swak4Foam specifies such sub-classes
Allows using of expressions
controlDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
" l i b s i m p l e S w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k C h e m i s t r y M o d e l F u n c t i o n P l u g i n . so "
" libgroovyBC . so "
" l i b s w a kT o po S ou r ce s . so "
);
157/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
meshCreate.sh
# ! / usr / bin / env bash
rm - rf constant / polyMesh / sets
blockMesh
setSet - batch system / setSet . middleCircle
158/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
system/setSet.middleCircle
cellSet testRange new expressionToCell " mag ( pos () - vector (0.01 ,0 ,0) ) <0.005 "
159/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
160/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
161/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
testRange
0.org/O2
air
{
type
groovyBC ;
value
uniform 0.23;
variables (
" highVal =0.23; "
" lowVal =0.1; "
" threshold =1800; "
" targetT { cellSet testRange }= sum ( T * vol () ) / sum ( vol () ) ; "
);
v al ue Expression " targetT < threshold ? highVal : lowVal " ;
}
162/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Nitrogren
0.org/N2
air
{
type
groovyBC ;
value
uniform 0.77;
v al ue Expression " 1 - O2 " ;
}
163/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
reactingFoam
164/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
165/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
166/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Exercises
167/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
168/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Ancient history
The oldest part of swak4Foam is funkySetFields
It is where the idea of general expressions was first
implemented
Capabilities
Creating new fields
Manipulation existing ones
Used for
Post-processing: "I need the temperature in Fahrenheit instead
of Kelvin"
Pre-processing: "I need an alpha1 initial condition in the form
of a semi-sphere"
169/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Command-line mode
170/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
zeroGradient
A list valuePatches can be specified
These are fixedValue and get their value from the next cell
171/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
mode"
Reads dictionary with a list expression in it
In the list sub-dictionaries
Will be "executed" in sequence
Format of the dictionaries is a mixture of swakExpression
and a funkySetFields-call
Options from the command line are entries in the dictionary
172/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Initializing chemistry
Idea: let amount of CH4 gradually rise from fuel to air
Other way round for O2
"Burning" would start sooner
The presented solution is more general than necessary:
1 Calculate center of air-patch
Same for fuel
173/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Calculate CH4
system/funkySetFieldsDict.setInitialChemistry
expressions
(
initMethan
{
field CH4 ;
calcDistance (
" centerFuel { fuel }= sum ( pos () * area () ) / sum ( area () ) ; "
" centerAir { air }= sum ( pos () * area () ) / sum ( area () ) ; "
" fromTo =( centerAir - centerFuel ) / mag ( centerAir - centerFuel ) ; "
" distance =( fromTo & ( pos () - centerFuel ) ) / mag ( centerAir -<brk>
<cont> centerFuel ) ; "
);
variables (
" # calcDistance ; "
" valFuel { fuel }= sum ( area () * $field ) / sum ( area () ) ; "
" valAir { air }= sum ( area () * $field ) / sum ( area () ) ; "
);
expression " valFuel + distance *( valAir - valFuel ) " ;
keepPatches true ;
}
174/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Same for O2
system/funkySetFieldsDict.setInitialChemistry
initOxygen
{
field O2 ;
calcDistance (
" centerFuel { fuel }= sum ( pos () * area () ) / sum ( area () ) ; "
" centerAir { air }= sum ( pos () * area () ) / sum ( area () ) ; "
" fromTo =( centerAir - centerFuel ) / mag ( centerAir - centerFuel ) ; "
" distance =( fromTo & ( pos () - centerFuel ) ) / mag ( centerAir - centerFuel ) ; "
);
variables (
" # calcDistance ; "
" valFuel { fuel }= sum ( area () * $field ) / sum ( area () ) ; "
" valAir { air }= sum ( area () * $field ) / sum ( area () ) ; "
);
expression " valFuel + distance *( valAir - valFuel ) " ;
keepPatches true ;
}
175/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The $
176/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
system/funkySetFieldsDict.setInitialChemistry
initRest
{
field N2 ;
keepPatches true ;
expression " 1 -( CH4 + O2 ) " ;
}
test
{
field sumSpec ;
create true ;
expression " CH4 + O2 + N2 " ;
}
);
177/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
> pyFoamPrepareCase.py .
casePrepare.sh
# ! / usr / bin / env bash
funk ySetFields - time 0 - dictExt s e t I n i t i a lC h e m i s t r y - noCacheVariables
178/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
179/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Exercises
for post-processing
Initialize U with a pattern that approximates the final solution
180/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
181/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Nice thing about simulations is that you can do things that are
be changed
182/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Setting k
controlDict
limitLowerK {
type manipulateField ;
outputControl timeStep ;
out putInterval 1;
fieldName k ;
variables (
" inK { fuel }= sum ( k * area () ) / sum ( area () ) ; "
);
expression " inK " ;
mask " pos () .y <0 && k > inK " ;
}
183/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
184/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
185/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Temperature differs
186/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
187/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Because we can
But sometimes there are sensible reasons:
Use particles for visualizing the flow
Solver doesnt support particles but were interested in the way
particles behave
188/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
189/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
kinematicCloudProperties
// Inj ectionModel
Inje ctionModel
ConeInjection ;
PatchInjection ;
190/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
kinematicCloudProperties
PatchPostProcessingCoeffs
{
m a x S t oredParcels 10000;
patches (
// in
// out
outlet
);
}
191/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
controlDict
libs (
" l i b s i m p l e F u n c t i o n O b j e c t s . so "
" l i b s i m p l e S w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k F u n c t i o n O b j e c t s . so "
" l i b s w a k C h e m i s t r y M o d e l F u n c t i o n P l u g i n . so "
" libgroovyBC . so "
" l i b s w a kT o po S ou r ce s . so "
" l i b s i m p l e L a g r a n g i a n F u n c t i o n O b j e c t s . so "
);
192/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
phase
Could as well be completely different fields (for instance an
expressionField)
controlDict
fuelParticles {
type e v o l v e K i n e m a t i c C l o u d ;
cloudName kinematicCloud ;
rhoName rho ;
UName U ;
muName mu ;
}
193/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
=
=
=
=
465
1.37407 e -05
303
8.95362 e -06
Time = 0.0515972
Solving chemistry
194/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
195/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
writes them
Caution: use it only when needed as it will require a lot of
memory
And a little CPU-time
constrolDict
l a s t T h r e e T im e st e ps {
type w r i t e O l d T i m e s O n S i g n a l ;
n u m b e r O f T i m e s t e p s T o S t o r e 3;
writeCurrent true ;
}
196/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
197/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
198/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Exercises
Try to set up customRegexp to reproduce the previous graph
Print statistics about the velocity of the particles relative to
199/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
200/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
201/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Why distributions
Sometimes the single values from the accumulations are not
enough information
but the full data-set is too much
202/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
swakExpression
Calculates expression and the computes how it is distributed
Expression weight determines how each value is weighted
For internal fields the cell volume is physically correct
But sometime something different is needed
Logical expression mask determines whether this value is
distribution is sampled
Value will be adapted if needed, but choose a sensible starting
value
Bernhard F.W. Gschaider
203/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
constrolDict
distributionT {
type s w a k E x p r e s s i o n D i s t r i b u t i o n ;
valueType internalField ;
o u t p u tCo nt rol Mod e deltaT ;
out putInterval 1;
outputDeltaT 0.01;
verbose true ;
expression " T " ;
writeTimeline true ;
w r i t e Dis tr ibu tio n true ;
weight " vol () " ;
mask " true " ;
d i s t r i b u t i o n B i n W i d t h 20;
}
204/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
outputControlMode deltaT
This is swak-specific
Used in cases where
Output every timestep would be too much data
Only at output-times would not be enough
Executes the function object every outputDeltaT seconds
(simulation time)
Does not manipulate the time-stepping
Therefor will not be exactly outputDeltaT apart
But it tries
205/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
taken
controlDict
d i s t r i b u t i on T ov e rX {
$di stributionT ;
type s w a k E x p r e s s i o n A v e r a g e D i s t r i b u t i o n ;
abscissa " pos () . x " ;
binNumber 50;
valueIfZero 0;
}
206/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
sample
But it can do distributions too
207/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Using gnuplot
pyFoamSamplePlot.py (and pyFoamTimelinePlot) do not
plot themselves
They only create commands for gnuplot
> p y F o a m S amplePlot . py . -- dir = postProcessing /<brk>
<cont> s w a k E x p r e s s i o n D i s t r i b u t i o n _ d i s t r i b u t i o n T / distributions --is -<brk>
<cont> distribution -- line = x -- field = normalised -- mode = complete -- time<brk>
<cont> =0.1 -- time =1 -- time =0.95
set term png
set output "<brk>
<cont> p o s t P r o c e s s i n g _ s w a k E x p r e s s i o n D i s t r i b u t i o n _ d i s t r i b u t i o n T _ d i s t r i b u t i o n s <brk>
<cont> . png "
plot [ ] [ 0 . 0 0 0 2 7 5 : 0 . 0 0 3 5 7 5 ] " ./ postProcessing /<brk>
<cont> s w a k E x p r e s s i o n D i s t r i b u t i o n _ d i s t r i b u t i o n T / distributions /0.1/<brk>
<cont> e x p r e s s i o n _ d i s t r i b u t i o n _ x " using 1:2 title " normalised at t<brk>
<cont> =0.100000 " with lines , " ./ postProcessing /<brk>
<cont> s w a k E x p r e s s i o n D i s t r i b u t i o n _ d i s t r i b u t i o n T / distributions /1/<brk>
<cont> e x p r e s s i o n _ d i s t r i b u t i o n _ x " using 1:2 title " normalised at t<brk>
<cont> =1.000000 " with lines , " ./ postProcessing /<brk>
<cont> s w a k E x p r e s s i o n D i s t r i b u t i o n _ d i s t r i b u t i o n T / distributions /0.95/<brk>
<cont> e x p r e s s i o n _ d i s t r i b u t i o n _ x " using 1:2 title " normalised at t<brk>
<cont> =0.950000 " with lines
> p y F o a m S amplePlot . py . -- dir = postProcessing /<brk>
<cont> s w a k E x p r e s s i o n D i s t r i b u t i o n _ d i s t r i b u t i o n T / distributions --is -<brk>
<cont> distribution -- line = x -- field = normalised -- mode = complete -- time<brk>
Bernhard
Gschaider
swak4Foam and PyFoam
208/226
<cont> =0.1 -- time
=1 --F.W.
time =0.95
| gnuplot
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
209/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Exercises
210/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
211/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Writing data
Instead of plotting pyFoamSamplePlot.py and
212/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
213/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
214/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
215/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
216/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
217/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
Plotting only O2
On the ipython-shell
In [1]: % matplotlib
Using matplotlib backend : Qt4Agg
In [2]: specData = self . getData () [ " plotData " ][ " species " ]
In [3]: specData [[ " O2_25 % " ," O2_75 % " ]]. plot ()
Out [3]: < matplotlib . axes . AxesSubplot at 0 x10d669210 >
In [4]: ( specData [ " O2_75 % " ] - specData [ " O2_25 % " ]) . describe ()
Out [4]:
count
1683.000000
mean
0.122822
std
0.028402
min
0.073966
25%
0.094794
50%
0.123427
75%
0.149328
max
0.167547
dtype : float64
In [5]:
218/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Distributions
Exporting data
219/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Outline
1
Introduction
About this presentation
What are we working with
Before we start
Basic case setup
Getting the case
Running
Not so basic uses
Basic plotting
Advanced processing
Case preparation
Adding our own evaluations
220/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Further reading
This presentation only covered parts of PyFoam and
221/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Further presentations
222/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Exercise
mentioned today?
223/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
The exercises
https://bitbucket.org/bgschaid/
counterflowflame2dswak4foampyfoam_ofw10/
Feel free to fork it and add your own stuff
224/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
Goodbye to you
225/226
Introduction
Basic case setup
Advanced processing
Manipulating the case
Data extraction
Conclusions
226/226