Open Form Post Processing

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.
Introductory OpenFOAM Course
University of Genoa, DICCA
Dipartimento di Ingegneria Civile, Chimica e Ambientale
From 17
th
to 21
th
February, 2014
Your Lecturer
Joel GUERRERO

joel.guerrero@unige.it

guerrero@wolfdynamics.com
Matteo BARGIACCHI

matteo.bargiacchi@unige.it

bargiacchi@wolfdynamics.com
Todays lecture
1. Data visualization with paraFoam
2. Data visualization with VISIT
3. Data manipulation and conversion
4. The sample utility
5. Probes
6. functionObjects
7. foamLog
8. More post-processing utilities
9. Hands-on session

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.
Big spoiler alert for those who like cool and
fantastic looking CFD pictures.
But before be begin
Cool and fantastic looking pictures do not imply
that the results are correct.
But before be begin
As we are going to do some post-processing, I want to
remind you that CFD does not stand for

Colorful Fluid Dynamics
Careful Fit of Data
But before be begin
Since its beginning, CFD has come a long way.
At the beginning nothing worked. Then things started to
work. Today almost everything work, but there is still
room for improvement.
Thus, despite the tremendous progress, we still have
major concerns on the accuracy and reliability of CFD
solutions, in other words, uncertainty quantification.
Today, we are no longer happy with pretty pictures. We
want quantitative results to guide decisions.
This lecture is not about uncertainty quantification, but
we are going to address how to compute the quantities of
interest needed to assess the solution and take decisions.
But before be begin
Remember, what you have done could be completely
physically wrong, so colorful pictures do not mean
physically correct results.
There is no way to know if your solution is fine or
acceptable without knowing the physics involve and the
theoretical background. Specially, if you did not take part
of the solution process.
Always be skeptical with the results (do not believe any
simulation results) and use common sense when
interpreting the results.
But before be begin
If experimental data is available, compare it with the
numerical solution. This is validation in action.
But again, the experimental data can be wrong or biased
due to measurements errors.
Finally, CFD is no longer reserve to the aerospace
community or the field of aerodynamics. It is now
complex multi-physics, that goes from continuum to
molecular level.
But before be begin
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

Data visualization with paraFoam
paraFoam is the main post-processor distributed with OpenFOAM.
However, you can use other alternatives (commercial or open
source).
paraFoam is a wrapper of a third-party open source product named
Paraview (www.paraview.org).
Paraview is based on VTK, the visualization toolkit (www.vtk.org).
paraFoam comes with many built-in filters. By using these filters you
can manipulate your data in order to create vectors, streamlines, iso-
surfaces, cut-planes, plot over a lines, and so on.

We will now do some post-processing using paraFoam. From now on follow
me.
Go to the postprocessing/cavity3d/ directory. In the terminal type:
cd $ptofc/postprocessing/cavity3d/c1
blockMesh
icoFoam
paraFoam
paraFoam generates a file named case_name.OpenFOAM (where
case_name is the name of the case, cavity3d in this tutorial), which is
necessary since Paraview needs a file to be specified.
If you want to read multiple cases, you will need to generate the
case_name.OpenFOAM file manually. In the terminal,
touch new_case_name.OpenFOAM
Mesh and initial conditions of passive scalar
By following the instructions, you should get something like this
Contours of velocity magnitude in two different cutplanes
Iso-surfaces of passive scalar colored by velocity
magnitude
Volume rendering of passive scalar colored by T
concentration
We will now do some post-processing using paraFoam. From now on follow
me.
Go to the postprocessing/yf17/ directory. In the terminal type:
cd $ptofc/postprocessing/yf17
cd c1
cp r fs_0.20 0.20
paraFoam
We do not need to run this case, the solution is in the directory
postprocessing/yf17/fs_0.20
The mesh is in the directory postprocessing/yf17/mesh
At this point, try to get familiar with the user interface and most important, try
to use all the features available in paraFoam.

Try to capture the vortex


Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

