About this presentation

• Technical requirements:
  • A HTML5-supporting browser (Firefox recommended)
  • Videos currently only work in Firefox
• Keys that can be used

  Space

  Move through the presentation sequentially

  Cursor Keys

  Move non-sequentially

  ESC

  Slide overview

  F

  Full screen-Mode

What it's about and who's talking

Aim of this 'presentation'

• Demonstrate new features of the next release of swak4Foam
  • This is also the announcement of the release
• Doesn't give a full introduction to swak4Foam
  • But some pointers where to look

Where I work

• ICE Stroemungsforschung
  • Located in Leoben, Austria
  • CFD Consulting
    • Development with OpenFOAM
    • Also using ClosedSource

What is swak

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

  and has grown since

• The goal of swak4Foam is to make the use of C++ unnecessary
  • Even for complex boundary conditions etc

The core of swak4Foam

• At its heart swak4Foam is a collection of parsers (subroutines that read a string and interpret it) for expressions on OpenFOAM-types
  • fields
  • boundary fields
  • other (faceSet, cellZone etc)
• … and a bunch of utilities, function-objects and boundary conditions that are built on it
• swak4foam tries to reduce the need for throwaway C++ programs for case setup and postprocessing

Previous presentations

• No C++, please. We're users! Held at the 6th Workshop in Penn State, 2011

  Similar in scope to this presentation. But with a different feature-set

• Automatic testing of solvers using PyFoam: Held at the OpenFOAM-Workshop in Darmstadt (2012)

  Despite the title also uses swak4Foam for evaluations

• swak4Foam - A toolbox for flexible case setup and evaluation, OSCFD 2012, London

  Describes several advanced features of OpenFOAM using one case

• Gentle introduction and new developments: Held at the OpenFOAM-Workshop in Jeju (2013)

Why particles

Available parsers

Until now the parsers were available for

but not for …

The lost ones

Particles

Why not?

• Technical difficulties
  • If you want to I can bore you later over coffee with it
• But now it is there
  • Only downside: every particle class has to have an especially written adapter class
    • Because the clouds don't like to reveal information about themselves (so we've got to ask them politely)
  • Most "standard" clouds are covered

Simple example of usage

A swakExpression-function object with specifications like this

valueType cloud;
cloudName someCloudName;
expression "(mass0-mass)/mass0";
accumulations (min max);

will print biggest and smallest relative change in particle mass

• Provided the cloud has mass0 and mass
  • Most OpenFOAM-clouds have

But how do I know what is available

The first time a parser is used a list like this is printed to the terminal

Driver for cloud limestoneCloud1 of type Cloud<basicThermoParcel> (Proxy type: CloudProxy)
     List of functions:
                Name |            Type | Description
--------------------------------------------------------------
                  Pr |          scalar | Default carrier Prandtl number (constant)
                   T |          scalar | Temperature
                  T0 |          scalar | Initial temperature (constant)
                TMin |          scalar | Minimum temperature (constant)
                   U |          vector | Velocity
               UTurb |          vector | Turbulent velocity fluctuations
              active |            bool | Is this parcel active?
               areaP |          scalar | Particle projected area
               areaS |          scalar | Particle surface area
                cell |          scalar | number of the cell
                  cp |          scalar | Specific heat capacity
                 cp0 |          scalar | Specific heat capacity (constant)
         currentTime |          scalar | current time of the particle
                   d |          scalar | Diameter
            epsilon0 |          scalar | Particle emissivity (constant)
                  f0 |          scalar | Particle scattering factor (constant)
                face |          scalar | number of the face

Talking to the "other" phase

A swakExpression like this

valueType cloud;
cloudName someCloudName;
expression "T-fluidPhase(T)";
accumulations (min max);
interpolationSchemes {
    T  cell;
}

calculates the differences of the particle temperatures to the fluid temperatures interpoalted to the particle positions.

The case

What we look at

• The simplifiedSiwek-case for the coalChemistryFoam-solver that comes with OpenFOAM
• Modifications:
  • Lots of evaluations
  • We don't use the injection-mechanism but initialize the particles ourselves
    • More flexibility
    • but you have to set up everything (which can be painful)

Our new friend: funkySetLagrangianField

• In its simplest form it can be used like funkySetField:

funkySetLagrangianField -time 0: -expression "T-fluidPhase(T)" -field TDiff
        -create -cloud aCloud -defaultInterpolation cell

