foamToPython 0.0.1__py3-none-any.whl

foamToPython/readOFList.py

@@ -0,0 +1,205 @@
+import numpy as np
+import sys
+import re
+from typing import List, Tuple, Optional
+from .headerEnd import *
+
+
+def _num_list(subcontent: List[bytes]) -> Tuple[int, int]:
+    for idx, line in enumerate(subcontent):
+        try:
+            return int(line), idx
+        except ValueError:
+            continue
+
+
+def _check_data_type(data: bytes) -> str:
+    data = data.decode("utf-8").strip()
+    if re.match(r"^\(\s*-?\d+(\.\d+)?\s+-?\d+(\.\d+)?\s+-?\d+(\.\d+)?\s*\)$", data):
+        return "vector"
+    elif re.match(r"^-?\d+(\.\d+)?([eE][-+]?\d+)?$", data):
+        return "scalar"
+    elif re.match(r"^\d+$", data):
+        return "label"
+    else:
+        sys.exit("Unknown data_type. please use 'label', 'scalar' or 'vector'.")
+
+
+def _extractList(content: List[bytes], data_type: Optional[str]) -> np.ndarray:
+    num_data_, data_idx = _num_list(content)
+    data_start_idx = data_idx + 2
+    # Extract relevant lines containing coordinates
+    string_coords = content[data_start_idx : data_start_idx + num_data_]
+
+    if data_type is None:
+        data_type = _check_data_type(string_coords[0])
+
+    if data_type == "label":
+        # Join all lines and replace unwanted characters once
+        joined_coords = b" ".join(string_coords).replace(b"\n", b"")
+        # Convert to a numpy array in one go
+        data_array = np.fromstring(joined_coords, sep=" ", dtype=int)
+
+    elif data_type == "scalar":
+        # Join all lines and replace unwanted characters once
+        joined_coords = b" ".join(string_coords).replace(b"\n", b"")
+        # Convert to a numpy array in one go
+        data_array = np.fromstring(joined_coords, sep=" ", dtype=float)
+
+    elif data_type == "vector":
+        # Join all lines and replace unwanted characters once
+        joined_coords = (
+            b" ".join(string_coords)
+            .replace(b")", b"")
+            .replace(b"(", b"")
+            .replace(b"\n", b"")
+        )
+        # Convert to a numpy array in one go
+        data_array = np.fromstring(joined_coords, sep=" ", dtype=float).reshape(
+            num_data_, 3
+        )
+
+    else:
+        sys.exit("Unknown data_type. please use 'label', 'scalar' or 'vector'.")
+
+    return data_array
+
+
+def _extractListList(content: List[bytes], data_type: str) -> np.ndarray:
+    num_list_, start_idx = _num_list(content)
+    # print(f"The number of list is: {num_list_}")
+    subcontent = content[start_idx + 1 :]
+    data_list = []
+    for i in range(num_list_):
+        num_data_, data_idx = _num_list(subcontent)
+        data_start_idx = data_idx + 2
+        # Extract relevant lines containing coordinates
+        string_coords = subcontent[data_start_idx : data_start_idx + num_data_]
+
+        if data_type == "label":
+            # Join all lines and replace unwanted characters once
+            joined_coords = b" ".join(string_coords).replace(b"\n", b"")
+            # Convert to a numpy array in one go
+            data_list.append(np.fromstring(joined_coords, sep=" ", dtype=int))
+
+        elif data_type == "scalar":
+            # Join all lines and replace unwanted characters once
+            joined_coords = b" ".join(string_coords).replace(b"\n", b"")
+            # Convert to a numpy array in one go
+            data_list.append(np.fromstring(joined_coords, sep=" ", dtype=float))
+
+        elif data_type == "vector":
+            # Join all lines and replace unwanted characters once
+            joined_coords = (
+                b" ".join(string_coords)
+                .replace(b")", b"")
+                .replace(b"(", b"")
+                .replace(b"\n", b"")
+            )
+            # Convert to a numpy array in one go
+            data_list.append(
+                np.fromstring(joined_coords, sep=" ", dtype=float).reshape(num_data_, 3)
+            )
+        else:
+            sys.exit("Unknown data_type. please use 'label', 'scalar' or 'vector'.")
+
+        subcontent = subcontent[data_start_idx + num_data_ + 1 :]
+
+    return np.array(data_list)
+
+
+def readListList(fileName: str, data_type: str) -> np.ndarray:
+    try:
+        with open(fileName, "rb") as f:
+            pass
+    except FileNotFoundError:
+        sys.exit(f"File {fileName} not found. Please check the file path.")
+    with open(f"{fileName}", "rb") as f:
+        return _extractListList(f.readlines(), data_type)
+
+
+def _extractUniformList(file: List[bytes], data_type: str) -> Tuple[int, np.ndarray]:
+    for line in file:
+        line = line.decode("utf-8").strip()
+        if "{" in line and "}" in line:
+            length, data = line.split("{")
+            length = int(length.strip())
+            data = data.replace("}", "").strip()
+            if data_type == "label":
+                return length, np.array(int(data))
+            elif data_type == "scalar":
+                return length, np.array(float(data))
+            elif data_type == "vector":
+                vector_values = data.strip("()").split()
+                return length, np.array(
+                        [
+                            float(vector_values[0]),
+                            float(vector_values[1]),
+                            float(vector_values[2]),
+                        ]
+                )
+            else:
+                sys.exit("Unknown data_type. please use 'label', 'scalar' or 'vector'.")
+
+
+def readList(fileName: str, data_type: str, fullLength: bool = True) -> np.ndarray:
+    try:
+        with open(fileName, "rb") as f:
+            pass
+    except FileNotFoundError:
+        sys.exit(f"File {fileName} not found. Please check the file path.")
+    with open(f"{fileName}", "rb") as f:
+        file_content = f.readlines()
+        file_length = len(file_content)
+        if file_length == 1:
+            length, data = _extractUniformList(file_content, data_type)
+            if fullLength:
+                if data_type == "vector":
+                    return np.tile(data, (length, 1))
+                else:
+                    return np.repeat(data, length, axis=0)
+            else:
+                return data
+        else:
+            return _extractList(file_content, data_type)
+
+
+def writeList(
+    data: np.ndarray, data_type: str, fileName: str, object_name: str = "None"
+) -> None:
+    """
+    Write data to a file
+    :param data: data to write
+    :param data_type: data type
+    :param fileName: file name
+    :return: None
+    """
+
+    with open(fileName, "w") as f:
+        output = []
+
+        thisHeader = header.replace("className;", f"{data_type}List;")
+        if object_name != "None":
+            thisHeader = thisHeader.replace(
+                "object      data;", f"object      {object_name};"
+            )
+            output.append(thisHeader + "\n\n")
+        else:
+            output.append(thisHeader + "\n\n")
+
+        output.append(f"{data.shape[0]}\n")
+        output.append("(\n")
+        if data_type == "label":
+            for point in data:
+                output.append(f"{point:d}\n")
+        elif data_type == "scalar":
+            for point in data:
+                output.append(f"{point:.8e}\n")
+        elif data_type == "vector":
+            for point in data:
+                output.append(f"({point[0]:.8e} {point[1]:.8e} {point[2]:.8e})\n")
+        else:
+            sys.exit("Unknown data_type. please use 'label', 'scalar' or 'vector'.")
+        output.append(")\n")
+        output.append(ender)
+        f.write("".join(output))

