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
PATHoutside 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 fileFoo.pyis present inlibit can be imported asPyFoam.Site.Foo. This directory does not have to be (in fact: it shouldn’t) added toPYTHONPATH
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
importthe module have to be adapted to the new name - IPython-notebooks created with
pyFoamIPythonNotebook.pyhave 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 thevertices-section of that mesh and rewriteblocksandpatchesso that they conform to thesevertices. The originalverticeshave to be a sub-set of theverticesin 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.orgis present remove the0folder too - go through all folders and for every found file with the
extension
.templatedo template expansion using the pyratemp-engine - create a mesh (either by using a script or if a
blockMeshDictis present by running blockMesh. If none of these is present assume that there is a valid mesh present) - copy every
foo.orgthat 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.pyorpyFoamSamplePlot.pyand 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, validLength, weightedAverage
- uses the index as
the $x$-axis and calculates these properties for a
Series.validLengthis the extent on which data is defined (weightedAverageis basicallyintegratedivided byvalidLength). Forintegratethe 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
listCustomRegexp=True.
A number of properties has been added that list data generated by function objects:
- timelines
- timeline data (like
propes) that can be visualized bypyFoamTimelinePlot.py - samples
- data from
set(assuming it is inraw-format) that can be processed bypyFoamSamplePlot.py - surfaces
- data from
surface(assumesVTK-format) that can be used bypyFoamSurfacePlot.py - distributions
- special cases of
samplewith 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 aDataFrameof the collected dataSpreadsheetDatanow has methods to returnSeriesandDataFrameobjects
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-interval
- keep timesteps at a specified interval. For
instance
--keep-interval=0.1will keep times like $1$, $1.1$ etc but remove $1.05$ - keep-parallel
- this will not remove any times in the
processor-directories. Also are things likekeep-lastnow honored for processor directories - remove-analyzed
- 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.py
- add an item
dumpwith the whole data as aDataFrame - pyFoamTimelinePlot.py
- add element
serieswith all the data asSeriesanddataFramewith the same data as aDataFrame - pyFoamSamplePlot.py
- Like
pyFoamTimelinePlot.py - pyFoamRedoPlot.py
- 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.py
- 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 ([email protected])
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.netadded)
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
The changes for older versions can be found on the Wiki-page