• which can be useful if you need additional properties for post-processing in ParaView
• For this funkySetLagrangianField
  • Reads all the fields of the cloud that are on disk into memory
  • Fluid fields on demand
• But it can also be used in dictionary-mode
  • like funkySetFields
    • … but it is also more flexible

Creating a cloud

• If createCloud is specified in funkySetLagrangianFieldDict then
  1. A chain of function-objects is executed
  2. In the end they should give out a list of positions for the particles in a swak global variable in a global namespace
  3. This variable is used to create a vanilla cloud on these positions
     • If additional fields are specified they will be added to the cloud
  4. The usual expressions-list will be executed to add even more fields to the cloud

BTW: you don't necessarily have to use the cloud for simulation. You can also use it as a fancy (but flexible) way to add Glyphs in ParaView

Distribution of parcels

The simplifiedSiewek running

• This animation shows
  • on the left: particle and fluid temperatures
  • on the right: fluid velocity and particle class

Movies are fine, but we want numbers …

Change of mass

This entry in controlDict

coalMassChange {
    type swakExpression;
    outputControlMode timeStep;
    verbose true;
    valueType cloud;
    cloudName coalCloud1;

    expression "max(mass0-mass,1e-15)";
    accumulations (
        min                  max
        weightedAverage      weightedMedian
        weightedQuantile0.05 weightedQuantile0.95
    );
}

Produces this data

No. This is really a plot, not a drawing

Excurse: Accumulations

Until now swak only provided the accumulations that were implemented by OpenFOAM

• min
• max
• average
• sum

But the inclusion of distributions in the last release made several more possible

The new accumulations

median

The value for which 50% of the distribution are smaller than this. More robust alternative to average

quantile

quantile0.25 for instance is the value for which 25% of the distribution are smaller than it

range

The difference of the quantile of $\frac{1+f}{2}$ and $\frac{1-f}{2}$. For instance range0.9 gives the range in which 90% of the values are (from the quantile 5% to 95%)

smaller

The fraction of the distribution that is smaller than a given value

bigger

The inverse of smaller

The weight

• A new function weight() has been added to the parsers
  • This has a slightly different meaning for all entities (cell volume for fields, face area for patches ….)
• For most accumulations exists an equivalent with the prefix weighted that takes the weight into account
  • For instance where one needed

expression "T*vol()/sum(vol())";
accumulations ( sum )

to get a proper average temperature one can now write

expression "T";
accumulations ( weightedAverage )

Differences of particle and gas temperature

Mass fractions of the species in the coal particles

The simple things …

• Sometimes we don't need to see the full field but stuff like
  • "What are the maximum and the minimum?"
  • "What is the volume of the geometry" (OK. =checkMesh can do that too)
  • "How much of the patch has $T<373.15$ ?"
  • "And could I please have files with that?"
  • "A distribution function would be nice"
  • "I don't waaaant to use ParaView today"

… fieldReport brings

Simply calling this utility like this

fieldReport T -time 0:

Generates output like this

Time = 0

 Reading Field T of type volScalarField

Internal field:
Size | Weight Sum                     2500 |            0.0275
Range (min-max)                      350.5 |             449.5
Average | weighted                     380 |       379.5454545
Sum | weighted                      950000 |           10.4375
Median | weighted              377.3777778 |             377.1

Additional features

• Not every output makes sense for every field (weighted sum of temperature?) but the interpretation is left to the user (as always)
  • Not every information that is easy to get is valuable
• Additional accumulations can be specified
  • See slide above
• Other "parts" can be specified:
  • Patches, zones and sets
• Data can be written to a CSV-file
• Distributions can be written to disk

Getting more information

fieldReport T -time 0: -doBoundary -fractionSmallerThan 350 -fractionBiggerThan 1000 -csvName TFieldValues.csv -nrOfQuantiles 10 -distributionsDirectory TFieldDist

Time = 0.75

 Reading Field T of type volScalarField

Writing distributions to "TFieldDist/0.75"

Patch field: top
Size | Weight Sum                        5 |             0.005
Range (min-max)                323.3613936 |       345.5260693
Average | weighted             333.9216142 |       333.9216142
Sum | weighted                 1669.608071 |       1.669608071
Median | weighted                   331.15 |            331.15
0.1 quantile | weighted             323.35 |            323.35
0.2 quantile | weighted              323.4 |             323.4
0.3 quantile | weighted                326 |               326
0.4 quantile | weighted              328.6 |             328.6
0.5 quantile | weighted             331.15 |            331.15
0.6 quantile | weighted              333.7 |             333.7
0.7 quantile | weighted             336.15 |            336.15
0.8 quantile | weighted              338.6 |             338.6
0.9 quantile | weighted              342.1 |             342.1
x <= 350 | weighted                      1 |                 1
x > 1000 | weighted                      0 |                 0

