PySDM 3.0.0rc11__tar.gz → 3.0.0rc13__tar.gz

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/.github/workflows/pdoc.yml

@@ -28,7 +28,7 @@ jobs:
           python-version: "3.12"
 
       - name: exclude pvpython scripts
-        run: rm examples/PySDM_examples/utils/pvanim.py
+        run: grep -rl '^#!/usr/bin/env pvpython' examples/PySDM_examples | xargs rm -f
 
       - run: pip install pdoc nbformat gitpython
       - run: pip install -e .

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/.github/workflows/precommit.yml

@@ -24,7 +24,7 @@ jobs:
       - uses: actions/checkout@v4.1.6
       - uses: actions/setup-python@v5.0.0
         with:
-          python-version: 3.9
+          python-version: "3.10"
       - run: |
           pip install pre-commit
           pre-commit clean

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/.github/workflows/pypi.yml

@@ -38,7 +38,7 @@ jobs:
           unset CI
           cd ${{ matrix.packages-dir }}
           python -m build 2>&1 | tee build.log
-          exit `fgrep -i warning build.log | grep -v impl_numba/warnings.py \
+          exit `fgrep -i warning build.log | grep -v warnings.py \
             | grep -v "no previously-included files matching" \
             | grep -v "version of {dist_name} already set" \
             | grep -v -E "UserWarning: version of PySDM(-examples)? already set" \
@@ -58,10 +58,7 @@ jobs:
     strategy:
       matrix:
         platform: [ ubuntu-latest, macos-latest, windows-latest ]
-        python-version: [ "3.9", "3.12" ]
-        exclude:
-          - platform: macos-14
-            python-version: "3.9"
+        python-version: [ "3.10", "3.12" ]
     runs-on: ${{ matrix.platform }}
     needs: [ package ]
     steps:

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/.github/workflows/readme_snippets.yml

@@ -25,7 +25,6 @@ jobs:
           python-version: "3.10"
       - run: python -m pip install $PIP_INSTALL_ARGS -e .
       - run: python -m pip install $PIP_INSTALL_ARGS pytest-codeblocks pytest
-      - run: python -m pip install $PIP_INSTALL_ARGS "pillow<11.3.0"  # matplotlib triggers deprecation warnings in 11.3.0
       - run: |
           python -c "import os,pytest_codeblocks; code=pytest_codeblocks.extract_from_file('docs/markdown/pysdm_landing.md'); f=open('readme.py', 'w', encoding='utf-8'); f.write('# coding: utf-8'+os.linesep); f.writelines(block.code for block in code if block.syntax=='Python'); f.close()"
       - run: cat -n readme.py
@@ -65,14 +64,17 @@ jobs:
       - uses: actions/checkout@v4.1.6
       - uses: actions/setup-python@v5.0.0
         with:
-          python-version: 3.9
+          python-version: "3.12"
+
+      - run: echo NUMBA_THREADING_LAYER=omp >> $GITHUB_ENV
+
       - run: pip install -e .
       - run: pip install pytest-codeblocks pytest
       - run: python -c "import pytest_codeblocks; code=pytest_codeblocks.extract_from_file('docs/markdown/pysdm_landing.md'); f=open('readme.m', 'w'); f.writelines(block.code for block in code if block.syntax=='Matlab'); f.close()"
       - run: cat -n readme.m
       - uses: matlab-actions/setup-matlab@v2.1.0
         with:
-          release: R2022a
+          release: R2024b
           cache: true
       - uses: matlab-actions/run-command@v2.1.0
         with:

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/.github/workflows/tests.yml

@@ -26,7 +26,7 @@ jobs:
     strategy:
       matrix:
         platform: [ ubuntu-24.04, macos-15-intel, macos-14, windows-latest ]
-        python-version: [ "3.9", "3.12" ]
+        python-version: [ "3.10", "3.12" ]
     runs-on: ${{ matrix.platform }}
     steps:
       - uses: actions/checkout@v4.1.6
@@ -45,7 +45,7 @@ jobs:
         python-version: ["3.12"]
         include: # for pylint
           - platform: ubuntu-24.04
-            python-version: "3.9"
+            python-version: "3.10"
     runs-on: ${{ matrix.platform }}
     steps:
       - uses: actions/checkout@v4.1.6