foamtopython-0.0.1.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: foamToPython
+Version: 0.0.1
+Summary: A py package to read and write OpenFOAM data
+Author-email: Shenhui_Ruan <shenhui.ruan@kit.edu>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+
+[foamToPython](https://github.com/Ruansh233/foamToPython.git) 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](https://github.com/fluiddyn/fluidfoam) and [foamlib](https://github.com/gerlero/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.
+
+![Performance Comparison](https://raw.githubusercontent.com/Ruansh233/foamToPython/main/foamToPython_comparison.png)
+
+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](https://pypi.org/project/PyFoam/) is not involved in the comparsion due to the problem of version compatibility.
+
+## Installation
+You can install the package via pip:
+```bash
+pip install foamToPython
+```
+Or you can clone the repository and install it manually:
+```bash
+pip install git+https://github.com/Ruansh233/foamToPython.git
+```
+
+## Usage and Examples
+
+### <span style="color:blue;">OFField</span> 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 <span style="color:blue;">internalField</span> and <span style="color:blue;">boundaryField</span>
+
+`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.
+
+#### <span style="color:blue;">writeField</span>
+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.
+
+### <span style="color:blue;">readList</span> 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").`
+
+### <span style="color:blue;">readListList</span> 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 <span style="color:blue;">POD</span> 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.

foamtopython-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+PODopenFOAM/__init__.py,sha256=b69xkbdteJB1NKD0pzbvpZlv5XecgG6rMWqCufjWtvc,88
+PODopenFOAM/ofmodes.py,sha256=ijbToWofpoAS1IH6NZ-ukcIIS2NzJPzexSi7tgha9BI,45123
+foamToPython/__init__.py,sha256=gkxoBFtrheK7_4ypMfvNpzTtuxODXgC14O59nUrtRo8,202
+foamToPython/headerEnd.py,sha256=71YKtxBeTVvNVqwesjTPyN9UUFdLRVnaQrdme5RFp2I,931
+foamToPython/readOFField.py,sha256=YVn40Z7p305rPVhohs7vIuuOb2ee6o_Vh6rI8roiPVA,47006
+foamToPython/readOFList.py,sha256=Vj5viT3NFnCOhKY_rDbohrvgxu2Trt81rR_K1zMmU5w,7384
+foamtopython-0.0.1.dist-info/METADATA,sha256=ufh0PkLQyKfHDvRZX9M_MqudqwhsxM2e0bszFcHF-SM,5823
+foamtopython-0.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+foamtopython-0.0.1.dist-info/top_level.txt,sha256=MK_8dURMuIU0_VSaR3Z0upsnsFKlfvgeAd2gqXURjRM,25
+foamtopython-0.0.1.dist-info/RECORD,,

foamtopython-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

foamtopython-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+PODopenFOAM
+foamToPython