Data visualization with VISIT
VISIT is an open source interactive parallel visualization and graphical
analysis tool.
VISIT was developed by the U.S. Department of Energy (DOE) Advanced
Simulation and Computing Initiative (ASCI) to visualize and analyze the
results of terascale simulations
VISIT contains a rich set of visualization filters for data manipulation.
VISIT can read OpenFOAM native format.
VISIT can also read other formats, such as VTK format. To convert the
OpenFOAM results to VTK format you need to use the foamToVTK utility.
VISIT can be downloaded from the following site:
https://wci.llnl.gov/codes/visit/home.html
Personally speaking, for large datasets, I do prefer to use VISIT rather than
paraFoam.
Let us do some post-processing using VISIT.
From now on follow me.
Go to the postprocessing/damBreak directory. In the terminal type:
cd $ptofc/postprocessing/damBreak/c1
blockMesh
cp 0/alpha1.org 0/alpha1
setFields
interFoam
To do post-processing with VISIT, let us first convert the case to VTK format.
In the terminal type:
foamToVTK
cd VTK
visit
(I added this alias to my .bashrc file)
Mesh Initial conditions
VOF Fraction
VOF Fraction volume rendering
Go to the postprocessing/vespacoarse directory. In the terminal
type:
cd $ptofc/postprocessing/vespacoarse/c1
We do not need to run this case, the solution is in the directory
postprocessing/vespacoarse/c1/fs_500
To do post-processing with VISIT, let us first convert the case to VTK format.
In the terminal type:
cp -r fs_500 500
foamToVTK -latestTime
cd VTK
visit
(I added this alias to my .bashrc file)