@@ -62,7 +62,7 @@ jobs:
     strategy:
       matrix:
         platform: [ubuntu-24.04]
-        python-version: ["3.9"]
+        python-version: ["3.10"]
     runs-on: ${{ matrix.platform }}
     steps:
     - uses: actions/checkout@v4.1.6
@@ -91,7 +91,7 @@ jobs:
     strategy:
       matrix:
         platform: [ ubuntu-24.04, macos-15-intel, macos-14, windows-latest ]
-        python-version: [ "3.9", "3.12" ]
+        python-version: [ "3.10", "3.12" ]
     runs-on: ${{ matrix.platform }}
     env:
       NUMBA_DISABLE_JIT: 1
@@ -300,8 +300,10 @@ jobs:
           rm /tmp/pytest/test_run_notebooks_*current
           ls /tmp/pytest/test_run_notebooks_*/
           ls /tmp/pytest/test_run_notebooks_*/output/
-          ffmpeg -i /tmp/pytest/test_run_notebooks_*/output/docs_intro_animation.ogv -loop 0 -vf "fps=10,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" $HOME/work/_temp/_github_home/figures/docs_intro_animation_${{ matrix.platform }}.gif
           mv /tmp/pytest/test_run_notebooks_*/output/last_animation_frame.pdf $HOME/work/_temp/_github_home/figures/last_animation_frame_${{ matrix.platform }}.pdf
+          for anim_name in docs_intro_animation parcel_animation; do
+              ffmpeg -i /tmp/pytest/test_run_notebooks_*/output/${anim_name}.ogv -loop 0 -vf "fps=10,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" $HOME/work/_temp/_github_home/figures/${anim_name}_${{ matrix.platform }}.gif
+          done
           ls $HOME/work/_temp/_github_home/figures
 
       - name: animation movie upload

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 3.0.0rc11
+Version: 3.0.0rc13
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only
@@ -33,7 +33,6 @@ Provides-Extra: unit-tests
 Requires-Dist: pytest; extra == "unit-tests"
 Requires-Dist: pytest-timeout; extra == "unit-tests"
 Requires-Dist: matplotlib!=3.9.1; extra == "unit-tests"
-Requires-Dist: Pillow<11.3.0; extra == "unit-tests"
 Provides-Extra: nonunit-tests
 Requires-Dist: pytest; extra == "nonunit-tests"
 Requires-Dist: PySDM-examples; extra == "nonunit-tests"

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/PySDM/backends/numba.py

@@ -7,6 +7,8 @@ import platform
 import warnings
 
 import numba
+from numba import prange
+import numpy as np
 
 from PySDM.backends.impl_numba import methods
 from PySDM.backends.impl_numba.random import Random as ImportedRandom