Reading in the CSV-file

Filtering the entity of interest

Plotting the data

Distribution of the Temperature

• This shows how the temperature evolves during time
• The initial distribution is due to the fact:
  • that the initial temperature depended on the height
  • the upper part of the geometry is thinner

In detail. In the beginning

In detail. After ignition

In detail. In the end

Do the big particles go down?

• In the beginning all the big lime particles are at the top
  • Obviously they will go down
  • But will they go "downer" than the small ones?
• Just looking at the Paraview pictures won't give us any clues … we'll have to do some numerical analysis

Using the snake

Enter Python

• The utility funkyPythonPostproc was written with this kind of application in mind
• It works like this:
  1. Starts a Python-interpreter and runs an initial script
  2. Executes a list of function objects that extract the "raw" data from the OpenFOAM-case and pass it to the script
     • As numpy-arrays
  3. A script does the analysis for this timestep
  4. If not finished read data for next timestep and go to 2
  5. Execute a final script
• The Python-scripts can use everything the Pythonverse has to offer

This is what our script does at every timestep

The real action happens in line 2

times.append(runTime)
r=stats.linregress(positions,diameter)
slopes.append(r[0])
offsets.append(r[1])

f=pyplot.figure()
pyplot.title("Diameters at t=%f" % runTime)
pyplot.xlabel('y-direction [m]')
pyplot.ylabel('diameter [m]')
data=pyplot.plot(positions,diameter,'b.',label="Data")
xLine=numpy.array([0.,1.])
line=pyplot.plot(xLine,r[1]+r[0]*xLine,'r',label="Fit")
a=line[0].get_axes()
text="d = %f * y + %f" % r[:2]
pyplot.text(0.1,0.1,text,transform=a.transAxes)
pyplot.legend()
pyplot.savefig("Diameter_%04d.png" % index)

Produces pictures like this (the initial condition)

And a slightly evolved state

And that's the way it moves

• This animation shows the evolution during time

Collecting the data

The end-script plots the coefficients of the regression as a function of time:

pyplot.figure()
pyplot.xlabel("Time [s]")
pyplot.subplot(2,1,1)
pyplot.title("Development of parameters over time")
pyplot.plot(times,offsets,"r")
pyplot.ylabel("Offset [m]")
pyplot.subplot(2,1,2)
pyplot.plot(times,slopes,"g")
pyplot.ylabel("Slope [m/m]")
pyplot.xlabel("Time [s]")

How we see our data

How other people see it

Tackling it in an alternative way

The function object with the long name

• There is a function object swakExpressionAverageDistribution that could be used for looking at this
• It calculates (using distributions) "Average of Quantity Y as a function of X"
• We use it for calculating the average diameter at different heights
• Doesn't improve our insight … I think

The function object

plotDistributions {
    type swakExpressionAverageDistribution;
    verbose true;
    outputControlMode timeStep;
    outputInterval 1;
    expression "d";
    weight "weight()";
    mask "true";
    abscissa "pos().y";
    valueType cloud;
    cloudName limestoneCloud1;
    binNumber 20;
    valueIfZero 0;
 }

Average diameters

The release

swak4Foam-release 0.3.0

• Will be available in the next couple of weeks
  • Parts that are presented here are already available in the public development repository
• The release will have the case files for the case presented here
• Version has been bumped up (and not just increased to 0.2.5) because the inclusion of particles closed a significant hole in the swak-toolbox

Other new stuff in the release

I keep forgetting and have to check the README myself

• mask-expression in swakExpression (and friends) to select values before accumulation
• function objects to calculate and recalculate the thermophysics. Mostly needed together with ..
• improvements of the PDE-function objects
• improvements to the Python-integration (IPython-inclusion etc)
• …

And finally

Goodbye

Questions?

This presentation

Was written with

reveal.js

a HTML5-framework for presentation

org-mode

Text outliner mode (and more) in

emacs

Text editor of kings

Bonus: Distribution of the Phases

• This animation shows the evolution of the phases in the coal particles during the simulation
  • gas, solid, liquid
• This is the cumulative distribution function
  • So it says "This percentage is smaller then T"