foamlib 0.9.4__tar.gz → 0.9.6__tar.gz

{foamlib-0.9.4 → foamlib-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.4
+Version: 0.9.6
 Summary: A Python interface for interacting with OpenFOAM
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib
@@ -196,148 +196,9 @@ case = FoamCase(Path(__file__).parent)
 case.run()
 ```
 
-## ▶️ A complete example
+## 📘 Documentation
 
-The following is a fully self-contained example that demonstrates how to create an OpenFOAM case from scratch, run it, and analyze the results.
-
-<details>
-
-<summary>Example</summary>
-
-```python
-#!/usr/bin/env python3
-"""Check the diffusion of a scalar field in a scalarTransportFoam case."""
-
-import shutil
-from pathlib import Path
-
-import numpy as np
-from scipy.special import erfc
-from foamlib import FoamCase
-
-path = Path(__file__).parent / "diffusionCheck"
-shutil.rmtree(path, ignore_errors=True)
-path.mkdir(parents=True)
-(path / "system").mkdir()
-(path / "constant").mkdir()
-(path / "0").mkdir()
-
-case = FoamCase(path)
-
-with case.control_dict as f:
-    f["application"] = "scalarTransportFoam"
-    f["startFrom"] = "latestTime"
-    f["stopAt"] = "endTime"
-    f["endTime"] = 5
-    f["deltaT"] = 1e-3
-    f["writeControl"] = "adjustableRunTime"
-    f["writeInterval"] = 1
-    f["purgeWrite"] = 0
-    f["writeFormat"] = "ascii"
-    f["writePrecision"] = 6
-    f["writeCompression"] = False
-    f["timeFormat"] = "general"
-    f["timePrecision"] = 6
-    f["adjustTimeStep"] = False
-    f["runTimeModifiable"] = False
-
-with case.fv_schemes as f:
-    f["ddtSchemes"] = {"default": "Euler"}
-    f["gradSchemes"] = {"default": "Gauss linear"}
-    f["divSchemes"] = {"default": "none", "div(phi,U)": "Gauss linear", "div(phi,T)": "Gauss linear"}
-    f["laplacianSchemes"] = {"default": "Gauss linear corrected"}
-
-with case.fv_solution as f:
-    f["solvers"] = {"T": {"solver": "PBiCG", "preconditioner": "DILU", "tolerance": 1e-6, "relTol": 0}}
-
-with case.block_mesh_dict as f:
-    f["scale"] = 1
-    f["vertices"] = [
-        [0, 0, 0],
-        [1, 0, 0],
-        [1, 0.5, 0],
-        [1, 1, 0],
-        [0, 1, 0],
-        [0, 0.5, 0],
-        [0, 0, 0.1],
-        [1, 0, 0.1],
-        [1, 0.5, 0.1],
-        [1, 1, 0.1],
-        [0, 1, 0.1],
-        [0, 0.5, 0.1],
-    ]
-    f["blocks"] = [
-        "hex", [0, 1, 2, 5, 6, 7, 8, 11], [400, 20, 1], "simpleGrading", [1, 1, 1],
-        "hex", [5, 2, 3, 4, 11, 8, 9, 10], [400, 20, 1], "simpleGrading", [1, 1, 1],
-    ]
-    f["edges"] = []
-    f["boundary"] = [
-        ("inletUp", {"type": "patch", "faces": [[5, 4, 10, 11]]}),
-        ("inletDown", {"type": "patch", "faces": [[0, 5, 11, 6]]}),
-        ("outletUp", {"type": "patch", "faces": [[2, 3, 9, 8]]}),
-        ("outletDown", {"type": "patch", "faces": [[1, 2, 8, 7]]}),
-        ("walls", {"type": "wall", "faces": [[4, 3, 9, 10], [0, 1, 7, 6]]}),
-        ("frontAndBack", {"type": "empty", "faces": [[0, 1, 2, 5], [5, 2, 3, 4], [6, 7, 8, 11], [11, 8, 9, 10]]}),
-    ]
-    f["mergePatchPairs"] = []
-
-with case.transport_properties as f:
-    f["DT"] = f.Dimensioned(1e-3, f.DimensionSet(length=2, time=-1), "DT")
-
-with case[0]["U"] as f:
-    f.dimensions = f.DimensionSet(length=1, time=-1)
-    f.internal_field = [1, 0, 0]
-    f.boundary_field = {
-        "inletUp": {"type": "fixedValue", "value": [1, 0, 0]},
-        "inletDown": {"type": "fixedValue", "value": [1, 0, 0]},
-        "outletUp": {"type": "zeroGradient"},
-        "outletDown": {"type": "zeroGradient"},
-        "walls": {"type": "zeroGradient"},
-        "frontAndBack": {"type": "empty"},
-    }
-
-with case[0]["T"] as f:
-    f.dimensions = f.DimensionSet(temperature=1)
-    f.internal_field = 0
-    f.boundary_field = {
-        "inletUp": {"type": "fixedValue", "value": 0},
-        "inletDown": {"type": "fixedValue", "value": 1},
-        "outletUp": {"type": "zeroGradient"},
-        "outletDown": {"type": "zeroGradient"},
-        "walls": {"type": "zeroGradient"},
-        "frontAndBack": {"type": "empty"},
-    }
-
-case.run()
-
-x, y, z = case[0].cell_centers().internal_field.T
-
-end = x == x.max()
-x = x[end]
-y = y[end]
-z = z[end]
-
-DT = case.transport_properties["DT"].value
-U = case[0]["U"].internal_field[0]
-
-for time in case[1:]:
-    if U*time.time < 2*x.max():
-        continue
-
-    T = time["T"].internal_field[end]
-    analytical = 0.5 * erfc((y - 0.5) / np.sqrt(4 * DT * x/U))
-    if np.allclose(T, analytical, atol=0.1):
-        print(f"Time {time.time}: OK")
-    else:
-        raise RuntimeError(f"Time {time.time}: {T} != {analytical}")
-```
-
-</details>
-
-
-## 📘 API documentation
-
-For more information on how to use **foamlibs**'s classes and methods, check out the [documentation](https://foamlib.readthedocs.io/).
+For details on how to use **foamlib**, check out the [documentation](https://foamlib.readthedocs.io/).
 
 ## 🙋 Support
 

{foamlib-0.9.4 → foamlib-0.9.6}/README.md

@@ -158,148 +158,9 @@ case = FoamCase(Path(__file__).parent)
 case.run()
 ```
 
-## ▶️ A complete example
+## 📘 Documentation
 
-The following is a fully self-contained example that demonstrates how to create an OpenFOAM case from scratch, run it, and analyze the results.
-
-<details>
-
-<summary>Example</summary>
-
-```python
-#!/usr/bin/env python3
-"""Check the diffusion of a scalar field in a scalarTransportFoam case."""
-
-import shutil
-from pathlib import Path
-
-import numpy as np
-from scipy.special import erfc
-from foamlib import FoamCase
-
-path = Path(__file__).parent / "diffusionCheck"
-shutil.rmtree(path, ignore_errors=True)
-path.mkdir(parents=True)
-(path / "system").mkdir()
-(path / "constant").mkdir()
-(path / "0").mkdir()
-
-case = FoamCase(path)
-
-with case.control_dict as f:
-    f["application"] = "scalarTransportFoam"
-    f["startFrom"] = "latestTime"
-    f["stopAt"] = "endTime"
-    f["endTime"] = 5
-    f["deltaT"] = 1e-3
-    f["writeControl"] = "adjustableRunTime"
-    f["writeInterval"] = 1
-    f["purgeWrite"] = 0
-    f["writeFormat"] = "ascii"
-    f["writePrecision"] = 6
-    f["writeCompression"] = False
-    f["timeFormat"] = "general"
-    f["timePrecision"] = 6
-    f["adjustTimeStep"] = False
-    f["runTimeModifiable"] = False
-
-with case.fv_schemes as f:
-    f["ddtSchemes"] = {"default": "Euler"}
-    f["gradSchemes"] = {"default": "Gauss linear"}
-    f["divSchemes"] = {"default": "none", "div(phi,U)": "Gauss linear", "div(phi,T)": "Gauss linear"}
-    f["laplacianSchemes"] = {"default": "Gauss linear corrected"}
-
-with case.fv_solution as f:
-    f["solvers"] = {"T": {"solver": "PBiCG", "preconditioner": "DILU", "tolerance": 1e-6, "relTol": 0}}
-
-with case.block_mesh_dict as f:
-    f["scale"] = 1
-    f["vertices"] = [
-        [0, 0, 0],
-        [1, 0, 0],
-        [1, 0.5, 0],
-        [1, 1, 0],
-        [0, 1, 0],
-        [0, 0.5, 0],
-        [0, 0, 0.1],
-        [1, 0, 0.1],
-        [1, 0.5, 0.1],
-        [1, 1, 0.1],
-        [0, 1, 0.1],
-        [0, 0.5, 0.1],
-    ]
-    f["blocks"] = [
-        "hex", [0, 1, 2, 5, 6, 7, 8, 11], [400, 20, 1], "simpleGrading", [1, 1, 1],
-        "hex", [5, 2, 3, 4, 11, 8, 9, 10], [400, 20, 1], "simpleGrading", [1, 1, 1],
-    ]
-    f["edges"] = []
-    f["boundary"] = [
-        ("inletUp", {"type": "patch", "faces": [[5, 4, 10, 11]]}),
-        ("inletDown", {"type": "patch", "faces": [[0, 5, 11, 6]]}),
-        ("outletUp", {"type": "patch", "faces": [[2, 3, 9, 8]]}),
-        ("outletDown", {"type": "patch", "faces": [[1, 2, 8, 7]]}),
-        ("walls", {"type": "wall", "faces": [[4, 3, 9, 10], [0, 1, 7, 6]]}),
-        ("frontAndBack", {"type": "empty", "faces": [[0, 1, 2, 5], [5, 2, 3, 4], [6, 7, 8, 11], [11, 8, 9, 10]]}),
-    ]
-    f["mergePatchPairs"] = []
-
-with case.transport_properties as f:
-    f["DT"] = f.Dimensioned(1e-3, f.DimensionSet(length=2, time=-1), "DT")
-
-with case[0]["U"] as f:
-    f.dimensions = f.DimensionSet(length=1, time=-1)
-    f.internal_field = [1, 0, 0]
-    f.boundary_field = {
-        "inletUp": {"type": "fixedValue", "value": [1, 0, 0]},
-        "inletDown": {"type": "fixedValue", "value": [1, 0, 0]},
-        "outletUp": {"type": "zeroGradient"},
-        "outletDown": {"type": "zeroGradient"},
-        "walls": {"type": "zeroGradient"},
-        "frontAndBack": {"type": "empty"},
-    }
-
-with case[0]["T"] as f:
-    f.dimensions = f.DimensionSet(temperature=1)
-    f.internal_field = 0
-    f.boundary_field = {
-        "inletUp": {"type": "fixedValue", "value": 0},
-        "inletDown": {"type": "fixedValue", "value": 1},
-        "outletUp": {"type": "zeroGradient"},
-        "outletDown": {"type": "zeroGradient"},
-        "walls": {"type": "zeroGradient"},
-        "frontAndBack": {"type": "empty"},
-    }
-
-case.run()
-
-x, y, z = case[0].cell_centers().internal_field.T
-
-end = x == x.max()
-x = x[end]
-y = y[end]
-z = z[end]
-
-DT = case.transport_properties["DT"].value
-U = case[0]["U"].internal_field[0]
-
-for time in case[1:]:
-    if U*time.time < 2*x.max():
-        continue
-
-    T = time["T"].internal_field[end]
-    analytical = 0.5 * erfc((y - 0.5) / np.sqrt(4 * DT * x/U))
-    if np.allclose(T, analytical, atol=0.1):
-        print(f"Time {time.time}: OK")
-    else:
-        raise RuntimeError(f"Time {time.time}: {T} != {analytical}")
-```
-
-</details>
-
-
-## 📘 API documentation
-
-For more information on how to use **foamlibs**'s classes and methods, check out the [documentation](https://foamlib.readthedocs.io/).
+For details on how to use **foamlib**, check out the [documentation](https://foamlib.readthedocs.io/).
 
 ## 🙋 Support
 

{foamlib-0.9.4 → foamlib-0.9.6}/docs/conf.py

@@ -7,7 +7,7 @@
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = "foamlib"
-copyright = "2024, Gabriel S. Gerlero"
+copyright = "2024-2025, Gabriel S. Gerlero"
 author = "Gabriel S. Gerlero"
 
 # -- General configuration ---------------------------------------------------

foamlib-0.9.6/docs/example.rst

@@ -0,0 +1,144 @@
+Example
+=======
+
+This example script sets up and runs a validation test case for the ``scalarTransportFoam`` solver, verifying the diffusion of a scalar field in a simplified 2D domain.
+
+Overview
+--------
+
+- Creates a clean OpenFOAM case in the ``diffusionCheck`` subdirectory.
+- Configures mesh geometry, solver settings, and initial/boundary conditions for scalar (``T``) and velocity (``U``) fields.
+- Simulates a velocity-driven scalar transport where a temperature gradient is imposed across the inlet.
+- Uses :class:`foamlib.FoamCase` and related utilities to manage OpenFOAM input files and execution.
+- Computes an analytical solution using the complementary error function (:func:`scipy.special.erfc`) and compares it against numerical results.
+
+Code
+----
+
+.. code-block:: python
+
+    #!/usr/bin/env python3
+    """Check the diffusion of a scalar field in a scalarTransportFoam case."""
+
+    import shutil
+    from pathlib import Path
+
+    import numpy as np
+    from scipy.special import erfc
+    from foamlib import FoamCase, FoamFile
+
+    path = Path(__file__).parent / "diffusionCheck"
+    shutil.rmtree(path, ignore_errors=True)
+    path.mkdir(parents=True)
+    (path / "system").mkdir()
+    (path / "constant").mkdir()
+    (path / "0").mkdir()
+
+    case = FoamCase(path)
+
+    with case.control_dict as f:
+        f["application"] = "scalarTransportFoam"
+        f["startFrom"] = "latestTime"
+        f["stopAt"] = "endTime"
+        f["endTime"] = 5
+        f["deltaT"] = 1e-3
+        f["writeControl"] = "adjustableRunTime"
+        f["writeInterval"] = 1
+        f["purgeWrite"] = 0
+        f["writeFormat"] = "ascii"
+        f["writePrecision"] = 6
+        f["writeCompression"] = False
+        f["timeFormat"] = "general"
+        f["timePrecision"] = 6
+        f["adjustTimeStep"] = False
+        f["runTimeModifiable"] = False
+
+    with case.fv_schemes as f:
+        f["ddtSchemes"] = {"default": "Euler"}
+        f["gradSchemes"] = {"default": "Gauss linear"}
+        f["divSchemes"] = {"default": "none", "div(phi,U)": "Gauss linear", "div(phi,T)": "Gauss linear"}
+        f["laplacianSchemes"] = {"default": "Gauss linear corrected"}
+
+    with case.fv_solution as f:
+        f["solvers"] = {"T": {"solver": "PBiCG", "preconditioner": "DILU", "tolerance": 1e-6, "relTol": 0}}
+
+    with case.block_mesh_dict as f:
+        f["scale"] = 1
+        f["vertices"] = [
+            [0, 0, 0],
+            [1, 0, 0],
+            [1, 0.5, 0],
+            [1, 1, 0],
+            [0, 1, 0],
+            [0, 0.5, 0],
+            [0, 0, 0.1],
+            [1, 0, 0.1],
+            [1, 0.5, 0.1],
+            [1, 1, 0.1],
+            [0, 1, 0.1],
+            [0, 0.5, 0.1],
+        ]
+        f["blocks"] = [
+            "hex", [0, 1, 2, 5, 6, 7, 8, 11], [400, 20, 1], "simpleGrading", [1, 1, 1],
+            "hex", [5, 2, 3, 4, 11, 8, 9, 10], [400, 20, 1], "simpleGrading", [1, 1, 1],
+        ]
+        f["edges"] = []
+        f["boundary"] = [
+            ("inletUp", {"type": "patch", "faces": [[5, 4, 10, 11]]}),
+            ("inletDown", {"type": "patch", "faces": [[0, 5, 11, 6]]}),
+            ("outletUp", {"type": "patch", "faces": [[2, 3, 9, 8]]}),
+            ("outletDown", {"type": "patch", "faces": [[1, 2, 8, 7]]}),
+            ("walls", {"type": "wall", "faces": [[4, 3, 9, 10], [0, 1, 7, 6]]}),
+            ("frontAndBack", {"type": "empty", "faces": [[0, 1, 2, 5], [5, 2, 3, 4], [6, 7, 8, 11], [11, 8, 9, 10]]}),
+        ]
+        f["mergePatchPairs"] = []
+
+    with case.transport_properties as f:
+        f["DT"] = FoamFile.Dimensioned(1e-3, f.DimensionSet(length=2, time=-1), "DT")
+
+    with case[0]["U"] as f:
+        f.dimensions = FoamFile.DimensionSet(length=1, time=-1)
+        f.internal_field = [1, 0, 0]
+        f.boundary_field = {
+            "inletUp": {"type": "fixedValue", "value": [1, 0, 0]},
+            "inletDown": {"type": "fixedValue", "value": [1, 0, 0]},
+            "outletUp": {"type": "zeroGradient"},
+            "outletDown": {"type": "zeroGradient"},
+            "walls": {"type": "zeroGradient"},
+            "frontAndBack": {"type": "empty"},
+        }
+
+    with case[0]["T"] as f:
+        f.dimensions = FoamFile.DimensionSet(temperature=1)
+        f.internal_field = 0
+        f.boundary_field = {
+            "inletUp": {"type": "fixedValue", "value": 0},
+            "inletDown": {"type": "fixedValue", "value": 1},
+            "outletUp": {"type": "zeroGradient"},
+            "outletDown": {"type": "zeroGradient"},
+            "walls": {"type": "zeroGradient"},
+            "frontAndBack": {"type": "empty"},
+        }
+
+    case.run()
+
+    x, y, z = case[0].cell_centers().internal_field.T
+
+    end = x == x.max()
+    x = x[end]
+    y = y[end]
+    z = z[end]
+
+    DT = case.transport_properties["DT"].value
+    U = case[0]["U"].internal_field[0]
+
+    for time in case[1:]:
+        if U*time.time < 2*x.max():
+            continue
+
+        T = time["T"].internal_field[end]
+        analytical = 0.5 * erfc((y - 0.5) / np.sqrt(4 * DT * x/U))
+        if np.allclose(T, analytical, atol=0.1):
+            print(f"Time {time.time}: OK")
+        else:
+            raise RuntimeError(f"Time {time.time}: {T} != {analytical}")

foamlib-0.9.6/docs/index.rst

@@ -0,0 +1,25 @@
+.. image:: https://github.com/gerlero/foamlib/blob/main/logo.png?raw=true
+   :alt: foamlib logo
+   :width: 200 px
+   :target: https://github.com/gerlero/foamlib
+=========================================================================
+
+`foamlib <https://github.com/gerlero/foamlib>`_ is a modern Python package that simplifies working with OpenFOAM cases and files by providing a standalone parser for seamless interaction with OpenFOAM's input/output data. It includes robust case-handling capabilities that reduce boilerplate code and enable efficient pre-processing, post-processing, and simulation management directly from Python. With support for ASCII- and binary-formatted fields, a fully type-hinted API, and asynchronous operations, foamlib offers a streamlined, Pythonic approach to automating and managing OpenFOAM workflows.
+
+Documentation
+=============
+
+.. toctree::
+   :maxdepth: 2
+
+   example
+   cases
+   files
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

{foamlib-0.9.4 → foamlib-0.9.6}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.9.4"
+__version__ = "0.9.6"
 
 from ._cases import (
     AsyncFoamCase,

{foamlib-0.9.4 → foamlib-0.9.6}/foamlib/_cases/_async.py

@@ -44,13 +44,14 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     Provides methods for running and cleaning cases, as well as accessing files.
 
-    Access the time directories of the case as a sequence, e.g. `case[0]` or `case[-1]`.
-    These will return `AsyncFoamCase.TimeDirectory` objects.
+    Access the time directories of the case as a sequence, e.g. ``case[0]`` or ``case[-1]``.
+    These will return :class:`AsyncFoamCase.TimeDirectory` objects.
 
     :param path: The path to the case directory. Defaults to the current working
         directory.
 
     Example usage: ::
+
         from foamlib import AsyncFoamCase
 
         case = AsyncFoamCase("path/to/case") # Load an OpenFOAM case
@@ -82,7 +83,7 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     max_cpus = multiprocessing.cpu_count()
     """
-    Maximum number of CPUs to use for running instances of `AsyncFoamCase` concurrently.
+    Maximum number of CPUs to use for running instances of :class:`AsyncFoamCase` concurrently.
 
     Defaults to the number of CPUs on the system.
     """
@@ -143,19 +144,23 @@ class AsyncFoamCase(FoamCaseRunBase):
         """
         Clean this case.
 
-        If a `clean` or `Allclean` script is present in the case directory, it will be invoked.
+        If a ``clean`` or ``Allclean`` script is present in the case directory, it will be invoked.
         Otherwise, the case directory will be cleaned using these rules:
 
-        - All time directories except `0` will be deleted.
-        - The `0` time directory will be deleted if `0.orig` exists.
-        - `processor*` directories will be deleted if a `system/decomposeParDict` file is present.
-        - `constant/polyMesh` will be deleted if a `system/blockMeshDict` file is present.
-        - All `log.*` files will be deleted.
+        - All time directories except ``0`` will be deleted.
+
+        - The ``0`` time directory will be deleted if ``0.orig`` exists.
+
+        - ``processor*`` directories will be deleted if a ``system/decomposeParDict`` file is present.
+
+        - ``constant/polyMesh`` will be deleted if a ``system/blockMeshDict`` file is present.
+
+        - All ``log.*`` files will be deleted.
 
         If this behavior is not appropriate for a case, it is recommended to write a custom
-        `clean` script.
+        ``clean`` script.
 
-        :param check: If True, raise a `CalledProcessError` if the clean script returns a
+        :param check: If True, raise a :class:`CalledProcessError` if the clean script returns a
             non-zero exit code.
         """
         for coro in self._clean_calls(check=check):
@@ -191,35 +196,40 @@ class AsyncFoamCase(FoamCaseRunBase):
         """
         Run this case, or a specified command in the context of this case.
 
-        If `cmd` is given, this method will run the given command in the context of the case.
+        If ``cmd`` is given, this method will run the given command in the context of the case.
 
-        If `cmd` is `None`, a series of heuristic rules will be used to run the case. This works as
+        If ``cmd`` is ``None``, a series of heuristic rules will be used to run the case. This works as
         follows:
 
-        - If a `run`, `Allrun` or `Allrun-parallel` script is present in the case directory,
-        it will be invoked. If both `run` and `Allrun` are present, `Allrun` will be used. If
-        both `Allrun` and `Allrun-parallel` are present and `parallel` is `None`, an error will
-        be raised.
-        - If no run script is present but an `Allrun.pre` script exists, it will be invoked.
-        - Otherwise, if a `system/blockMeshDict` file is present, the method will call
-        `self.block_mesh()`.
-        - Then, if a `0.orig` directory is present, it will call `self.restore_0_dir()`.
-        - Then, if the case is to be run in parallel (see the `parallel` option) and no
-        `processor*` directories exist but a`system/decomposeParDict` file is present, it will
-        call `self.decompose_par()`.
+        - If a ``run``, ``Allrun`` or ``Allrun-parallel`` script is present in the case directory,
+          it will be invoked. If both ``run`` and ``Allrun`` are present, ``Allrun`` will be used. If
+          both ``Allrun`` and ``Allrun-parallel`` are present and ``parallel`` is ``None``, an error will
+          be raised.
+
+        - If no run script is present but an ``Allrun.pre`` script exists, it will be invoked.
+
+        - Otherwise, if a ``system/blockMeshDict`` file is present, the method will call
+          :meth:`block_mesh()`.
+
+        - Then, if a ``0.orig`` directory is present, it will call :meth:`restore_0_dir()`.
+
+        - Then, if the case is to be run in parallel (see the ``parallel`` option) and no
+          ``processor*`` directories exist but a ``system/decomposeParDict`` file is present, it will
+          call :meth:`decompose_par()`.
+
         - Then, it will run the case using the application specified in the `controlDict` file.
 
         If this behavior is not appropriate for a case, it is recommended to write a custom
-        `run`, `Allrun`, `Allrun-parallel` or `Allrun.pre` script.
+        ``run``, ``Allrun``, ``Allrun-parallel`` or ``Allrun.pre`` script.
 
-        :param cmd: The command to run. If `None`, run the case. If a sequence, the first element
-            is the command and the rest are arguments. If a string, `cmd` is executed in a shell.
-        :param parallel: If `True`, run in parallel using MPI. If None, autodetect whether to run
+        :param cmd: The command to run. If ``None``, run the case. If a sequence, the first element
+            is the command and the rest are arguments. If a string, ``cmd`` is executed in a shell.
+        :param parallel: If ``True``, run in parallel using MPI. If None, autodetect whether to run
             in parallel.
-        :param cpus: The number of CPUs to use. If `None`, autodetect from to the case.
-        :param check: If `True`, raise a `CalledProcessError` if any command returns a non-zero
+        :param cpus: The number of CPUs to use. If ``None``, autodetect from to the case.
+        :param check: If ``True``, raise a :class:`CalledProcessError` if any command returns a non-zero
             exit code.
-        :param log: If `True`, log the command output to `log.*` files in the case directory.
+        :param log: If ``True``, log the command output to ``log.*`` files in the case directory.
         """
         for coro in self._run_calls(
             cmd=cmd, parallel=parallel, cpus=cpus, check=check, log=log
@@ -262,6 +272,7 @@ class AsyncFoamCase(FoamCaseRunBase):
         :return: The copy of the case.
 
         Example usage: ::
+
             import os
             from pathlib import Path
             from foamlib import AsyncFoamCase
@@ -298,6 +309,7 @@ class AsyncFoamCase(FoamCaseRunBase):
         :return: The clone of the case.
 
         Example usage: ::
+
             import os
             from pathlib import Path
             from foamlib import AsyncFoamCase

{foamlib-0.9.4 → foamlib-0.9.6}/foamlib/_cases/_base.py

@@ -23,10 +23,10 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     Provides methods for accessing files and time directories in the case, but does not
     provide methods for running the case or any commands. Users are encouraged to use
-    `FoamCase` or `AsyncFoamCase` instead of this class.
+    :class:`FoamCase` or :class:`AsyncFoamCase` instead of this class.
 
-    Access the time directories of the case as a sequence, e.g. `case[0]` or `case[-1]`.
-    These will return `FoamCaseBase.TimeDirectory` objects.
+    Access the time directories of the case as a sequence, e.g. ``case[0]`` or ``case[-1]``.
+    These will return class:`FoamCaseBase.TimeDirectory` objects.
 
     :param path: The path to the case directory. Defaults to the current working
         directory.
@@ -39,11 +39,11 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         """
         A time directory in an OpenFOAM case.
 
-        Use to access field files in the directory (e.g. `time["U"]`). These will be
-        returned as `FoamFieldFile` objects.
+        Use to access field files in the directory (e.g. ``time["U"]``). These will be
+        returned as :class:`FoamFieldFile` objects.
 
-        It also behaves as a set of `FoamFieldFile` objects (e.g. it can be
-        iterated over with `for field in time: ...`).
+        It also behaves as a set of :class:`FoamFieldFile` objects (e.g. it can be
+        iterated over with ``for field in time: ...``).
         """
 
         def __init__(self, path: os.PathLike[str] | str) -> None:
@@ -154,7 +154,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def _nsubdomains(self) -> int | None:
-        """Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found."""
+        """Return the number of subdomains as set in the decomposeParDict, or ``None`` if no decomposeParDict is found."""
         try:
             nsubdomains = self.decompose_par_dict["numberOfSubdomains"]
             if not isinstance(nsubdomains, int):