@@ -45,21 +47,43 @@ class Numba(  # pylint: disable=too-many-ancestors,duplicate-code
         self.formulae_flattened = self.formulae.flatten
 
         parallel_default = True
-        if platform.machine() == "arm64":
-            if "CI" not in os.environ:
-                warnings.warn(
-                    "Disabling Numba threading due to ARM64 CPU (atomics do not work yet)"
-                )
-            parallel_default = False  # TODO #1183 - atomics don't work on ARM64!
-
-        try:
-            numba.parfors.parfor.ensure_parallel_support()
-        except numba.core.errors.UnsupportedParforsError:
-            if "CI" not in os.environ:
-                warnings.warn(
-                    "Numba version used does not support parallel for (32 bits?)"
-                )
-            parallel_default = False
+
+        if override_jit_flags is not None and "parallel" in override_jit_flags:
+            parallel_default = override_jit_flags["parallel"]
+
+        if parallel_default:
+            if platform.machine() == "arm64":
+                if "CI" not in os.environ:
+                    warnings.warn(
+                        "Disabling Numba threading due to ARM64 CPU (atomics do not work yet)"
+                    )
+                parallel_default = False  # TODO #1183 - atomics don't work on ARM64!
+
+            try:
+                numba.parfors.parfor.ensure_parallel_support()
+            except numba.core.errors.UnsupportedParforsError:
+                if "CI" not in os.environ:
+                    warnings.warn(
+                        "Numba version used does not support parallel for (32 bits?)"
+                    )
+                parallel_default = False
+
+            if not numba.config.DISABLE_JIT:  # pylint: disable=no-member
+
+                @numba.jit(parallel=True, nopython=True)
+                def fill_array_with_thread_id(arr):
+                    """writes thread id to corresponding array element"""
+                    for i in prange(  # pylint: disable=not-an-iterable
+                        numba.get_num_threads()
+                    ):
+                        arr[i] = numba.get_thread_id()
+
+                fill_array_with_thread_id(arr := np.full(numba.get_num_threads(), -1))
+                if not max(arr) == arr[-1] == numba.get_num_threads() - 1:
+                    raise ValueError(
+                        "Numba threading enabled but does not work"
+                        " (try other setting of the NUMBA_THREADING_LAYER env var?)"
+                    )
 
         assert "fastmath" not in (override_jit_flags or {})
         self.default_jit_flags = {

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/PySDM/exporters/__init__.py

@@ -6,3 +6,4 @@ from .netcdf_exporter import NetCDFExporter
 from .netcdf_exporter_1d import NetCDFExporter_1d, readNetCDF_1d
 from .vtk_exporter import VTKExporter
 from .vtk_exporter_1d import VTKExporter_1d
+from .vtk_exporter_parcel import VTKExporterParcel

pysdm-3.0.0rc13/PySDM/exporters/vtk_exporter_parcel.py

@@ -0,0 +1,151 @@
+"""
+VTK Exporter for parcel PySDM simulations.
+
+This module defines `VTKExporterParcel`, a subclass of `PySDM.exporters.VTKExporter`,
+that writes simulation outputs to VTK format using `pyevtk`. It exports product
+profiles (e.g., relative humidity) as unstructured grids and particle attributes
+as point clouds, along with `.pvd` collection files for time-series visualization
+in ParaView.
+"""
+
+from pyevtk.hl import unstructuredGridToVTK, pointsToVTK
+from pyevtk.vtk import VtkHexahedron, VtkGroup
+import numpy as np
+
+from PySDM.exporters.vtk_exporter import VTKExporter
+
+
+# pylint: disable=too-many-instance-attributes
+class VTKExporterParcel(VTKExporter):
+    """
+    Custom VTK exporter for parcel PySDM, exporting products as grids
+    and attributes as point clouds for ParaView visualization.
+    """
+
+    def __init__(self, n_sd, output, mass_of_dry_air):
+        super().__init__()
+        self.output = output
+        self.coords = {
+            "x": np.random.random(n_sd),
+            "y": np.random.random(n_sd),
+            "z": np.random.random(n_sd),
+        }
+        self.half_diagonal = []
+        self.n_levels = len(self.output["products"]["z"])
+
+        volume = mass_of_dry_air / output["products"]["rhod"][0]
+        delta_z = output["products"]["z"][1] - output["products"]["z"][0]
+        for level in range(self.n_levels):
+            if level > 0:
+                prev_to_curr_density_ratio = (
+                    output["products"]["rhod"][level - 1]
+                    / output["products"]["rhod"][level]
+                )
+                volume *= prev_to_curr_density_ratio
+                delta_z = (
+                    output["products"]["z"][level] - output["products"]["z"][level - 1]
+                )
+            area = volume / delta_z
+            self.half_diagonal.append((2 * area) ** 0.5)
+
+    def write_pvd(self):
+        pvd_attributes = VtkGroup(self.attributes_file_path)
+        for key, value in self.exported_times["attributes"].items():
+            pvd_attributes.addFile(key + ".vtu", sim_time=value)
+        pvd_attributes.save()
+
+        pvd_products = VtkGroup(self.products_file_path)
+        for key, value in self.exported_times["products"].items():
+            pvd_products.addFile(key + ".vtu", sim_time=value)
+        pvd_products.save()
+
+    def export_products(
+        self, step, simulation
+    ):  # pylint: disable=arguments-differ, too-many-locals
+        path = self.products_file_path + "_num" + self.add_leading_zeros(step)
+        self.exported_times["products"][path] = step * simulation.particulator.dt
+
+        n_vertices = 4 * self.n_levels
+        x_vertices = np.zeros(n_vertices)
+        y_vertices = np.zeros(n_vertices)
+        z_vertices = np.zeros(n_vertices)
+        connectivity = [0, 1, 2, 3]
+        cell_type = np.zeros(self.n_levels - 1)
+        cell_type[:] = VtkHexahedron.tid
+
+        for level in range(self.n_levels):
+            half_diag = self.half_diagonal[level]
+            current_z = self.output["products"]["z"][level]
+            idx = level * 4
+            x_vertices[idx], y_vertices[idx], z_vertices[idx] = (
+                -half_diag,
+                -half_diag,
+                current_z,
+            )
+            idx += 1
+            x_vertices[idx], y_vertices[idx], z_vertices[idx] = (
+                -half_diag,
+                half_diag,
+                current_z,
+            )
+            idx += 1
+            x_vertices[idx], y_vertices[idx], z_vertices[idx] = (
+                half_diag,
+                half_diag,
+                current_z,
+            )
+            idx += 1
+            x_vertices[idx], y_vertices[idx], z_vertices[idx] = (
+                half_diag,
+                -half_diag,
+                current_z,
+            )
+            connectivity += [*range(4 * (level + 1), 4 * (level + 2))] * 2
+        connectivity = np.asarray(connectivity[:-4])
+        offset = np.asarray(range(8, 8 * self.n_levels, 8))
+
+        _ = {"test_pd": np.array([44] * n_vertices)}
+
+        relative_humidity = self.output["products"]["S_max_percent"]
+        cell_data = {
+            "RH": np.full(shape=(len(relative_humidity) - 1,), fill_value=np.nan)
+        }
+        cell_data["RH"][:step] = (
+            np.array(relative_humidity[:-1] + np.diff(relative_humidity) / 2)
+        )[:step]
+        unstructuredGridToVTK(
+            path,
+            x_vertices,
+            y_vertices,
+            z_vertices,
+            connectivity=connectivity,
+            offsets=offset,
+            cell_types=cell_type,
+            cellData=cell_data,
+        )
+
+    def export_attributes(self, step, simulation):  # pylint: disable=arguments-differ
+        path = self.attributes_file_path + "_num" + self.add_leading_zeros(step)
+        self.exported_times["attributes"][path] = step * simulation.particulator.dt
+
+        payload = {}
+
+        for key in self.output["attributes"].keys():
+            payload[key] = np.asarray(self.output["attributes"][key])[:, step].copy()
+        if step != 0:
+            delta_z = (
+                self.output["products"]["z"][step]
+                - self.output["products"]["z"][step - 1]
+            )
+            if step == 1:
+                self.coords["z"] *= delta_z
+            else:
+                self.coords["z"] += delta_z
+
+        pointsToVTK(
+            path,
+            2 * (self.coords["x"] - 0.5) * self.half_diagonal[step],
+            2 * (self.coords["y"] - 0.5) * self.half_diagonal[step],
+            self.coords["z"],
+            data=payload,
+        )

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/PySDM/products/aqueous_chemistry/aqueous_mole_fraction.py

@@ -22,11 +22,11 @@ class AqueousMoleFraction(MomentProduct):
         attr = "moles_" + self.key
 
         self._download_moment_to_buffer(attr=attr, rank=0)
-        conc = self.buffer.copy()
+        number = self.buffer.copy()
 
         self._download_moment_to_buffer(attr=attr, rank=1)
         tmp = self.buffer.copy()
-        tmp[:] *= conc
+        tmp[:] *= number
         tmp[:] *= DUMMY_SPECIFIC_GRAVITY * self.formulae.constants.Md
 
         self._download_to_buffer(self.particulator.environment["rhod"])

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/PySDM/products/size_spectral/cloud_water_content.py

@@ -33,8 +33,8 @@ class CloudWaterContent(MomentProduct):
             self._download_moment_to_buffer(
                 attr="water mass", rank=0, filter_range=(0, np.inf)
             )
-            conc = self.buffer
-            cwc += mass * conc / self.particulator.mesh.dv
+            number = self.buffer
+            cwc += mass * number / self.particulator.mesh.dv
 
         if self.ice:
             self._download_moment_to_buffer(
@@ -51,8 +51,8 @@ class CloudWaterContent(MomentProduct):
                 filter_range=(-np.inf, 0),
                 filter_attr="signed water mass",
             )
-            conc = self.buffer
-            cwc += mass * conc / self.particulator.mesh.dv
+            number = self.buffer
+            cwc += mass * number / self.particulator.mesh.dv
 
         if self.specific:
             self._download_to_buffer(self.particulator.environment["rhod"])

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/PySDM/products/size_spectral/water_mixing_ratio.py

@@ -31,7 +31,7 @@ class WaterMixingRatio(MomentProduct):
             filter_range=self.signed_mass_range,
             filter_attr="signed water mass",
         )
-        conc = self.buffer.copy()
+        number = self.buffer.copy()
 
         self._download_moment_to_buffer(
             attr="water mass",
@@ -40,7 +40,7 @@ class WaterMixingRatio(MomentProduct):
             filter_attr="signed water mass",
         )
         result = self.buffer.copy()
-        result[:] *= conc
+        result[:] *= number
         result[:] /= self.particulator.mesh.dv
 
         self._download_to_buffer(self.particulator.environment["rhod"])

{pysdm-3.0.0rc11 → pysdm-3.0.0rc13}/examples/PySDM_examples/Pyrcel/simulation.py

@@ -13,7 +13,13 @@ from PySDM.physics import si
 
 class Simulation(BasicSimulation):
     def __init__(
-        self, settings, products=None, scipy_solver=False, rtol_thd=1e-10, rtol_x=1e-10
+        self,
+        settings,
+        products=None,
+        scipy_solver=False,
+        rtol_thd=1e-10,
+        rtol_x=1e-10,
+        mass_of_dry_air=44 * si.kg,
     ):
         n_sd = sum(settings.n_sd_per_mode)
         builder = Builder(
@@ -27,7 +33,7 @@ class Simulation(BasicSimulation):
                 initial_water_vapour_mixing_ratio=settings.initial_vapour_mixing_ratio,
                 T0=settings.initial_temperature,
                 w=settings.vertical_velocity,
-                mass_of_dry_air=44 * si.kg,
+                mass_of_dry_air=mass_of_dry_air,
             ),
         )
         builder.add_dynamic(AmbientThermodynamics())

