foamToPython 0.0.1

A py package to read and write OpenFOAM data

foamToPython is an ongoing repository to read and write the OpenFOAM field and numpy array. You can also perform Proper Orthogonal Decomposition (POD) to OpenFOAM fields with this package. It can handle both serial and parallel OpenFOAM case. The package is developed in Python 3.8+ and depends on numpy.

Features

It is about 10 times faster than two widely used packages, FluidFoam and foamlib, in reading fields. Moreover, it is capable to read and write parallel OpenFOAM case. The comparison of the performance is shown in the following figure.

The comparsion is performed for 4 conditions.

1. Scalar fields with 5 million cells.
2. Vector fields with 5 million cells.
3. Scalar fields with 36 million cells.
4. Vector fields with 36 million cells.

This test is performed on a cluster node with Intel Xeon Platinum 8358 CPU 64 cores @ 2.60GHz, 256GB RAM, and Red Hat Enterprise Linux.

foamToPython is ten times faster than FluidFoam and foamlib when reading parallel case with 36 million cells. Note that the aforementioned packages have more functions compared to the current library. PyFoam is not involved in the comparsion due to the problem of version compatibility.

Installation

You can install the package via pip:

pip install foamToPython

Or you can clone the repository and install it manually:

pip install git+https://github.com/Ruansh233/foamToPython.git

Usage and Examples

OFField class

The class could read OpenFOAM fields. It can process volScalarField or volVectorField, either uniform or non-uniform internalField.

read field, e.g., U

U = readOFData.OFField('case/1/U', 'vector', read_data=True)

The arguments are:

1. filename: the path of the field file.
2. data_type: the type of the field, e.g., "scalar", "vector", "label".
3. read_data: whether to read the field when initializing the class.
4. parallel: whether the case is run in parallel.

If read_data is False, the field will not be read when initializing the class. You can use U._readField() to read it later, or access U.internalField or U.boundaryField, which will trigger the reading of the field.

The package can read parallel case, e.g., U = readOFData.OFField('case/1/U', 'vector', parallel=True).

load internalField and boundaryField

U_cell = U.internalField U_boundary = U.boundaryField

1. U_cell is a numpy array, store the fields values. The length is 1 for the uniform internal field.
2. U_boundary is a dict store each patches. For each patch, it contain type for the type of boundary. If the type is fixedValue, the numpy array can be accessed by the key value. For example: U.boundaryField['velocityInlet']['value']

For parallel case, both internalField and boundaryField are read from all processors and stored as lists. For example, U.internalField[0] is the internalField from processor 0.

writeField

You can modify the data of U and then write it as OF field.

The arguments are:

1. path: the path to write the field. It can contain <timeDir> and <fieldName>, which will be replaced by the arguments timeDir and fieldName if provided.
2. timeDir: the time directory to write the field. Default is None.
3. fieldName: the name of the field to write. Default is None.

Same function can be used to write parallel case, e.g., U.writeField('case/<timeDir>/<fieldName>').

Therefore, you can use two types of inputs, e.g.,

1. U.writeField('case/<timeDir>/<fieldName>').
2. U.writeField('case/test', timeDir=<timeDir>, fieldName=<fieldName>). Note that timeDir and fieldName are needed when using Paraview to read the fields.

readList function

The function could read field value like velocity and pressure. The data type are: "lable", "scalar", "vector".

For example: U = readList("1/U", "vector").

readListList function

The function could read ListList, like the cellZones file. The data type are: "lable", "scalar", "vector".

For example: cellZones = readList("constant/polyMesh/cellZones", "label").

Perform POD to openfoam fields.

Please check the submodule PODopenFOAM and the class under it PODmodes, which can be called foamToPython.PODmodes. It can be created as,

pod = PODmodes(U, POD_algo=<POD_algo>, rank=<rank>).

The arguments are:

1. U: the OFField class instance, which contains the data to perform POD.
2. POD_algo: the algorithm to perform POD, can be "svd" or "eigen". Default is "eigen".
3. rank: the number of modes to compute. Default is 10, which means 10 modes are computed.

The modes can be exported with OpenFOAM format using pod.writeModes(outputDir, fieldName=<fieldName>).

The arguments are:

1. outputDir: the directory to write the modes. The modes will be written in folders outputDir/1, outputDir/2, ..., outputDir/rank.
2. fieldName: the name of the field to write. Default is None.

Parallel case

The package can read and write parallel case. However, the speed is slower than the serial case, and it will be improved in the future.