With IPython 3.0 the names of the Widget classes lost the Widget
in
the name (for instance DropdownWidget
becomes Dropdown
). PyFoam
has been changed to conform with this but as a consequence won't work
with old version of the IPython
notebooks
If no setup-script is specified and if there is a setFieldsDict
present then setFields
is automatically executed
The configuration system now has a section Autoplots
. The entries
there are all dictionaries with two entries:
solvers
: a list of regular expressions. If the name of the currently used
solver matches any of these expressions then this entry is used
plotinfo
: a dictionary with the plot information known from regular
customRegexp
: expr
, titles
etc
If the solver matches solvers
then a custom plot based on plotinfo
is automatically added.
If the solver does not fit the plot is not added (this helps avoid
processing of unused expr
. This is important because processing the
expr
is one of the things PyFoam
uses the most computation time for)
Some common plots (phase fractions for instance or most of the output of
chtMultiRegionFoam
) are hardcoded into PyFoam
Also there is a new section [SolverBase]
in the configuration. It is
checked whether the current solver name begins with any of the keys
there. If it does then the list of solvers is assumed to be the solvers
this solver was based on and Autoplots
for those solvers are added as
well. For instance
[SolverBase]
myReactingCht: ["chtMultiRegionFoam","reactingFoam"]
assumes that a solver myReactingChtFoam
is based on these two solvers
and automatically adds their Autoplots
In addition if a setting like
[Plotting]
autoplots: cloudNumberMass
is set (for instance through LocalConfigPyFoam
in the case) then the
autoplot cloudnumbermass
is used regardless of the solver name
This allows specifying plots generated with type dynamic
on the
alternate axis
These utilities now allow with the option --gnuplot-terminal
to choose
the terminal. Otherwise the terminal specified in the configuration
(usually x11
) is used
Names in the legend are now sorted. This improves readability for large numbers of lines in the plot
The option --run-with-debugger
runs the command in the debugger. The
arguments are appropriately handled
If the execution of a script fails (the status code returned by the
script is not --continue-on-script-failure
.
It is up to the script to ensure that the failure of a utility called in
the script is forwarded to pyFoamPrepareCase.py
. For instance with
set -e
in a bash
-script
This option allows setting the options for the terminal selected with
--format-of-hardcopy
. This overrides any default set in configuration
section [Plotting]
under the name hardcopyOptions_<term>
with
<term>
being the name of the terminal (for instance for png
the
option is hardcopyOptions_png
.
It writes to the usual state file. This way pyFoamListCases.py
will
list this information. If the scripts call pyFoamRunner.py
then this
information will be overwritten
Since that foam version all binaries (and object files are located in
the directory platforms
. The utility now finds them there
With the option --use-blink1
these utilities now flash on a plugged in
blink(1)
USB-device for every time-step
To indicate that the utility is still running it is able to play a
pattern on a blink(1)
-device. This is switched on with -use-blink
With the option --template-dict
it is possible to initialize the
output with an existing file. With this file it is possible to add
'complicated' settings.
Probe files now have one comment line per probe to specify the position. This format is now correctly detected and plotted. Old probe files are also handled
The .rst
-file written by the utility now adds a section on derived
parameters if such parameters were specified in a script
It is now possible to specify directories that should be ignored when
looking for templates. Some sensible defaults like postProcessing
,
processor*
and VTK
are already set
The option --add-formula-to-sheet
allows adding formulas to the
Excel-sheet. Something like
--add-formula="massflow:::'inlet'-'outlet'"
adds a column massflow
that subtracts the columns inlet
and outlet
For those who use mercurial to keep track of their cases the utility now
has the option -hg-info
that displays the mercurial hash-ID, the local
id and the branch name
Using the library lqdm
progress bars have been added to utilities that
have a long run-time and where the progress bars are not disturbing the
regular output. These utilities are
pyFoamListCases.py
pyFoamBinarySize.py
Bars can be switched off with --no-progress-bar
pyFoamCleasCase.py
and all utilities that have a --clear
option now
also have a --verbose-clear
option that reports what is being
cleared
The utility now has two new options:
: Replaces the first line (for instance if the header does not match the data
A development installation is now also detected and it is assumed that
this uses the new calling convention. Also: PyFoam reports this as
version 9.9.9
(as this is larger than any version in the foreseeable
future
An additional fork type openfoamplus
has been added (in addition to
openfoam
and extend
). Installations of the form OpenFOAM-vX.X+
(with X.X
being the version number) are added to this fork. Also
OpenFOAM-plus
is added as the development version of this fork
In newer OpenFOAM-versions blockMeshDict
may be located in system
.
PyFoam detects it either there or in the old
constant/polyMesh
-location
Lists and dictionaries now can also be specified. Have to be correctly formatted if they are longer than one line (indented by at least one space - convention for configuration files)
If an option opt
is requested with this option then it is checked
whether an architecture-dependent setting exists. Architecture arch
is
the output of the uname
-command. The architecture-dependent name is
opt_arch
.
This function now has an option that makes it return the status of the execution as well as the output of the execution.
In the past this class (and the utilities based on it) looked for a file
stop
and stopped the run (with writing) if it was found. Now two
additional files are looked for
stopWrite : this waits for the next scheduled write and then stops the run kill : gracefully stops the run without any writing
This class assumes that a blink(1)
USB-device is present and the
API-server (from the Blink1Control
-program for this is running. It
wraps these calls so that utilities can use them conveniently
#includeEtc
is now supported
Uniform fields of the form 1002{42.5}
(Field with 1002 values
These two classes have a method toNumpy
added that transformed the
data into a structured NumPy
-array. There are no applications for this
in PyFoam
yet but an application will be the parsing of lagrangian
data
This module reads data written by the cloud function-object that writes
particle data as particles hit the patches and transforms it into
numpy
-array. Which can also be returned as pandas
DataFrames
It adds some properties to the data
- the patch name
- the time at which this data was written
- a
globalId
constructed fromorigId
andorigProcId
This gets
- a case
- a cloud name
- a time name and reads the lagrangian data from the specified time
and converts it to a pandas
DataFrame
A globalId
that is consistent with the one in LagrangianPatchData
is
set
This method formats a string assuming that it is a program code. Default
value is python
Newer OpenFOAM-versions allow dimensions in symbolic format (for example
[ m s^-1 ]
). These are now correctly parsed
Fields of the form 23 { 4.2 }
(meaning "23 times 4.2") are now
correctly parsed
As expydoc
is discontinued the API-documentation is now generated with
sphinx
. Just run
make docu
to do so.
Advantage is that now with
make docset
a document set for offline searching with Dash
(for Mac OS X) or
clones (on other OSes) can be generated
Untitests only used to run correctly if the OpenFOAM-version was 1.7. Are changed to run with OF 3.0. No effort has been made to support intermediate versions as the changes are mainly about changed tutorials
If the ExecutionTime
is not as expected pyFoamPlotWatcher.py
and
pyFoamPlotRunner.py
finish with an error. This is now more robust
For dynamic plots the addition of the phase name did not work. Fixed
If phase
was set the output of the function objects got it added to
the names even though the function objects do not belong to the phase.
This is fixed
When working with regions one region too many was added in
pyFoamChangeBoundaryType.py
and pyFoamChangeBoundaryName.py
. Fixed
If a case is write protected then the utility failed. Now it only issues a warning and continues cleaning
When copying one file to another and one of them is zipped then copying doesn't replace the destination correctly but adds the zipped/unzipped variant
If snapshots were taken from state files with multiple layouts then some of the views had the wrong time (either that from the state-file or from the timestep before). Fixed
The data from the first timestep was not plotted under certain circumstances. This has been fixed
Starting with this OS-version as a security feature the system does not
pass LD_LIBRARY_PATH
and DYLD_LIBRARY_PATH
to a shell. PyFoam
detects this and creates these variables and makes sure they are passed
to the processes
The reason is that the old way of making axis data unique did not work anymore. This has been fixed
This problem has been reported at
https://sourceforge.net/p/openfoam-extend/ticketspyfoam/220/ (the
number 1E-2
is not correctly parsed to 0.01
) and has been fixed
In cases where the parallel data has a different start directory than
pyFoamRunner.py
and similar utilities cleared that data and
made a restart impossible. This has been fixed
As the distutils
(and all mechanisms built on these like pip
)
replace the used python in scripts the necessary pvpython
was removed.
This has been fixed by generating a temporary script file that is
actually executed with =pvpython)
Add the library tqdm
(https://github.com/tqdm/tqdm) for adding
progress bars to utilities.
Library is under MIT
License
PyFoam is now found at https://pypi.python.org/pypi/PyFoam
Recommended way of installing is using https://pip.pypa.io/en/latest/ :
pip install PyFoam
This will also make sure that the required numpy
-package is installed
As this was never really used it is discouraged (the option is still there).
If you don't understand what this means it probably doesn't concern you
All pickled files are now written and read in binary mode (as this was the only way that works consistently in Python 3). This may cause problems with old cases (but no effort has been made to check whether this problem actually exists)
These two utilities now don't strip leading spaces from the read lines. This preserves formatting in the output but might break scripts that rely on these spaces.
The old behaviour may be reset by overriding stripSpaces
in section
SolverOutput
with a value True
The enhanced naming of the columns might break scripts that rely on the old naming
In previous versions these boundary files were not modified. Now they
are. Scripts that rely on unchanged boundary
-files in the
processorX
-directories might fail. Old behavior can be set with the
--no-processor
-option
Lines with $$
are passed to the file and make it syntactically
incorrect. Fixed
This caused problems in Python 3 were binary strings were not correctly written (actually: attempts to write them to a pickle-file made the application fail)
In a number of classes/applications semantic differences between Python 2 and 3 makes these fail on Python 3. Changes are
- Replace
map
with list comprehension where possible - Modify wrappings in
CTestRun
to work with Python3 - Replace
print
withprint_
- Semantic difference in division of two integers: Python3 gives a floating point number as a result
If an included dictionary has a header parsing failed. This is fixed by retrying the parsing with the header
If there is for instance a ;
after an #include
statement the regular
OpenFOAM-parser ignores it. The PyFoam-parser failed. This has been
fixed and the parser behaves like regular OpenFOAM
Due to changes in the API the program did not work. This is now fixed and the program works with VTK 6 as well as VTK 5
In that case an overeager split
created lists.
Fix provided by Martin Beaudoin
Change in the syntax of imports in Python 3 broke this one. Fixed. But doesn't matter as Mercurial doesn't support Python3
Wrong usage of indexes. Fixed
Reason was a different calling convention to the exec
-function of
Python. Fixed
This was due to actions being on the same level as the debug-output. Fixed
For certain solvers the plot utilities issued a warning during a phase when no information about the current time is available. This is now fixed
not used when iterating over dictionaries When iterating over dictionaries with redirects the values in the redirected dictionaries were not used. This is now fixed
Due to a difference in the behavior of the eval
-function in Python 3
certain expressions (especially with list comprehension) failed. Fixed
These characters were stripped out by SQLite. They are thus normalized to special character combinations (which will be denormalized after reading)
The algorithm to find (Open)FOAM-installations in alternate locations was broken. Now working again
Due to a a change in the socket API if the socket for the network thread (usually port 18000) was already notified the program failed. Fixed. Tested on 2.7 as well
If there are multiple regions and no prepareMesh.sh
then it will try
to execute blockMesh
for the regions
With the option --extension-addition
additional templates that
override the regular templates can be specified.
Application may be for instance special templates for potentialFoam
If the meshing stage generates a 0
-directory then data in that
directory will be kept. This can be switched off if this is not the
desired behaviour
If a file default.parameters
is found in this directory then this file
is automatically read. This file is read like a regular parameter-file
but it can also have added information about the values:
-
if an entry is a dictionary and has the entries
description
andvalues
then it is assumed that this is a group of values. These groups are only used for grouping in reports. Thevalues
are set in the global scope.Groups can be nested
-
if an entry is a dictionary and has the entries
description
anddefault
then it is assumed that the dictionary holds meta-information about the value. The entrydefault
is the value that is actually used. -
an additional enty
options
in that dictionary specifies a list of valid values for that parameter. The utility fails if the set value is not in that list. This is useful for setting boundary condition types or similar entries where only a limited number of words is valid
It is recommended that all used values are specified in this file as this will be used for reporting
The utility now writes a Restructured Text file with a report about
the variables. Information from default.parameters
like groupings and
description
are used in this report. Also the default value and the
actual value are reported.
The file can be converted with a utility like rst2pdf
For all utilities that use Gnuplot as the backend for plotting there is
now a configuration option gnuplotCommands
in the Plotting
-section
with the usual set
commands of Gnuplot. This is preset to display a
grid and the y-axis.
The settings can be reset with the gnuplotCommands
-list in the
customRegexp
-entries
The API for screenshots changed with Paraview 4.2 and later. This API
now supports layouts if multiple views were specified. The default
behaviour is now to make only one screenshot per layout. The old
behaviour (one screenshot per view) can now be switched on with the
-no-layouts
-option.
This allows screenshots exactly the way they look on screen
The utility now rewrites the state file so that either decomposed or reconstructed data is read. The default is that the data set for which more timesteps exist is selected
It is now possible to specify a dictionary with source names and the fields that should be set for them. This allows quickly coloring the same layout with different fields.
This works for
- 3D (rendered) filters
- bar charts
There are now two ways to rescale the color-transfer functions
-
by specifying a dictionary with the ranges
-
by specifying a source. The range of the data on that source will be used to scale the data
- when specifying a source percentiles can be specified for the highest and lowest percent of the cells to be ignored
The first method will override the second
An option allows specifying that these parameters should be read. They are then available for substitution in the Text source
The utility now has options to select the cases that should be considered by name of the case. Either substrings or globs can be used. Ignore patterns can be specified as well
The format of the parameter-file has been extended so that instead of values variations can be dictionaries. The contents of the dictionary are then used instead of a single value. An example would look like this
defaults {
a 1;
b 2;
c 3;
}
values {
solver (
interFoam
);
inVel ( 1 2 );
outP ( 0 1 );
sets (
{ name foo; a 3; }
{ name bar; b 4; c 5; }
);
}
where sets has two variations. Values unset in sets
will be used from
defaults
Now all functionality of the Join
-utility is present in the Convert
utility (including interpolating times)
pyFoamJoinCSV.py
will be removed in future versions of PyFoam
If idNr
is a list then now the actual id is composed from all the
match groups specified in that list. If idNr
is an integer then it
behaves like it used to.
Application for the new behavior would be for instance to have the flow of different species on different patches in one plot
This combines the properties of the types dynamic
and slave
:
dynamically generated data sets that are added to another plot
Uses the library line_profiler
for profiling. Only of interest for
developers. Experimental
The section Template
in the configuration now allows modifying the
behavior of the templating engine (how templates are processed and
syntax details)
This allows overruling options before they are set be command line options. This has to be enabled by the application (it doesn't make sense for all).
An example is the pyFoamPrepareCase.py
-utility where the local
configuration file can overrule the default behavior of the template
engine
Now if that option is selected and the extension of the output is xls
the option -write-excel-file
doesn't have to be set anymore
The input data files now can be added to an excel-file as separate
sheets with the --add-sheets
-option
Now if there is more than one source file then the columns from the first source also get a unique prefix.
It is also possible to clean the column names before writing them to
file. The time name can be changed with -write-time-name
. Substrings
can be replaced with --column-name-replace
and simple functions can be
applied with --column-name-transformation
The utility now can read these files and determine the field names from
the filename. --automatic
assumes that files with the extension .xy
are of this format
If a script derivedParameters.py
is present then it is executed and
values set in that script can be used in the templates as well
If unspecified by the user this variable is automatically
The PrepareCaseJob
-class in ClusterJob
automatically sets the values
according to the number of processors in the cluster job
Both utilities now also modify the boundary files in the
processorX
-direcories. This behaviour can be switched off from the
command line
Templates with the extension .finalTemplate
are executed after the
caseSetup.sh
-script.
The option --cloned-case-postfix
adds a postfix to the cloned
directory names. This can be used if the results from multiple
variations with the same parameter file should be kept (for instance
when comparing OpenFOAM-versions)
The option --default-read-format
now allows setting a different format
than csv
as the default format for input files
The utility tries to determine from the pickled data the host the simulation was run on and prints it (can be switched off with an option)
The utility now has an option --clone-case
to clone a new case before
starting instead of working in the specified directory (in this case the
case will be cloned to this directory). The name of the created
directory can be constructed from the specified parameters with the
--automatic-casename
-option
Valid regions are sub-directories of constant
that have a
polyMesh
-directory
Comparison used to fail for types where it was not explicitly
implemented like None
Now --interactive-after-exception
also works in the utilities that use
pvpython
In the mode where executions are allowed now more flexible assignments to variables are possible. To be specific:
- array assignments like
$$ a["t"] = 2
- multiple assignments like
$$ a,b = 2,3
This library has been upgraded to the latest released version
There are additional methods emphasis
, strong
and literal
that
wrap their arguments in the appropriate markup
The methods bulletList
, enumerateList
and definitionList
take
lists or dictionaries and mark them as lists
If the option isSampleFile
is set then it is assumed that the field
names are in the filename and there is no header with field names in the
file
By Oliver Borm. The building of Debian packages for Python libraries has changes. Necessary adaptions were done by Oliver Borm
The nose
-library had problems and all the unit-tests run
out-of-the-box with pytest
The only requirement is a python-installation. The main testing and development has been done with 2.7 and 2.6. Python 2.5 should work but not for all utilities. Currently 2.6, 2.7 and 3.4 are used during development.
Certain functionalities need special Python-libraries. The main one is
numpy
for plotting. Other libraries that might be of interest are
matplotlib
, pandas
and IPython
. For pyFoamDisplayBlockmesh.py
the libraries PyQt4
and vtk
are needed. Other libraries are tested
for and reported by pyFoamVersion.py
but not required (only install if
you're sure that you need it)
These two utilities are almost indistinguishable and will be unified into one
If in customRegexp
an expr
is found with \n
then this expression
is matched over multiple consecutive lines. Types like dynamic
work as
usual.
This makes it possible to match for instance the output of the
forces
-function objects
The utility which was introduced in the last version is becomong more
usable and will be central to all things that set up the case (for
instance a special ClusterJob
)
These utilities are now more flexible and allow writing and reading of Excel-files too
Both variables are not necessary but PYFOAM_SITE_DIR
allows consistent
insertion of site-specific libraries and utilities.
PYFOAM_DIR
is set by some Foam-distributions and tested for by
pyFoamVersion.py
. It is supposed to point to the currents
PyFoam-installation.
PYFOAM_SITE_DIR
points to a directory with site-specific scripts and
configurations. The sub-directories supported (and thested py
pyFoamVersion.py
) are
bin
: directory with scripts. It has to be added to the PATH
outside of
PyFoam (for instance in the .bashrc
)
etc
: Optional directory which is searched for configuration files.
Priority is below the user settings and above the global settings
lib
: Optional directory to allow mixing in site-specific library files.
Imported as PyFoam.Site
: For instance if a file Foo.py
is
present in lib
it can be imported as PyFoam.Site.Foo
. This
directory does not have to be (in fact: it shouldn't) added to
PYTHONPATH
Purpose of PYFOAM_SITE_DIR
is to allow administrators to provide
site-wide scripts and settings for all users on a site
Option has been renamed to --no-complain
SQLite does not support case-sensitive column-names (s_max
and S_max
are the same). To change this the upper case letters in the column names
are replaced by an underscore and the letter (S_max
becomes _s__max
)
This means that old databases might not be read correctly
The algorithm to make variable names unique has changed (basically it uses the part of the filenames that differ) and scripts relying on these names might fail
The name of the module crashed in certain instances (especially
unit-testing) with the regular IPython
-library. To avoid these crashes
it has been renamed to IPythonHelpers
. This raises two potential
problems:
- scripts that
import
the module have to be adapted to the new name - IPython-notebooks created with
pyFoamIPythonNotebook.py
have two imports pointing to this module. These notebooks have to be adapted to be usable again
This was a problem for script-templates which were not executable any more. Fixed
This has been fixed by adding an import in BasicRunner.py
This is now fixed
Some calls for sort
still used the cmp
-parameter which does not
exist for Python3 anymore. These calls have been replaced with key
and
reverse
Because the output of subprocess
is now binary instead of a regular
string. Fixed
This was due to incorrect use of the interpolate
-method
This was because there was a problem in the library code and the utility did not consider the parallel time-steps. Fixed
Basic run information was not added to the file. Now it is with the
prefix runInfo//
The logic for checking whether a file was "backupable" was wrong. This
affected the proper restore of files with utilities for instance for
--write-all
According to the bug
http://sourceforge.net/p/openfoam-extend/ticketspyfoam/219/ it was not
possible to import DataStructures
because of a circular dependency
with FoamFileGenerator
. Fixed by moving an import to the back of the
file
This utility takes a template case and a file specifying the parameter
variation and creates cases with the pyFoamPrepareCase.py
-engine, runs
a solver on these cases and collects the data into a database. The
database can then be extracted with pyFoamDumpRunDatabaseToCSV.py
Calculates the size of the binaries in an OpenFOAM-installation separated by compile-option
Assists the user in rewriting the blockMeshDict
by doing simple, but
error-prone transformations. Assumes "sensible" formatting: one
block/vertex etc per line.
Sub-commands are:
refine
: refines mesh by multiplying cell numbers in the blocks
number
: Adds comments with the vertex numbers. Should help the user when
editing/modifying the mesh
stripNumber
: Remove the comments added by number
mergeVertices
: Adds vertices from other blockMeshes that are not present in the
current blockMesh
renumberVertices
: Take another blockMeshDict
, copy over the vertices
-section of
that mesh and rewrite blocks
and patches
so that they conform to
these vertices
. The original vertices
have to be a sub-set of
the vertices
in the other mesh
normalizePatches
: Rotates patches so that the lowest number is in front
The option --additional-values
allows specifying a dictionary with
additional values for the boundary (stuff that is needed by mappedWall
etc)
This allows to write case-templates that can distinguish between different OF-versions
Before doing anything else the contents of different directories are copied into the current case. This allows for instance to use tutorial cases as the basis for a case
Additional code added to the generated notebook:
- Code to change the default size of the plots
- Distribution-directories in subdirectories
distributions
(generated by someswak
-function objects) added
If the controlDict
is acceptable to OpenFOAM but syntactically
incorrect for PyFoam (for instance because of a missing semicolon) the
utility does not fail anymore (but no data is collected for that case).
This should make it easier to find items
Both utilities now allow writing Excel-files
In addition to regular text files the first sheet from xls
-files can
be read
Now it is possible to filter for regular expressions
The functionality of the two utilities now is very similar and it is possible that one of them will be discontinued
The two utilities now can add columns or recalculate columns based on the existing column values
Testing for the library Numeric
library removed as it is no longer
supported as a fallback for numpy
. Test also removed from setup.py
The class PrepareCaseJob
supports cases that are set up with
pyFoamPrepareCase.py
. Additional parameters to the constructor are
- the name of the parameter-file
- a list with the parameters. The list is composed of name/value-pairs
The class VariationCaseJob
supports cases that are set up with
pyFoamRunParameterVariation.py
. Additional parameters to the
constructor are
- the name of the parameter-file
- the name of the variations-file
The function checks if the file exists and is not executable. The program fails in that case
This ensures that it is printed in a form that is valid in OF-dictionaries
This has until now only been used in ListCases
but moved to a separate
method/function diskUsage
in the Utilities
-module
Added the possibility to have an epilog and usage examples with the
epilog
and examples
-keyword arguments for applications.
These and descriptions now have the possibility for line-breaks: if two line-breaks are encountered in the text a new paragraph is created
For Python-version where shutil
has a which
-function this is used
instead of calling an external program
This currently only works for reading, Backups, zipping etc won't work but it makes algorithms more flexible
Instead content is stored in memory. Old behaviour is the default to preserve compatibility with old scripts
numberVertices : Adds comments with the vertex numbers to the vertices
Previous behaviour was stripping all spaces from the lines. Now the left hand spaces can be ket. Old behaviour is still default for compatibility
This allows faster debugging of template-files. This can be enabled with a switch in the utilities using templates
And additional parameter solverArgs
will now be passed to the solver
(if the solver accepts arguments)
During construction if an Excel-file is specified and the xlrd
-library
and pandas
are installed then the first sheet in the file is read
Columns can be recalculated using expressions. This includes other data
items. Currently present column names are available as variables. There
is also a variable data
that can be subscripted for items that are not
valid variable names. A variable this
points to the item to be
recalculated
This manifests with pyFoamRunParameterVariation.py
. The custom
timelines are still kept in memory. Not a problem. Just annoying
The only requirement is a python-installation. The main testing and development has been done with 2.7 and 2.6. Python 2.5 should work but not for all utilities. Unit tests run on Python 3.4 but it is currently not used in a production environment (reports of success or failure most welcome)
Certain functionalities need special Python-libraries. The main one is
numpy
for plotting. Other libraries that might be of interest are
matplotlib
, pandas
and IPython
. For pyFoamDisplayBlockmesh.py
the libraries PyQt4
and vtk
are needed. Other libraries are tested
for and reported by pyFoamVersion.py
but not required (only install if
you're sure that you need it)
Now pyFoam
supports different versions of OpenFOAM for switching. Out
of the box openfoam
and extend
are supported. If only the version
number is specified (for instance by --foamVersion=1.7.x
) and such a
version exists only for one fork it is correctly expanded with the
correct fork( in the example with openfoam-1.7.x
). If more than one
fork has the same version then the fork name has to be specified as well
Note: additional forks can be easily specified with the configurations.
In section OpenFOAM
the parameter forks
has to be extended. For each
new fork a dirpatterns
and installation
-parameter has to be
specified
The selection of what is to be done is now selected by subcommands instead of options. This will break scripts using this
The reason is that the utilities assume that this directory is produced
from 0.org
The reason was that it used the same throttling that made sense for the PlotRunner. Fixed
Reason is that the class vtkPythonStdStreamCaptureHelper
does not
support isatty
Reported in https://sourceforge.net/apps/mantisbt/openfoam-extend/view.php?id=208 and fixed
Vector fields only were added to the data fields if they were the first in the list. Fixed
This is now fixed. The alternate values have to be specified in the master (specifying in the slave gives an error)
Usually these files are ascii
(even if the header says binary
). In
some cases the parsing failed for these. Fixed by enforcing reading as
ascii
. Can be switched off
The reason was that if there were duplicate times in the table the index was non-unique which certain Pandas-operations don't appreciate. Solved by dropping duplicate times. Can be switched off
If things are specified twice they were added twice. Now it is checked whether the item already exists in the tar-file before adding them
The reason was that this was interpreted as a vector and the numeric prefix was removed. Reported at http://sourceforge.net/apps/mantisbt/openfoam-extend/view.php?id=218
Fixed by introducing an extra parameter to FoamFileGenerator
This utility aims to reduce the need for boilerplate scripts to set up cases. The steps it executes are
- Clear old data from the case (including processor directories)
- if a folder
0.org
is present remove the0
folder too - go through all folders and for every found file with the extension
.template
do template expansion using the pyratemp-engine - create a mesh (either by using a script or if a
blockMeshDict
is present by running blockMesh. If none of these is present assume that there is a valid mesh present) - copy every
foo.org
that is found to tofoo
(recursively if directory) - do template replacement for every
.postTemplate
- execute another preparation script
This utility creates and manipulates IPython-notebooks for analyzing OpenFOAM cases. It has a number of subcommands:
create : this is the main command. All other commands assume that the notebooks they work with were created with this.
The utility looks at the case specified and creates a notebook that
has the capabilities to quickly build a report about the case:
- reporting general properties of the case. This
basically is the capability of the pyFoamCaseReport.py
-utility
- It searches for data that can be visualized by
pyFoamTimelinePlot.py
orpyFoamSamplePlot.py
and generates selectors that allow the user to select which data to import. The selectors import the data as Pandas-=DataFrames= and create the commands necessary to do this. It is recommended to erase the selector afterwards - Selectors for pickled case data and pickled plot generated by PyFoam
- Capability to store read data in the notebook file. This feature is experimental and has performance issues for medium to large datasets
The created notebook can be executed but needs to be edited to be useful
clear
: removes selected cells (but only cells created with create
) or
output from the notebook.
info
: prints information about the notebook
copy
: copies notebook to a different case and rewrites it so that data is
read from that case
Recommended way of working with this utility is
- Create notebook with utility
- Edit it to contain standardized evaluations
- Copy it over to another, similar case
The purpose of this submodule is to support pyFoamIPythonNotebook.py
.
It has the classes
Notebook : read a file and interpret it as an IPython-notebook. Do manipulations on this notebook PermanentStorage : Implements permanent storage in an IPython-notebook. Only works inside a notebook and allows only one instance at once. Passing the data from the notebook (through JavaScript) to Python currently is a performance bottleneck Case : Convenience object that exposes the functionality of some of the PyFoam-utilities through a simple interface
Wraps popular Python-libraries to add functions that make it easier to work with OpenFOAM-data.
Currently only one Wrapper is implemented:
This provides PyFoamDataFrame
as a wrapper for DataFrame
. The
functionality added is
addData
: Conveniently add new data from different Series
, DataFrames
. It
is assumed that the index is the same property (time or for samples
the distance) but with a different resolution. The indexes are
joined and missing data is interpolated
integrate,
: uses the index as the Series
. validLength
is the extent on which data is defined
(weightedAverage
is basically integrate
divided by
validLength
). For integrate
the trapezoid-rule is used
describe
: adds the three above quantities to the regular describe
-command
The option -index-instead-of-filename
switches this on. This makes it
easier to generate movies from the files
The option --custom-data
now allows the specification of custom data
items. These are read from the pickledData
-files and displayed in the
table like regular data items
Now all utilities allow switching the compiler version (for instance
from Gcc47
to Gcc48
). The relevant options are
--force-system-compiler
, --force-openfoam-compiler
and
--force-compiler
Now the location of the installations is reported as well
This is a workaround where the writer produces a segmentation fault
In addition to writing out bitmaps allows writing out 3D-data (for importing into other applications). Sources can be selected by name
The utility can now also:
- erase selected patches
- merge selected patches into one
This now automatically happens for OF-versions that support it (2.0 and greater). They can be switched on again
Files that are assumed to be used by pyFoamPrepareCase.py
are
automatically added to the clone. This includes all files (and
directories) with the extensions .sh
, .template
and .org
. Also
IPython notebooks (extension .ipynb
are added)
This should help with diagnosing problems with MPI etc.
Can be switched on in some utilities with --echo-command-prefix
Using the machine-file now can be switched off for job-schedulers with a tight integration
If a item in the case itself is a symlink then it used to be a copy of
the file the symlink is pointing to. Now it is created as a symlink to
the target the original symlink. If the --follow-symlink
-option is
used the old behaviour is used (copying). In this case the option
noForceSymlink
in the Cloning
-section of the configuration can be
used to change this behaviour for selected files
The directory is cleared if it exits from a previous run.
Used to fail if incompatible data types were used. Now ignores them
The subclass SubclassFoamOptionParser
now allows the parsing of
subclasses. The base class for utilities PyFoamApplication
now
supports this as an option. As an example this is implemented in
pyFoamSTLUtilities.py
The class checks whether arguments are filehandles and in this case doesn't try to open a file for reading or writing but uses the handle
If no file matching the name is found it is assumed that this is a
glob-pattern and all matching files are added. This affects all
utilities that use that method (especially pyFoamCloneCase.py
)
This method now allows the specification of a working directory. Before executing the command the method changes to the working directory. Afterwards it changes back to the regular working directory.
There is also an option echo
that immediately prints the output to the
screen
rmtree
now also works if the "tree" is a file.
copytree
now has a parameter force
that allows removing the
destination directory if it exists
Strings that are usually interpreted as boolean in OF-dictionaries (for
instance on
, yes
, ...) are now stored as a special type that allows
treating them like 'real' booleans.
For instance an expression test no;
in a dictionary now allows things
like if d['test']:
in the script
Until now the options to be used had to be specified as a list of string
modeled on the way the command line looked like. This is still possible.
In addition it is now possible to specify these things as keyword
parameters on the command line. Rudimentary type checking is done. The
names of the parameters are generated from the command line options: the
-
are removed and the words are converted to CamelCase. So for
instance --list-custom-Regexp
becomes listCustomRegexp
. Also for
switches like these a boolean value has to be passed. So the correct
usage in a call would be .
A number of properties has been added that list data generated by function objects:
timelines
: timeline data (like propes
) that can be visualized by
pyFoamTimelinePlot.py
samples
: data from set
(assuming it is in raw
-format) that can be
processed by pyFoamSamplePlot.py
surfaces
: data from surface
(assumes VTK
-format) that can be used by
pyFoamSurfacePlot.py
distributions
: special cases of sample
with distribution data
These properties only list the subdirectories of the case with that data
Additional properties are
pickledData : a list of pickled data files that are found pickledPlots : list of found pickled plots
These lists are sorted in descending temporal order (newest first)
Tries to determine the names of the values from the first line in the files
This also allows enforcing string values
If strings are unquoted but contain characters that make it illegal as a word then the string is quoted before output
This mainly concerns ParsedParameterFile
Starting with this version the pandas
-library is used for
data-analysis. When possible and appropriate classes return
pandas
-objects. Currently these are:
CSVCollection
. With a call-operator this class returns the collected data as aDataFrame
of the collected dataSpreadsheetData
now has methods to returnSeries
andDataFrame
objects
It is not necessary to install pandas
if these classes are not used
(and even then most of their functionality works)
The class RunDatabase
(and therefor also the utility
pyFoamDumpRunDatabaseToCSV.py
) now write as a separator for data from
sub-tables a //
instead of the space. This especially means that
scripts that rely on a data-item foo
in analyzed
might break because
this is now called analyzed//foo
instead of analyzed foo
. On the
other hand this makes the names more consistent and easier to parse as
//
is the saperator for other levels of dictionaries
Instead of col0
this is now coord
. This could cause problems with
scripts that use that column name in the resulting
SpreadsheetData
-object
Symbolic links were copied as is and did not work correctly afterwards. This is fixed. If the symbolic link is an absolute path or points outside the case directory it is replaced with the file it points to. Otherwise it is preserved as a symbolic link
These versions require an entry potentialFlow
in the fvSolution
-file
instead of the old SIMPLE
Fixed by first trying to read that with preprocessing. Without if that fails
Now using a set
instead of a list
makes sure that no file is cloned
twice
The utility now allows removing these entries in case that they don't
work with potentialFoam
Some of the options of pyFoamClearCase.py
for clearing cases (for
instance specifying additional files) have been ported to the
Runner
-utilities. Also is the postProcessing
-directory removed by
default
If there are field files and their zipped counterpart than instead of an error a warning can be given
A new method templateFile
gets the name of a file which is constructed
from a template of the same name plus the extension .template
The method additionalParameters
can return a dictionary with
additional parameters
In the written data in the sub-dictionary analyzed
there is now a
subdictionary Custom
with the values of the custom expressions with
the prefix CustomXX_
removed. This means that values that were
available as
data['Custom02_velCheck']['min']
are now available as
data['Custom']['velCheck']['min']
The advantage is that the number part which was dependent on the order the expressions were specified is now no longer necessary (this should make scripts more stable)
The old notation is still available but deprecated
The parameter solverLogCompress
compresses the log-file while writing
it to disc. Attention: This may lead to corrupted log-files if the
run crashes
The dictionary returned by getData()
now allows access to all the
elements as attributes.
The hook-module MailToAddress
sends a mail at the end of a run.
Prerequisite is an SMTP-Server that doesn't need authentication
This utility goes through cases and compresses single files. The cases can be searched recursively to.
Purpose of this utility is to shrink cases where writeCompression
was
not turned on during the run
A new module PyFoam.Paraview.Data
reads additional data usually
written by OpenFOAM. These are converted to vtkArray
using the
following functions and can be used in Programmable filters
:
setSampleData
: reads the data from sampled sets
setTimelineData
: reads data from a timeline directory
setPlotData
: reads pickled plot data using RedoPlot
When used with the option --implementation=xkcd
and version of
matplotlib
that supports it is installed then plots are done in the
style of the webcomics http://xkcd.com
If the disk usage of the cases is calculated then it is displayed in human readable form (as KB, MB, GB or TB) for sizes larger than one Kilobyte
Options to be more flexible in removing data are added:
keep
: keep timesteps at a specified interval. For instance
--keep-interval=0.1
will keep times like processor
-directories. Also
are things like keep-last
now honored for processor directories
remove
: Remove the directories with the analyzed data too. Old behavior was
to remove them. Now they are kept by default
If an output file foo
is specified and no template then the utility
looks for a file foo.template
as a template.
If a file foo.defaults
is present then this file is read and used as
default parameter values. Other specifications override these defaults
Additional option --disable-run-data
With the -pandas-print
-option a DataFrame
is generated and printed
If the ipdb
-package (basically pdb
with IPython
-additions) is
installed then it is used. This gives additions like tab-completion
The option --interactive-after-execution
drops the user to an
interactive shell where the namespace can be inspected. If present
IPython
will be used, otherwise the regular shell is used
This is mainly to be used on the interactive shell to do further analysis or write this data out. The utilities are:
pyDumpRunDatabaseToCSV
: add an item dump
with the whole data as a DataFrame
pyFoamTimelinePlot
: add element series
with all the data as Series
and dataFrame
with the same data as a DataFrame
pyFoamSamplePlot
: Like pyFoamTimelinePlot.py
pyFoamRedoPlot
: Now can get series and the whole plot data as pandas-objects
The utilities pyDumpRunDatabaseToCSV.py
, pyFoamTimelinePlot.py
,
pyFoamSamplePlot.py
and pyFoamRedoPlot.py
now have options to write
Excel-files
If an item in customRegexp
has an item gnuplotCommands
then it is
assumed that this is a list of strings which are executed before the
first plotting. For instance
gnuplotCommands (
"set format y '%.2e'"
);
changes the number format on the y-axis
Instead of determining the names of the fields and lines form the filenames it is now also possible to specify them through options.
The option --is-distribution
is a shorthand that sets these options
for distribution files
The range of the x-axis of the plots can either be set by automatically
scaling to the domains of all the data sets with --scale-domain
or by
specifying them with --domain-minimum
or --domain-maximum
.
These domains are set for all plots
When activating an on-demand write the constrolDict
was not restored
because the output-line about the file being read was not recognized
(due to a change in the output in recent OF-versions). Now a number of
different formats is recognized
That plot-type needs a master
. Fixed to fail if none is defined
This did affect all utilities that use that option and also calls with
listOnly
to the library class
If multiple actions like --update
and --build
are specified they are
executed in a sensible order (update before build etc)
If the environment variable that determines the OpenFOAM-version is unset a warning is issued by the utilities
If single file is specified then the action to transform it has can be specified
Now knows how to transform "old" reaction files (where the
reactions
-entry was a list) to the new format (where it is a
dictionary). Only a limited number of reaction types is supported.
Now the old form of thermophysical data (lists) is transformed into the new dictionary-form
Now with the option --symlink-mode
instead of copying the directories
from the original new directories art created and populated with
symlinks to the files in the original. The depth until which no symlinks
to directories are created can be specified. This allows the clone to
share the configuration files with the original
The directory postProcessing
is now automatically removed (can be
switched off with --keep-postprocessing
). Also with the
--additional
-option patterns with additional files to remove can be
specified.
- Now reports the location of the
python
-executable - Reports locations of used libraries
The files Allrun
, Allclean
and 0.org
are automatically added
during cloning as these are often used by the standard-utilities
This makes sure that templates are handled consistently and also allows
different delimiters in the blockMeshDict.template
- Now the new relative scoping that was introduced in OF 2.2 is supported
Added a function find
that approxiamtes the find
-command
Some more patterns have been added that will be ignored in a VSC-controlled case. All of them concerning files that PyFoam creates during operation
This utility replaces a symlink with a copy of the file/directories it
points to. To be used after a pyFoamCloneCase.py
in --symlink-mode
Sources are adapted so that PyFoam
works with Python3 too. This breaks
support for Python 2.4 and earlier (possibly also Python 2.5)
Some of the Libraries in PyFoam.ThirdParty
had to be adapted to work
with Python3:
Gnuplot
: The original version 1.8 is quite old. It was adapted with the help
of the six
-library (see below) to work with Python2 and Python3
(inspired by
[https://github.com/oblalex/gnuplot.py-py3k/commits/master] which
is a pure port to Python3 without backwards compatibility)
six : Library that helps supporting Python 2 and Python 3 in the same source code. Currently version 1.2 from [https://bitbucket.org/gutworth/six] is used pyratemp : Templating library to support the new templating format. Version 0.2.0 from [http://www.simple-is-better.org/template/pyratemp.html] is used
Port to allow running PyFoam on Windows was done by Bruno Santos of blueCAPE (bruno.santos@bluecape.com.pt)
Patch was originally posted at http://sourceforge.net/apps/mantisbt/openfoam-extend/view.php?id=166
Note: many of PyFoam's features are not yet fully functional on Windows.
Sources are executed in pypy
but it seems there are problems with
numpy
and also with code like for l in open(f).readlines()
This brings virtually no changes. README
with copyright information
has been added
This should help to avoid side-effects
Due to a previous workaround timeouts when collecting information about new machines was not treated correctly
This allows the execution of a shell-script in the directory of the case
These modules are found in PyFoam.Infrastructure.RunHooks
. Two
concrete implementations:
PrintMessageHook
: to print a text to the terminal
SendToWebservice
: encode an URL and send it to a webservice (example for
pushover.net
added)
Hooks are automatically instantiated from the configuration data (examples are hardcoded))
The Runner-classes now have a parameter parameters
. This data (usually
it would be a dictionary) is added verbatim to the run info.
Most runner applications now have the possibility to add this info.
Purpose of this facility is to identify different runs in the database better.
Parameter values are now handed to the actual job. Also a dictionary with parameters can be handed to the constructor and will be used in the relevant callbacks
During the run whenever the PickledPlots
-file is written a file
pickledUnfinishedData
gets written. This has the current solver data
and is similar to pickledData
.
Also a file pickledStartData
gets written that has the data that is
available at the start of the run.
The runner collects
- at every warning the next 20 lines of the output until a total of 500 lines is reached (this avoids filling disk and memory if the solver produces too many warnings)
- All output from an error message until the end
And stores them in the application data
The class TempalteFile
now uses an enhanced templating engine. The old
implementation is in the class TemplateFileOldFormat
If used as classes (not as utilities) these classes print the class name instead of the calling utilities name
Error and warning messages don't decorate the output if it goes to files or other non-terminal streams
An exception is now raised by self.error()
. This makes it easier to
handle such errors if the application class is used. The exception is
passed up until there is a "real" application
When the format of a file is binary
lists with a length prefix are
being read as binary blobs.
For reading the blobs a simple heuristics is used: a multiple of the
length in bytes is read. If the next character is a )
and the
characters after that are a certain combination of characters (newlines
and ;
) then it is assumed that the blob has ended. This may fail on
certain occasions:
- if the combination of characters appears at these places
- if the objects inside the binary data are of different sizes
It would be hard to work around these restrictions without reprogramming the full functionality of OpenFOAM
New class in the RestructuredTextHelper
allows more flexible
generation of tables. Items are added with column
and row
and if
these don't exist in the first row/column the table is extended
appropriately
This is implemented for Gnuplot
and Matplotlib
. Default for the
label on the x-Axis is now "Time [s]"
The utility can now use the pyratemp-templating engine which allows templates with loops, conditions and other fancy stuff
Instead of using the x-values from the original data the y-values of the
reference data can be used for comparing (with the
--use-reference
-option)
Same for pyFoamTimelimePlot.py
If scales not equal to gnuplot
-output
With the --relative-average-error
-option
- More tolerant if no library was found
- Reports the location of the PyFoam-Library
- Checks whether utility version is consistent the library found
Hooks can be added at the start and the end of a run
Added -end
and -start
-option to select a range that should be
plotted.
Currently not working with the Matplotlib-implementation (only gnuplot)
If a file with values is specified then the utility assumes you're editing a template file and will evaluate it before displaying it
New switch that makes the parser treat files that are declared binary
in the header as if they were ascii
This makes it easier to catch faulty specifications (or empty timeline-files)
An option --wait
has been added that makes the utility wait before
displaying the next picture
Switch allows forcing it to read a binary File as an ASCII
Previously the option --interactive-debug
only started the debugger if
the error was no syntax error. This is still the default behavior,
but can be overruled
The option --catch-USR1-signal
now installs a signal-handler that
prints a traceback and finishes the run. If the interactive debugger is
enabled then it goes to the debugger-shell.
Option --keyboard-interrupt-trace
triggers the same behaviour for
keyboard interrupts with <Ctrl>-C
For the purpose of developing a switch --i-am-a-developer
has been
added.
With the option xlabel
in the customRegexp
-file the label on the
x-axis of the plot can be changed. Setting ylabel
and y2label
(for
the secondary axis) was already possible
Now the options --min-time
and --max-time
are supported by
--metrics
and --compare
New addition by Marc Immer allows the graphical selection of blocks and
patches and adds them to the blockMeshDict
The file LocalConfigPyFoam
is read by these utilities and if there is
a parameter addItem
in the section Cloning
defined then these files
are cloned/packed automatically (no user specification required)
Additional option to print the estimated end times. These can be wrong
if the case did not start from the startTime
in the controlDict
.
Also now allows printing the end and the start-time according to the
controlDict
Plots of type phase
in customRegexp
don't actually plot anything.
The set a phase-name that is used for subsequent values (for instance to
distinguish the different residuals)
Options --region
and --time-directory
added that allow selecting
different boundary
-files
The class RunDatabase
stores the data from runs. Utility
pyFoamAddCaseDataToDatabase.py
is one way to populate the database.
pyFoamDumpRunDatabaseToCSV.py
allows dumping that data to a file for
further processing (in a spreadsheet for instance)
Database can also be populated using a special post-run hook
Pattern had to start with 1 (now every digit is possible))
No harm done. But fixed
Reason was that rmtree
does not allow wildcards. Fixed
The DictRedirect
would not convert to float. Fixed. Although it might
happen again for other data types
The option was only implemented for the list-form of the functions
entry in controlDict
Now fixed to also work with the dictionary-form
Seems like the length was interpreted as the name of the list. Fixed
Only worked if no region was specified (= not at all). Fixed
Plots were over the whole data range. This is now fix (also the issue
that --end
alone did not work)
Contents was "only" set as a dictionary which does not preserve the
order in which entries are added. Replaced with a DictProxy
Problem that was introduced by changes in the fields
-mode
For OpenFOAM-versions 1.6 and higher the automatic decomposition used is
now scotch
As regions have their own subdirectories the /
from the directory name
was inserted into the filename and if the subdirectory did not exist
gnuplot
did not create the picture
The base class didn't correctly handle the (
and )
. Fixed
The problem was that during splitting the timeline data an exception was raised. This exception was caught by another part of PyFoam. This left a lock on the data structure locked and the next access to the structure was held indefinitely. Fixed
As there is a tuple of residuals the scanner did not analyze the output
of the output of the block-coupled solver from 1.6-ext
correctly. This
is now treated as a special case and each residual is plotted separately
(distinguished by a [x]
with x
being the number of the component)
Macros $var
were not correctly expanded. Fixed
When being expanded to string form macros were not correctly expanded
If the utility was used in the form
pyFoamPackCase.py .
then an 'invisible' tar ..tgz
was produced. Fixed
Reported in [http://www.cfd-online.com/Forums/openfoam-solving/112278-pyfoam-struggles-adopted-solver-post403990.html] the string is assumed to be part of the iteration number. Fixed
At least for PV 3.14 and 3.98 the way the version number is determined has changed and the PV-utilities failed. This has been fixed but is untested with old versions
For the first rendered view Paraview automatically resets the camera. This has now been switched off (so the snapshot is rendered correctly)
- Problem with nested comments
- Parse code streams
- Preserving of comments can be switched off
- Ignore extra semicolons
- Allows parsing lists of length 3 and 9 as lists and not as vectors and tensors
- "lookup redirection" in OF-dictionaries now works
- pyFoamSamplePlot.py stops if the same directory is compared
- pyFoamSamplePlot.py shows the location of the biggest difference
- pyFoamSamplePlot.py allows only same ranges for comparisons
- Generation of pickled-files can be switched of for runner-utilities
- Frequency with which the pickled file is written is adapted (so that it doesn't use ALL the CPU-time)
- pyFoamVersion.py improved (Version of Python is checked etc)
- pyFoamRedoPlot.py: fixed parameter checking
- pyFoamPotentialRunner.py: temporarily disable libs and functions
- Only write last N loglines from Runner-utility
- pyFoamClearCase.py: allow local specification of additional files that should be cleared
- Runner utilities can report data about the run
- pyFoamConvertToCSV.py now allows selection of columns
- Utilities for quantative analysis now can return data
- Utilities for quantative now correctly return data for multiple places
- pyFoamSamplePlot.py now allows specification of valid variable pre and postfixes to allow correct parsing of variable names with a _
- endTime can be specified by the runner-utilities
- Utilities now allow piping (using pickled data)
- pyFoamSamplePlot.py now allows the specification of a reference time
- Nomenclature of pyFoamSamplePlot.py and pyFoamTimelinePlots.py now similar (both call it fields)
- pyFoamDecompose.py now can use the -region-option ifthe OF-version is right
- Forcing debug-mode fixed for older OF-versions
- pyFoamDecomposer.py now accepts globalFaceZones in Python or OpenFOAM-syntax
- Plot-utilities now don't interpret _ in names not as LaTeX
- pyFoamEchoPickledApplicationData to output pickled data
- pyFoamPrintData2DStatistics.py to output data from comparisons
- pyFoamBuildHelper.py to build project and its prerequisites (work in progress)
- pyFoamCreateModuleFile.py to create files for http://modules.sourceforge.net/ (by Martin Beaudoin)
- pyFoamSTLUtility.py to join STL-files
- stabler comparisons
- Paraview-Utilities work with 1.x and 2.x
- Runner classes return a dictionary with data
- TimelineDirectory ignores dot-files
- Application-objects can now be used like dictionaries to access data
- New class TableData for simple data tables
- New class Data2DStatistics for statistics about tables
- new class CTestRun as basis for automated testing
- FoamOptionParser now resets environment variables so that application-classes can call other application classes
- Improvements to HgInterface
- Additional VCS-subclasses for git, svn and svk (implementation only as needed)
- SolutionDir now uses 0.org as initial directory if no valid initial directory is present (this affects clearing and cloning)
- FoamFileGenerator now more flexible for long lists
- ParsedBlockMeshDict now doesn't introduce prefixes for 'long' lists
- pyFoamAPoMaFoX.py
- pyFoamPlotResiduals.py
- Got rid of Numeric-support in Gnuplot-library
- script to generate man-pages for the utilities
- Paraview3-example probeDisplay.py now renamed to probeAndSetDisplay.py and reads sampledSets from controlDict and sampleDict
- Older Versions The changes for older versions can be found on the Wiki-page