pysdm-3.0.0rc13/examples/PySDM_examples/Strzabala_2025_BEng/__init__.py

@@ -0,0 +1,8 @@
+# pylint: disable=invalid-name
+"""
+ParaView visualisation of a parcel-model example based on the test case from
+[Pyrcel package docs](https://pyrcel.readthedocs.io/)
+
+paraview_parcel_model.ipynb:
+.. include:: ./paraview.ipynb.badges.md
+"""

pysdm-3.0.0rc13/examples/PySDM_examples/Strzabala_2025_BEng/paraview.ipynb

@@ -0,0 +1,220 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ea16d42c",
+   "metadata": {},
+   "source": [
+    "[![preview notebook](https://img.shields.io/static/v1?label=render%20on&logo=github&color=87ce3e&message=GitHub)](https://github.com/open-atmos/PySDM/blob/main/examples/PySDM_examples/Strzabala_2025_BEng/paraview.ipynb)\n",
+    "[![launch on mybinder.org](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PySDM.git/main?urlpath=lab/tree/examples/PySDM_examples/Strzabala_2025_BEng/paraview.ipynb)\n",
+    "[![launch on Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PySDM/blob/main/examples/PySDM_examples/Strzabala_2025_BEng/paraview.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bdde4d45",
+   "metadata": {},
+   "source": [
+    "Runs a parcel simulation based on Pyrcel documentation setup, and demonstrates export to VTK and visualisation using Paraview\n",
+    "\n",
+    "(requires `pvpython` command in PATH)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1829d6ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "if 'google.colab' in sys.modules:\n",
+    "    !pip --quiet install open-atmos-jupyter-utils\n",
+    "    from open_atmos_jupyter_utils import pip_install_on_colab\n",
+    "    pip_install_on_colab('PySDM-examples')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6dcbcc6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import subprocess\n",
+    "import platform\n",
+    "import pathlib\n",
+    "from PySDM import Formulae\n",
+    "from PySDM.physics import si\n",
+    "from PySDM.initialisation.spectra import Lognormal\n",
+    "from PySDM.products import (\n",
+    "    ParcelDisplacement,\n",
+    "    AmbientTemperature,\n",
+    "    AmbientDryAirDensity,\n",
+    "    AmbientRelativeHumidity,\n",
+    "    ParticleSizeSpectrumPerVolume,\n",
+    "    ParticleVolumeVersusRadiusLogarithmSpectrum,\n",
+    ")\n",
+    "from PySDM.exporters import VTKExporterParcel\n",
+    "\n",
+    "from PySDM_examples.Pyrcel import Settings, Simulation\n",
+    "import PySDM_examples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cd6288b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "settings = Settings(\n",
+    "    dz=10 * si.m,\n",
+    "    n_sd_per_mode=(25, 25),\n",
+    "    aerosol_modes_by_kappa={\n",
+    "        0.54: Lognormal(\n",
+    "            norm_factor=850 / si.cm**3,\n",
+    "            m_mode=15 * si.nm,\n",
+    "            s_geom=1.6,\n",
+    "        ),\n",
+    "        1.2: Lognormal(\n",
+    "            norm_factor=10 / si.cm**3,\n",
+    "            m_mode=850 * si.nm,\n",
+    "            s_geom=1.2,\n",
+    "        ),\n",
+    "    },\n",
+    "    vertical_velocity=1.0 * si.m / si.s,\n",
+    "    initial_pressure=775 * si.mbar,\n",
+    "    initial_temperature=274 * si.K,\n",
+    "    initial_relative_humidity=0.90,\n",
+    "    displacement=1000 * si.m,\n",
+    "    formulae=Formulae(constants={\"MAC\": 0.3}),\n",
+    ")\n",
+    "\n",
+    "dry_radius_bin_edges = np.logspace(\n",
+    "    np.log10(1e-3 * si.um), np.log10(5e0 * si.um), 33, endpoint=False\n",
+    ")\n",
+    "\n",
+    "simulation = Simulation(\n",
+    "    settings,\n",
+    "    products=(\n",
+    "        ParcelDisplacement(name=\"z\"),\n",
+    "        AmbientRelativeHumidity(name=\"S_max_percent\", unit=\"%\", var=\"RH\"),\n",
+    "        AmbientTemperature(name=\"T\"),\n",
+    "        ParticleSizeSpectrumPerVolume(\n",
+    "            name=\"dry:dN/dR\", radius_bins_edges=dry_radius_bin_edges, dry=True\n",
+    "        ),\n",
+    "        ParticleVolumeVersusRadiusLogarithmSpectrum(\n",
+    "            name=\"dry:dV/dlnR\", radius_bins_edges=dry_radius_bin_edges, dry=True\n",
+    "        ),\n",
+    "        AmbientDryAirDensity(),\n",
+    "    ),\n",
+    "    mass_of_dry_air = 66666 * si.kg,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3ff50a25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output = simulation.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "15d59657",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "e = VTKExporterParcel(n_sd=simulation.particulator.n_sd, output=output, mass_of_dry_air=simulation.particulator.environment.mass_of_dry_air)\n",
+    "for step in settings.output_steps:\n",
+    "    e.export_products(step, simulation)\n",
+    "    e.export_attributes(step, simulation)\n",
+    "e.write_pvd()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a6ea0e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "product = pathlib.Path(\"./output/sd_products.pvd\").absolute()\n",
+    "attributes = pathlib.Path(\"./output/sd_attributes.pvd\").absolute()\n",
+    "\n",
+    "paraview_script = pathlib.Path(PySDM_examples.__file__).parent / 'Strzabala_2025_BEng' / \"paraview_parcel_model.py\"\n",
+    "\n",
+    "args = [\n",
+    "    \"pvpython\",\n",
+    "    \"--force-offscreen-rendering\",\n",
+    "    str(paraview_script),\n",
+    "    \"--sd-products-pvd\",\n",
+    "    str(product),\n",
+    "    \"--sd-attributes-pvd\",\n",
+    "    str(attributes),\n",
+    "    \"--output-animation-path\",\n",
+    "    str(pathlib.Path(\"./output/parcel_animation.ogv\").absolute()),\n",
+    "    \"--output-screenshot-path\",\n",
+    "    str(pathlib.Path(\"./output/last_frame.pdf\").absolute()),\n",
+    "]\n",
+    "result = subprocess.run(\n",
+    "    args,\n",
+    "    check=platform.system() != \"Windows\",\n",
+    "    capture_output=True,\n",
+    "    text=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e65c734-7012-4eff-8099-daa1119cb97d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "baea1aff-648f-41c0-b97b-4bf8f0b6de31",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d64ba1c-5eb9-4141-90a9-5a3da6ad7a71",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}