Pressure contours and bounding box
Pressure contours on driver and motorcycle and cut plane with velocity
magnitude contours
Pressure contours on driver and motorcycle and velocity magnitude volume rendering
Surface mesh and cut plane with velocity vectors
Pressure contours on driver and motorcycle
Normal rendering Red/Green Stereo rendering (eye angle 4)
Red/Green Stereo rendering (eye angle 4). Pressure contours on driver and motorcycle
Red/Green Stereo rendering (eye angle 0.8). Pressure contours on driver and motorcycle
The mesh was generated using snappyHexMesh, so feel free to take a look
at the snappyHexMesh dictionary and the .stl file containing the
geometry.
I really like this geometry, it is an actual 3D scan of a Vespa scooter. I
would like to thanks Paul McIntosh for sharing the geometry and the case
setup (http://www.vespalabs.org).
At this point, try to get familiar with the user interface and most important, try
to use all the features available in VISIT.
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

Data manipulation and conversion
OpenFOAM comes with many data manipulation utilities. These
utilities can be found in the $FOAM_UTILITIES directory (use alias
util to go there).
OpenFOAM utilities can also be cloned and customized to create
user defined utilities. Always remember to develop your own utilities
in your user directory (WM_PROJECT_USR_DIR) and to keep the same
directory structure as in the original OpenFOAM installation.
In the postProcessing directory, you will find the data manipulation
utilities for post-processing. For example, in the sub-directory
postProcessing/velocityField you will find the following
utilities source code directories: Co, Pe, enstrophy, Q, flowType,
streamFunction, Lambda2, uprime, Mach, vorticity.
Inside each utility directory you will find a *.C file with the same name
as the directory. This is the main file, where you will find the top-level
source code and a short description of the utility.
For instance, in the directory Q, you will find the file Q.C, which is the
source code of the utility Q. In the source code you will find the
following description:
Calculates and writes the second invariant of the velocity
gradient tensor.

Take your time and dig into each directory to get a complete
description of each utility.
It is also possible to export data to be visualized with other post-
processing tools:
foamDataToFluent: converts OpenFOAM data to Fluent format.
foamToEnsight: converts OpenFOAM data to EnSight format.
foamToGMV: converts OpenFOAM data to GMV.
foamToVTK: converts OpenFOAM data to VTK format.
foamToTecplot360: converts OpenFOAM data to tecplot format
In the User Guide you will find the complete listing
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

The sample utility
OpenFOAM provides the sample utility to sample field data for
plotting on graphs.
The sampling locations are specified for a case through a
sampleDict dictionary located in the case system directory.
Data can be written in a range of formats including well-known
graphing packages such as: grace/xmgr, gnuplot and jPlot.
The sampling can be executed by running the utility sample in the
case folder and according to the application syntax.
A final word, this utility does not do the sampling while the solver is
running. It does the sampling after you finish the simulation.
For more information about the sample utility, refer to the user guide.
The sample utility
We will do now some post-processing using the sample utility. From now on
follow me.
Go to the postprocessing/turb_backstep directory. In the terminal
type:
cd $ptofc/postprocessing/turb_backstep/c1
blockmesh
setDiscreteFields
(If you do not have this tool, copy the files located in the directory 0init to the directory 0)
simpleFoam
sample -latestTime
At this point take a look at the case folder. You will notice that the sample
utility creates a new folder named postProcessing, which contains the
folder sets where you will find n time directories (one for each time step
sampled).
Mesh
The sample utility
Velocity magnitude contours
The sample utility
Pressure contours
The sample utility
Turbulence kinetic energy (k) contours Turbulence dissipation rate (epsilon) contours
Velocity magnitude profiles
The sample utility
0 1 2 3 4 5 6 7 8 9 10
0 0.02
[x/H]
[U/Uc]
Exp
CFD
0 1 2 3 4 5 6 7 8 9 10
-0.5 0 0.5
[x/H]
[U/Uc]
Exp
CFD
Turbulence kinetic energy (k) profiles
The sample utility
You will find in the case directory a small shell script named script. From the
terminal type:
./script
This script will generate two output files in .eps format using the gnuplot
scripts located in the case folder (profilek.gp and profileU.gp). Take a
look at these files, this is a part of the post-processing tutorials.

To visualize the .eps files, from the terminal type:
evince profilek.eps
evince profileU.eps
or whatever application you use to view .eps files

Let us now study the sampleDict dictionary. Go to the case system
directory and open the file sampleDict.
Let us now study the sampleDict dictionary. The probesDict
dictionary contains at least the following entries:

// Set output format
setFormat raw;
// Surface output format.
surfaceFormat foamFile;
// interpolationScheme.
interpolationScheme cellPointFace;
// Fields to sample.
fields
( U k );
// Set sampling definition:
sets
(
x=0H
{
type midPoint;
axis z;
start (0 0.5 1);
end (0 0.5 4);
}
//...
//More lines here//
//...
);
// Surface sampling definition:
surfaces
(
);
The sample utility
The sample utility
The sampleDict file

The sampleDict file contains several entries to be set according to the
user needs. There you can set,
The choice for the interpolationScheme.
The format of line data output.
The format of surface data output.
The fields to be sample.
The sub-dictionaries that controls each sampling operation. In these
sub-dictionaries you set the name, type and geometrical information of
the sampling operation.
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

Probes
OpenFOAM provides the probeLocations utility to sample field data in
some discrete points.
Probes can be created by using the probesDict dictionary, which must be
contained in the system folder.
During the job execution, inside the case directory a new folder named
postProcessing/probes, will be created. In this folder, the probed
values are stored.
The probed values are saved in a ascii file, with the name of the probed
field.
The probing can be executed by running the utility probeLocations in the
case folder and according to the application syntax.
A final word, this utility does not probe while the solver is running. It does the
probing after you finish the simulation.

Probes
We will now run a simulation using some probes. From now on follow me.
Go to the postprocessing/pitzDaily directory. In the terminal type:
cd $ptofc/postprocessing/pitzDaily/c1
blockMesh
pisoFoam
probeLocations
yPlusLES
Let us explore the case folder. You will see that we have a new folder
named postProceing/probes, which contains the 0 time folder, this is
the folder from which we started to sample the probes.
Velocity magnitude
Probes
Mean velocity magnitude Mean pressure
Probes
Y-plus
Probes
Probes
Pressure probes time history
Probes
Let us now study the probesDict dictionary. Go to the case system
directory and open the file probesDict. The probesDict dictionary
contains at least the following entries:
// Fields to be probed. runTime modifiable!
fields
(
p
);

// Locations to be probed. runTime modifiable!
// You can add as many as you like
probeLocations
(
( 0.0254 0.0253 0 )
( 0.0508 0.0253 0 )
( 0.0762 0.0253 0 )
( 0.1016 0.0253 0 )
( 0.127 0.0253 0 )
( 0.1524 0.0253 0 )
( 0.1778 0.0253 0 )
);
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

functionObjects
It is possible to perform some data extraction/manipulation operations
while the simulation is running by using the
functionObject

feature.

functionObject
are small pieces of code executed at a regular
interval without explicitly being linked to the application.
When using
functionObject
, files of sampled data can be written
for graph plotting and post processing.

functionObject
are specified in the
controlDict
dictionary and
executed every timestep (or regular intervals).
All
functionObject
are runtime modifiable.

functionObjects
Below is a list of some of the available functionObject that can be
called at run-time:

fieldAverage - temporal averaging of fields.
fieldMinMax - writes min/max values of fields.
fieldValue - averaging/integration across sets of faces/cells, e.g. for flux across a plane.
readFields - loads fields to the database for post-processing.
surfaceInterpolateFields - generates surfaceFields from volFields for further postprocessing.
forces - calculates pressure/viscous forces and moments.
forceCoeffs - calculates lift, drag and moment coefficients.
sampledSet - data sampling along lines, e.g. for graph plotting.
probes - data probing at point locations.
isoSurface - generation of an isosurface of given fields in one of the standard sample formats.
cuttingPlane - generation of a cuttingPlane with field data in one of the sample formats.
sampledPatch - generation of a surface of a patch with field data in one of the sample formats.
systemCall - execute any system call, e.g. email you to tell you your job is finished.
abortCalculation - aborts the calculation if a given file is present in the case directory.
partialWrite - allows registered objects, e.g. fields, to be written at different times (frequencies).
nearWallFields - generates a volField with boundary values from interpolated internal field.
streamLine - generates streamlines in one of the sample formats.
timeActivatedFileUpdate - modifies case settings at specified times in a simulation.
writeRegisteredObject - writes registered objects, e.g. fields that are not scheduled to be
written in the application, i.e. created with NO_WRITE.
In the User Guide you will find the complete listing
functionObjects
And by the way, these three functionObject are really powerful:

systemCall
timeActivatedFileUpdate
writeRegisteredObject
Try to figure out when they can be used.
functionObjects
We will now run a simulation using functionObject. From now on follow
me.
Go to the postprocessing/2d_cylinder directory. In the terminal
type:
cd $ptofc/postprocessing/2d_cylinder/c1
blockMesh
icoFoam > log &
tail -f log
Let us explore the case directory. You will see that we now have a new
directory named postProcessing. Inside this directory, you will find many
subdirectories pointing to the functionObject used.
In this case you will find the following directories: forceCoeffs_object,
forces_object, minmaxdomain, probes1, probes2 and
surfaceSampling, sampleset, patchMassFlows_massFlow, each
one containing the 0 time directory, this is the time directory from which we
started to sample using functionObject.
Mesh
functionObjects
Velocity magnitude
functionObjects
Vorticity
Mean velocity magnitude
functionObjects
Mean pressure
Lift coefficient time history
functionObjects
Drag coefficient time history
To plot in gnuplot:
plot [][-1:1] forceCoeffs.dat u 1:3 w l
To plot in gnuplot:
plot [][1:2] forceCoeffs.dat u 1:3 w l
Pressure and velocity probes time history
functionObjects
Min. and max. values
functionObjects
Some awk scripting
First at all, let us go to the postProcessing/minmaxdomain/0 directory. Now
type in the terminal:
cat fieldMinMax.dat | tr -d "()" > out.txt
awk '0 == NR % 2' out.txt > pre_minmax.txt
awk '1 == NR % 2' out.txt > vel_minmax.txt
rm out.txt
awk '{if (NR!=1) {print}}' vel_minmax.txt > temp
mv temp vel_minmax.txt
functionObjects
Some awk scripting
First at all, let us go to the postProcessing/forceCoeffs_object/0 directory.
Now type in the terminal:
awk NR>=500 && NR { total += $3; count++} END { print
Mean_drag total/count} forceCoeffs.dat
(This is one line)

awk NR>=500 && NR { total += $4; count++} END { print
Mean_lift total/count} forceCoeffs.dat
(This is one line)

functionObjects
Some awk scripting
awk NR>=500 && NR { total += $3; totalsq += $3$3; count++} END
{ print Std_dev drag sqrt(totalsq/count (total/count)^2)}
forceCoeffs.dat
(This is one line)

awk NR>=500 && NR { total += $4; totalsq += $4$4; count++} END
{ print Std_dev drag sqrt(totalsq/count (total/count)^2)}
forceCoeffs.dat
(This is one line)

functionObjects
Some awk scripting
sh awk_script
The script awk_script will compute the mean value and standard deviation of the
lift and drag coefficients. It will save the computed values in the ascii files
lift_coe.txt and drag_coe.txt.

Feel free to adapt this script to your needs. I just showed how to compute the
average and standard deviation, but you can do many things in an automatic way.

The power of scripting!!!
functionObjects
functionObjects
gnuplot

plot [][-1:2] 'vel_minmax.txt' u 1:3 w l title "min_ux

or you can try to plot everything

plot [][-1:2] 'vel_minmax.txt' u 1:3 w l title "min_ux",'vel_minmax.txt' u 1:4 w l
title "min_uy",'vel_minmax.txt' u 1:5 w l title "min_uz",'vel_minmax.txt' u 1:9 w l
title "max_ux",'vel_minmax.txt' u 1:10 w l title "max_uy",'vel_minmax.txt' u 1:11
every 100 w p pt 7 ps 0.5 lc 8 title "max_uz
(This is one line)
Plotting in gnuplot
First at all, let us go to the postProcessing/minmaxdomain/0 directory. Now
type in the terminal:

functionObjects
gnuplot

plot [][1:2] forceCoeffs.dat' u 1:3 title Drag coefficient
with lines
(This is one line)

plot [][-1:1] forceCoeffs.dat' u 1:4 title Lift coefficient
with lines
(This is one line)

Plotting in gnuplot

functionObjects
We will now run a simulation using functionObject. From now on follow
me.

Let us now study the controlDict dictionary. Go to the case system
directory and open the file controlDict.
At the end of the controlDict dictionary, you will find a new sub-
dictionary entry, here all the functionObject are defined.

The functionObject entry in the controlDict dictionary, contains at
least the following information:
function_object_name

{

type function_object_to_use;

functionObjectLibs ("function_object_library.so");

enabled true;
outputControl outputTime;

timeStart 100;
timeEnd 200;

//...
//functionObject //
//keywords and sub-dictionaries //
//...

}
functionObjects

!"#$%&#'()*$+ +& "-*
./0* &! !"#$%&#'()*$+
12(3/34 +& "-*
5*46&37- /#7 -"(8
72$%&#/32*- -9*$2:$ +&
+;* !"#$%&#'()*$+
functionObjects

additional_fields
{
type writeRegisteredObject;

functionObjectLibs ("libIOFunctionObjects.so");

objectNames ("U_0")

enabled true;

timeStart 100;
timeEnd 200;

}
functionObjects

fieldAverage
{
type fieldAverage;
functionObjectLibs ("libfieldFunctionObjects.so");
enabled true;
cleanRestart false;
timeStart 20;
timeEnd 200;

fields
(
U
{
mean on;
prime2Mean on;
base time;
}
p
{
mean on;
prime2Mean on;
base time;
}
);
}
functionObjects


forces_object
{
type forces;
functionObjectLibs ("libforces.so");

outputControl timeStep;
outputInterval 1;

patches ("cylinder");

pName p;
Uname U;

rhoName rhoInf;
rhoInf 1.225;

CofR (0 0 0);
}
functionObjects

forceCoeffs_object
{
type forceCoeffs;
functionObjectLibs ("libforces.so");
patches ("cylinder");

pName p;
Uname U;
rhoName rhoInf;
rhoInf 1.0;

log true;

CofR (0.0 0 0);
liftDir (0 1 0);
dragDir (1 0 0);
pitchAxis (0 0 1);
magUInf 1.0;
lRef 1.0;
Aref 1.0;

outputInterval 1;
}
functionObjects


minmaxdomain
{
type fieldMinMax;


enabled true;

mode component;

outputInterval 1;

log true;

fields (p U);
}
functionObjects


probes1
{
type probes;
functionObjectLibs ("libsampling.so");

probeLocations
(
(2 1 0)
);
fields
(p U);

outputInterval 1;
}
functionObjects

probes2
{
type probes;

probeLocations
(
(5 0.5 0)
(5 0 0)
(5 -0.5 0)
(10 0.5 0)
(10 0 0)
(10 -0.5 0)
);
fields
(p U);

outputInterval 1;
}
functionObjects


surfaceSampling
{
type surfaces;
enabled true;
interpolationScheme cellPoint;
surfaceFormat raw;

fields
(
p
);

surfaces
(
nearWall
{
type patch;
patches ( "cylinder" );
interpolate true;
triangulate false;
}
);
}
functionObjects


sampleset
{
type sets;
enabled true;
outputInterval 1;
setFormat raw;
surfaceFormat vtk;
interpolationScheme cellPoint;
fields
( p U );
sets
(
lineX1
{
type midPoint;
axis y;
start (5 -4 0);
end (5 4 0);
}
//...
//More lines here//
//...
);
}
functionObjects

inMassFlow
{
type faceSource;

enabled true;

outputInterval 1;

log true;

valueOutput false;

source patch;
sourceName in;

operation sum;
fields
( phi );
}
functionObjects

outMassFlow
{
type faceSource;

enabled true;

outputInterval 1;

log true;

valueOutput true;
surfaceFormat raw;

source patch;
sourceName out;

operation sum;
fields
( phi );
}
functionObjects

massFlow
{
type patchMassFlow;
functionObjectLibs ("libsimpleFunctionObjects.so");

verbose true;
patches
(in out);

factor 1

outputControlMode timeStep;
outputInterval 1;
}
To use this functionObject you will need to install swak4foam.
functionObjects

In the previous example we only used a few of the functionObject
available in OpenFOAM, namely:
writeRegisteredObject
fieldAverage
forces
forceCoeffs
fieldMinMax
probes
surfaces
sets
faseSource
patchMassFlow

For more information about functionObjects, refer to the user guide.
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session

foamLog
During execution, OpenFOAM writes values of residuals, number of
iterations, and so on, on the standard output (terminal).
It is possible to extract this information with the foamLog utility, provided the
standard output has been written to a file (logfile).
solver_name > logfile
foamLog logfile
By default, the files are presented in two-column format of time and the
extracted values. You can plot each file by using gnuplot or your favorite
plotting tool. Depending of your case setup, the following files might be
present:
courant_0, contCumulative_0, contGlobal_0, contLocal_0
foamLog.awk, executionTime_0, Separator_0, Time_0
p_0 , pFinalRes_0, pIters_0
Ux_0, UxFinalRes_0, UxIters_0
Uy_0, UyFinalRes_0 , UyIters_0

foamLog
All the information extracted from the log file is saved in the directory logs
To plot this info we can use gnuplot, grace, xmgr, octave and/or jPlot.
(just to name a few).
Let us analyze the log of the case postprocessing/2d_cylinder. In
the terminal type:
foamLog log
cd logs
gnuplot
plot CourantMean_0 w l
plot p_0 w l, pFinalRes_0 w l

If you do not have the log file from the previous tutorial, you can use the log
file icofoam_run, which is located in the case directory.
foamLog
This is a screenshot on my computer. This is a plot of the pressure initial and
final residual using gnuplot. You can plot any of the output files generated
by foamLog.
foamLog
It is also possible to plot this information on-the-fly. To do this you will need
to install PyFoam and use the following utility:
pyFoamPlotRunner.py [options] <foamApplication>

Let us run again the case postprocessing/2d_cylinder but this time
using pyFoamPlotRunner.py. In the terminal type:
cd $ptofc/postprocessing/2d_cylinder
pyFoamPlotRunner.py icoFoam
If you need help or want to know all the options available, type in the
terminal,
pyFoamPlotRunner.py --help
foamLog
This is a screenshot on my computer. In this case, pyFoamPlotRunner is
showing the initial residuals and continuity errors on the fly
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session
More post-processing utilities
In OpenFOAM, you can output on the fly streamlines, cutting planes, iso-
surfaces, wall bounded stream lines, forces and force coefficients written
into data bins.
So take your time and explore these directories. You can also take a look at
the tutorial contained in the directory
$ptofc/postprocessing/motorBike

In the directory $FOAM_UTILITIES/postProcessing, $FOAM_SRC/
postProcessing, $FOAM_SRC/sampling, you will find the directories
containing the source code for many post-processing utilities available in
OpenFOAM.

Mesh generation using open source tools
Additional tutorials
In the directory $ptofc/postprocessing you will find many tutorials, try to go
through each one to understand and get functional using the post processing tools.

Thank you for your attention
Todays lecture
5. Probes
6. functionObjects
7. foamLog
9. Hands-on session
Hands-on session
In the courses directory ($ptofc) you will find many tutorials (which are different from
those that come with the OpenFOAM installation), let us try to go through each one to
understand and get functional using OpenFOAM.
If you have a case of your own, let me know and I will try to do my best to help you to
setup your case. But remember, the physics is yours.

Open Form Post Processing

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Open Form Post Processing

Enviado por

Direitos autorais:

Formatos disponíveis

Disclaimer

This offering is not approved or

Você também pode gostar