The new PLY-version and six now at least requires this Python-version. If your system has Python 2.5 or older stick with PyFoam 0.6.6
pyFoamPVSnapshot.py differDue to changes in the time-step numbering the names of the generated files differ. If your work-flow depends on the old names add the options --consecutive-index-for-timesteps and --duplicate-times
pyFoamListProfilingInfo.py to print profiling dataThe utility reads the profiling info written by
and prints it in a human-readable form
pyFoamBlockMeshConverter.py to convert a 2D-mesh to 3DThis utility (and the required Libraries) was written by Hasan Shetabivash (original at https://github.com/hasansh/blockMeshConverter.git)
This utility takes a file that is written in a similar syntax as the regular blockMeshDict but with the third dimension missing. It then converts this file to a regular blockMershDict by either extruding in the z-direction or by rotating around the x or the y-axis
Until now data items (groups) in the regular expression had to be valid numbers. Otherwise a warning was issued. This behavior is still the default but if a list-variable stringValues is added then the items (whose numbers are specified in the list) are not being plotted. They are written to disk with --write-files and they can be used in progress
PyFoamHistory escapedAdditions to the history file where arguments contain whitespaces and/or quotes are quoted and quotes inside are escaped. This allows these command lines to be copy/pasted to the command line
pyFoamPrepareCase.py now accepts OpenFOAM-formatThese strings are now parsed as OpenFOAM-strings if there is no starting { and no ending }. With these the old behavior (parsing as a Python-dictionary) is used
pyFoamPlotRunner.py allow automatic selection of solverIf for those utilities the word auto is written in place of a proper solver (like interFoam) then the utility looks into controlDict for the application-entry and uses that
customRegexpIf an entry dataTransformations is specified in the dictionary then the results of these transformations is are for writing/plotting instead of the real data.
dataTransformations is a list with valid single-line python-expressions. The groups from the regular expression expr are inserted textually into the expression before it is evaluated. $1 is the first group, $2 the second and so on (this convention is the same as for the progress-string.
The titles-entry corresponds to these results. If the "raw" (untransformed) data should be plotted as well you'll have to add identity-transformations of the form ="$1"=
idNr for dynamic in customRegexpidNr can now alternatively be a list of integers (instead of a single integer). In that case the corresponding matches are concatenated (with a _ between them) to generate the data id.
If only a number is specified it has the old behavior.
As usual the indexes of the matches stat with 1 (not 0)
If a run has not had any output in the last hour it is listed as dead. This threshold can be customized
pyFoamPVSnapshot.pyThe utility now numbers the time-steps by the order in the solution directory. Before that the used time-steps were numbered consecutively (from 0 to N − 1 if N time-steps were specified).
Also: by default each time-step is only processed once
The old behaviour can be reproduced with --consecutive-index-for-timesteps and --duplicate-times
Whether or not plots are plotted automatically (for instance the execution time) can be set in the [Plotting]-section of the configuration. So it can be set per-case in the LocalConfigPyFoam-file. If a plot is on by default it can be switched off with the corresponding --no-option. If off by default the --with-option switches it on
pyFoamPrepareCase.py allows error reportingIn that script that calculates new parameters and also can do parameter checking there now is a function error available that makes the script and the complete execution fail
Both distros changed their scheme for the version numbers and the regular expressions have been adapted to detect them
If one of the columns is string data then the ()-operator returns string values (when interpolating the next value)
The class can now read strings without spaces (OpenFOAM words) and pass them to SpreadsheetData
SpreadsheetData works without nameIf no name parameter is given then the method returns a dictionary with all the values
setCurrentTimeline in PyFoam.Paraview.Data to get data at timeThis function reads timeline data at a specified position. Return the interpolated values from the current simulation time as a table
Use in Programmable Filter. Set output type to vtkTable. To get the values from a timeline postProcessing/swakExpression_pseudoTime/0/pseudoTime use
from PyFoam.Paraview.Data import setCurrentTimeline
setCurrentTimeline(self.GetOutput(),"swakExpression_pseudoTime","pseudoTime")
To print the values pipe into a PythonAnnotation-filter. Set ArrayAssociation to Row Data and use an Expression like
"Time = %.1f (%.1f)" % (average,t_value)
(this assumes that there is a column average)
Hint: this reads string values as well. But in that case the value has to be converted with val.GetValue(0) in the expression
The method PyFoam.FoamInformation.getUserTempDir makes sure that a user specific temporary directory exists and returns the path to that directory
Instead of Gnuplo the window titles are now set to pyFoam and the actual title of the plots. This should make it easier to find plot windows in the window manager
#includeFuncIn case of a #includeFunc-entry the file is either searched relative to the current file (this is where the semantics differ from how OpenFOAM because that searches in the system-directory. But as this entry is usually called from system/controlDict the result is the same) and if not it looks for it in $FOAM_ETC
findFileInDirThis function in PyFoam.Basics.Utilities looks recursively for a file in a directory
PyFoam.Basics.UtilitiesThis function takes a duration (in seconds) and prints it in a human-readable form
ThirdParty-packagesNow these versions are reported as well for quick reference
The class PyFoamApplication assumes that the module sys has an element argv. This is not the case inside Paraview
pyFoamPrepareCaseParameters.sh not working on Mac OS XBecause newer versions of Mac OS X remove LD_LIBRARY_PATH from the environment passed to scripts (for security reasons) additional libraries (for instance swak4Foam) were not correctly loaded. This has been fixed by generating a special script that exports LD_LIBRARY_PATH before executing the rest
SolutionDirectoryThe class assumed that processorX directories were added in the numeric order which is not necessarily the case. This caused problems with pyFoamCaseReport.py
The utility function to delete directories failed if the directory didn't exist. Fixed
RegionCasesWhen creating a RegionCase only the "known" files were symlinked. This causes some programs to fail. Now everything from system in the master-case is symlinked if there is not already a file of that name there
solver in pyFoamListCase.pyIf another utility was run in the mean-time the wrong solver is listed by the utility. Fixed
tqdm to version 4.8.4No reason. Just because there was an update
PLY to version 3.9This breaks compatibility with Python 2.5 or older
six to 1.10.0This also breaks compatibiliy with Python 2.5 or older
IPython-notebooks 3.0With 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
setFields if appropriateIf 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:
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 0) then execution of the utility fails (before the utility just continued). This behavior can be overridden with the option --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
gnuplot-terminalsThis 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
blink(1)-devicesWith the option --use-blink1 these utilities now flash on a plugged in blink(1) USB-device for every time-step
blink(1)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
pyFoamPrepareCase.py now reports derived parametersThe .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.pypyFoamBinarySize.pyBars 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:
OpenFOAM-devA 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
OpenFOAM+ as a forkAn 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
blockMeshDictIn newer OpenFOAM-versions blockMeshDict may be located in system. PyFoam detects it either there or in the old constant/polyMesh-location
ConfigurationLists 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)
getArch for architecture dependent settingsIf 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.
PyFoam.Basics.Utilities returns status-codeThis 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
Blink1 class to support blink(1) devicesThis 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#includeEtc is now supported
Uniform fields of the form 1002{42.5} (Field with 1002 values 42.5) are now correctly parsed
Unparsed and FieldThese 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
PyFoam.RunDictionary.LagrangianPatchData to read data from patch function objectThis 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
globalId constructed from origId and origProcIdPyFoam.RunDictionary.LagrangianCloudData to read cloud dataThis gets
DataFrameA globalId that is consistent with the one in LagrangianPatchData is set
code added to =RestructuredTextHelperThis 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
epydoc to sphinxAs 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
ExecutionTime breaks plotting utilitiesIf 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
pyFoamPrepareCase.py confused by zipped filesWhen 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
pyFoamPVSnapshots.pyIf 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
pandas broke the writing of excel files with pyFoamConvertToCSV.pyThe reason is that the old way of making axis data unique did not work anymore. This has been fixed
E in exponential notation for floats breaks parserThis 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 0 the pyFoamRunner.py and similar utilities cleared that data and made a restart impossible. This has been fixed
pvpython not working when installed through distutilsAs 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)
tqdm for progress barsAdd 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
SolutionDirectory discouragedAs 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)
PlotRunner and PlotWatcher now don't strip spacesThese 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
pyFoamConvertToCSV.pyThe enhanced naming of the columns might break scripts that rely on the old naming
pyFoamChangeBoundaryType.py automatically modify processorXIn 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
TemplateFile passed to fileLines 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
map with list comprehension where possibleCTestRun to work with Python3print with print_#include edIf an included dictionary has a header parsing failed. This is fixed by retrying the parsing with the header
#includeIf 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
GeneralVCSInterfaceChange in the syntax of imports in Python 3 broke this one. Fixed. But doesn't matter as Mercurial doesn't support Python3
ParsedBlockMeshDict brokenWrong usage of indexes. Fixed
Reason was a different calling convention to the exec-function of Python. Fixed
pyFoamPrepareCase in --quiet was setThis 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
RunDatabaseThese 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 and values then it is assumed that this is a group of values. These groups are only used for grouping in reports. The values are set in the global scope.
description and default then it is assumed that the dictionary holds meta-information about the value. The entry default is the value that is actually used.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 validIt 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
There are now two ways to rescale the color-transfer functions
by specifying a source. The range of the data on that source will be used to scale the data
The first method will override the second
pyFoamPrepareCase.pyAn 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
pyFoamJoinCSV.pyNow 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
customRegexp now allows composition from multiple match-groupsIf 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
dynamicslave in customRegexpThis combines the properties of the types dynamic and slave: dynamically generated data sets that are added to another plot
--profile-line-profilerUses 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
--automatic-formatNow 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
numberOfProcessorsIf unspecified by the user this variable is automatically 1. It can be used by the templates to distinguish between different cases
The PrepareCaseJob-class in ClusterJob automatically sets the values according to the number of processors in the cluster job
pyFoamChangeBoundaryType.py now support decomposed casesBoth 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
boolComparison used to fail for types where it was not explicitly implemented like None
pvpython for debuggingNow --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:
$$ a["t"] = 2
$$ a,b = 2,3
six upgraded to 1.9.0This library has been upgraded to the latest released version
RestructuredTextHelperThere 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
sets-functionObjectIf 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
pytest for unittestingThe 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)
pyFoamJoinCSV.py and pyFoamConvertToCSV.py unifiedThese two utilities are almost indistinguishable and will be unified into one
customRegexpIf 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
pyFoamPrepare.pyThe 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
PYFOAM_SITE_DIR and PYFOAM_DIRBoth 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
PATH outside of PyFoam (for instance in the .bashrc)
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
--silent removed from pyFoamPrepareCase.pyOption has been renamed to --no-complain
RunDatabase with column-names that contain upper-case letters changeSQLite 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
pyFoamConvertToCSV.pyThe 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
PyFoam.IPythonHelpersThe 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:
import the module have to be adapted to the new namepyFoamIPythonNotebook.py have two imports pointing to this module. These notebooks have to be adapted to be usable againpyFoamPrepareCase.py did not keep permissionsThis 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
PyFoamDataFrame extrapolates for invalid valuesThis was due to incorrect use of the interpolate-method
pyFoamClearCase.py and parallel casesThis 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//
FileBasisBackup did not workThe logic for checking whether a file was "backupable" was wrong. This affected the proper restore of files with utilities for instance for --write-all
DataStructuresAccording 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:
number
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
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:
distributions (generated by some swak-function objects) addedcontrolDictIf 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
pyFoamConvertToCSV.py read and write Excel-filesBoth utilities now allow writing Excel-files
In addition to regular text files the first sheet from xls-files can be read
pyFoamJoinCSV.py and pyFoamConvertToCSV.pyNow 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
pyFoamJoinCSV.py and pyFoamConvertToCSV.py can be recalculatedThe two utilities now can add columns or recalculate columns based on the existing column values
Numeric removed from pyFoamVersion.pyTesting for the library Numeric library removed as it is no longer supported as a fallback for numpy. Test also removed from setup.py
ClusterJob that support PrepareCaseThe class PrepareCaseJob supports cases that are set up with pyFoamPrepareCase.py. Additional parameters to the constructor are
ClusterJob that support RunParameterVariationThe class VariationCaseJob supports cases that are set up with pyFoamRunParameterVariation.py. Additional parameters to the constructor are
PyFoam/Utilities fails if script is not executableThe function checks if the file exists and is not executable. The program fails in that case
tupleThis ensures that it is printed in a form that is valid in OF-dictionaries
UtilitiesThis has until now only been used in ListCases but moved to a separate method/function diskUsage in the Utilities-module
--helpAdded 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
Utitlities uses native Python-routineFor 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
BlockMesh-classPrevious 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
pyFoamSTLUtility.pyThe selection of what is to be done is now selected by subcommands instead of options. This will break scripts using this
0.org is present pyFoamCloneCase.py and pyFoamPackCase.py ignore 0The 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)
boundary-filesUsually 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
0.org is present remove the 0 folder too.template do template expansion using the pyratemp-engineblockMeshDict is present by running blockMesh. If none of these is present assume that there is a valid mesh present)foo.org that is found to to foo (recursively if directory).postTemplateThis utility creates and manipulates IPython-notebooks for analyzing OpenFOAM cases. It has a number of subcommands:
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:
basically is the capability of the pyFoamCaseReport.py-utility
pyFoamTimelinePlot.py or pyFoamSamplePlot.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 afterwardsThe created notebook can be executed but needs to be edited to be useful
create) or output from the notebook.
Recommended way of working with this utility is
PyFoam.IPythonThe purpose of this submodule is to support pyFoamIPythonNotebook.py. It has the classes
PyFoam.WrappersWraps 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
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
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-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
pyFoamPVSnapshot.pyThis is a workaround where the writer produces a segmentation fault
pyFoamPVSnapshot.pyIn addition to writing out bitmaps allows writing out 3D-data (for importing into other applications). Sources can be selected by name
pyFoamSTLUtilityThe utility can now also:
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
analyzed-directoryThe 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
SolutionDirectory accepts glob patternsIf 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)
Utilities allows specification of working directory and echoing of outputThis 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
copytree more tolerantrmtree 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 .
postProcessing-directoryA number of properties has been added that list data generated by function objects:
propes) that can be visualized by pyFoamTimelinePlot.py
set (assuming it is in raw-format) that can be processed by pyFoamSamplePlot.py
surface (assumes VTK-format) that can be used by pyFoamSurfacePlot.py
sample with distribution data
These properties only list the subdirectories of the case with that data
Additional properties are
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
dict-like update-methodThis 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
FileBasis now can be used with the with-statementThis mainly concerns ParsedParameterFile
pandas-libraryStarting 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 a DataFrame of the collected dataSpreadsheetData now has methods to return Series and DataFrame objectsIt 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
controlDict that use preprocessingFixed 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
functions and libsThe 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
TimeDirectory are more tolerantIf 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
ClusterJobThe 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
pyFoamCompressCases.pyThis 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:
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=0.1 will keep times like 1, 1.1 etc but remove 1.05
processor-directories. Also are things like keep-last now honored for processor directories
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
pandas-objectWith the -pandas-print-option a DataFrame is generated and printed
ipdbIf 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
pandas-data and/or numpyThis is mainly to be used on the interactive shell to do further analysis or write this data out. The utilities are:
dump with the whole data as a DataFrame
series with all the data as Series and dataFrame with the same data as a DataFrame
pyFoamTimelinePlot.py
The utilities pyDumpRunDatabaseToCSV.py, pyFoamTimelinePlot.py, pyFoamSamplePlot.py and pyFoamRedoPlot.py now have options to write Excel-files
GnuPlot in customRegexpIf 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
pyFoamSamplePlot.pyInstead 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
controlDict after writeWhen 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
slave not working if no master definedThat 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
postProcessing and allows removal of additional filesThe 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.
pyFoamVersion.pypython-executableThe files Allrun, Allclean and 0.org are automatically added during cloning as these are often used by the standard-utilities
pyFoamFromTemplate.pyThis makes sure that templates are handled consistently and also allows different delimiters in the blockMeshDict.template
ParsedParameterFileAdded 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
pyFoamSymlinkToFile.pyThis 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:
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)
WindowsPort 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.
pypySources are executed in pypy but it seems there are problems with numpy and also with code like for l in open(f).readlines()
ply to 3.4This brings virtually no changes. README with copyright information has been added
CTestRun after initializationThis should help to avoid side-effects
MetaServer rightDue to a previous workaround timeouts when collecting information about new machines was not treated correctly
execute-method to ClusterJobThis allows the execution of a shell-script in the directory of the case
These modules are found in PyFoam.Infrastructure.RunHooks. Two concrete implementations:
PrintMessageHookSendToWebservicepushover.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.
ClusterJob extendedParameter 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
PickledPlotsDuring 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
And stores them in the application data
pyratempThe 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:
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
xlabelThis 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
pyFoamSamplePlot.pyIf scales not equal to 1 and offsets not equal to 0 are specified they are used in the gnuplot-output
With the --relative-average-error-option
pyFoamVersion.pyHooks 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
pyFoamTimelinePlot.py raise error if no plots are generatedThis 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
USR1 and will give a tracebackThe 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
pyFoamTimelinePlot.py and pyFoamSamplePlot.py support time rangesNow 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
pyFoamPackCase.py accept additional parametersThe 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
pyFoamDecompose.py not workingReason 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
--function-object-data of pyFoamClearCase.py not working with directoriesThe 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
pyFoamRunner.py brokenOnly worked if no region was specified (= not at all). Fixed
--end and --startPlots 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
TimelinePlot in positions-modeProblem that was introduced by changes in the fields-mode
metis for decompositionFor OpenFOAM-versions 1.6 and higher the automatic decomposition used is now scotch
pyFoamTimelinePlot.py produced no pictures for regionsAs 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
pyFoamTimelinePlot.py not working if value is a vectorThe 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
pyFoamPVSnapshot.pyFor the first rendered view Paraview automatically resets the camera. This has now been switched off (so the snapshot is rendered correctly)