diff --git a/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb
new file mode 100644
index 000000000..5d1007c6c
--- /dev/null
+++ b/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb
@@ -0,0 +1,504 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "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/Barahona_and_Nenes_2007/fig_1.ipynb)\n",
+    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-atmos/PySDM.git/main?urlpath=lab/tree/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb)\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-atmos/PySDM/blob/main/examples/PySDM_examples/Barahona_and_Nenes_2007/fig_1.ipynb)"
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Fig. 1 from [Barahona and Nenes 2007](https://doi.org/10.1029/2007JD008473) using [Lee & Pruppacher 1977](https://doi.org/10.1007/BF00876119) entraining parcel model implemented without dependence on PySDM, and with Pint dimensional analysis checks.\n",
+    "\n",
+    "TODO #1433:\n",
+    "- use DimensionalAnalysis context manager to check units only once, and skip units checks for integration\n",
+    "- switch from integration in mass \"m\" to integration in \"ln(r)\" or alike ... or to \"r\" to be closer to the paper\n",
+    "- rho in System: total pressure, but dry air R. (a good approximation)\n"
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.127318Z",
+     "start_time": "2024-12-03T13:46:36.097786Z"
+    }
+   },
+   "cell_type": "code",
+   "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')"
+   ],
+   "outputs": [],
+   "execution_count": 10
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "_KYH2YCDF4CF",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.588674Z",
+     "start_time": "2024-12-03T13:46:36.132140Z"
+    }
+   },
+   "source": [
+    "import numpy as np\n",
+    "import pint\n",
+    "from matplotlib import pyplot\n",
+    "import scipy\n",
+    "import functools\n",
+    "from scipy import constants\n",
+    "from chempy import Substance\n",
+    "    \n",
+    "si = pint.UnitRegistry()\n",
+    "si.setup_matplotlib()\n",
+    "si.define('fraction = [] = frac')\n",
+    "si.define('percent = 1e-2 frac = pct')"
+   ],
+   "outputs": [],
+   "execution_count": 11
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "3Gd21_5yF4CG",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.608277Z",
+     "start_time": "2024-12-03T13:46:36.601776Z"
+    }
+   },
+   "source": [
+    "class Constants:\n",
+    "    # polynomial fot to equilibrium vapour pressure wrt water (coefficients from Flatau et al. 1992)\n",
+    "    # doi:10.1175/1520-0450(1992)031<1507%3APFTSVP>2.0.CO%3B2\n",
+    "    c_w = (6.115836990e000, 0.444606896e000, 0.143177157e-01, 0.264224321e-03, 0.299291081e-05,\n",
+    "           0.203154182e-07, 0.702620698e-10, 0.379534310e-13, -.321582393e-15)\n",
+    "\n",
+    "    T0 = constants.zero_Celsius * si.kelvin\n",
+    "\n",
+    "    def __molar_mass(x):\n",
+    "        return Substance.from_formula(x).mass * si.gram / si.mole\n",
+    "\n",
+    "    M_a = (\n",
+    "        0.78 * __molar_mass(\"N2\") +\n",
+    "        0.21 * __molar_mass(\"O2\") +\n",
+    "        0.01 * __molar_mass(\"Ar\")\n",
+    "    )\n",
+    "    M_v = __molar_mass(\"O\") + __molar_mass(\"H\") * 2\n",
+    "\n",
+    "    R_str = constants.R * si.joule / si.kelvin / si.mole\n",
+    "\n",
+    "    R_a = R_str / M_a\n",
+    "    R_v = R_str / M_v\n",
+    "\n",
+    "    g = constants.g * si.metre / si.second**2\n",
+    "\n",
+    "    l_v = 2.5e6 * si.joule / si.kilogram\n",
+    "    c_p  = 1000 * si.joule / si.kilogram / si.kelvin\n",
+    "\n",
+    "    D = 2.26e-5 * si.metre ** 2 / si.second\n",
+    "    K = 2.4e-2 * si.joules / si.metres / si.seconds / si.kelvins\n",
+    "    rho_w = 1 * si.kilogram / si.litre\n",
+    "    sigma_w = 0.072 * si.joule / si.metre**2\n",
+    "\n",
+    "    epsilon = R_a/R_v"
+   ],
+   "outputs": [],
+   "execution_count": 12
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "vlM1J4LZF4CG",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.619675Z",
+     "start_time": "2024-12-03T13:46:36.615186Z"
+    }
+   },
+   "source": [
+    "class Formulae:\n",
+    "    @staticmethod\n",
+    "    def rho(p, R, T):\n",
+    "        return p / (R * T)\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def __p_sat(temperature, coefficients, valid_range):\n",
+    "        from numpy.polynomial.polynomial import polyval\n",
+    "\n",
+    "        value = polyval(temperature.to(si.celsius).magnitude, coefficients)\n",
+    "\n",
+    "        if isinstance(temperature.magnitude, np.ndarray):\n",
+    "            value[np.logical_or(temperature < valid_range[0], temperature > valid_range[1])] = np.nan\n",
+    "        else:\n",
+    "            value = np.nan if not valid_range[0] < temperature <= valid_range[1] else value\n",
+    "\n",
+    "        return value * si.hectopascals\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def p_eq(T):\n",
+    "        return Formulae.__p_sat(T, Constants.c_w, (Constants.T0-85 * si.kelvin, np.inf * si.kelvin))\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def r_dr_dt(S_eq, T, S, rho_eq):\n",
+    "        return (\n",
+    "            (S - S_eq)\n",
+    "            / Constants.rho_w\n",
+    "            / (1 / rho_eq / Constants.D  + Constants.l_v**2 / Constants.K / T**2 / Constants.R_v)\n",
+    "        )\n",
+    "    \n",
+    "    @staticmethod\n",
+    "    def S_eq(drop_radius, kappa, a_dry_3, T):\n",
+    "      return (\n",
+    "          np.exp((2 * Constants.sigma_w / Constants.R_v / T / Constants.rho_w) / drop_radius)\n",
+    "          * (drop_radius**3 - a_dry_3)\n",
+    "          / (drop_radius**3 - a_dry_3 * (1 - kappa))\n",
+    "          ) - 1\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def r_cr(kp, a_dry_3, T, sgm): # from https://github.com/open-atmos/PySDM/blob/main/PySDM/physics/hygroscopicity/kappa_koehler.py\n",
+    "        return np.sqrt(3 * kp * a_dry_3 / (2 * sgm / Constants.R_v / T / Constants.rho_w))\n"
+   ],
+   "outputs": [],
+   "execution_count": 13
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "EaiiPI4TF4CH",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.630871Z",
+     "start_time": "2024-12-03T13:46:36.625974Z"
+    }
+   },
+   "source": [
+    "class Storage:\n",
+    "    \"\"\" state vector representation with each element having its own Pint-compatible\n",
+    "    physical dimension, thus allowing to seamlessly couple Pint and scipy.odeint\n",
+    "    (assumes the last variable extends till the end of the state vector;\n",
+    "    all methods return objects that inherit from `numpy.ndarray` but are additionally\n",
+    "    equipped with .VAR unit-aware setters and getters, allowing both unit-anaware\n",
+    "    whole-array expressions (e.g., `state += dt * deriv`) as well as unit-aware\n",
+    "    operations on state vars (e.g., `state.T = 300 * si.K` or `state.m[:] = ...`) \"\"\"\n",
+    "\n",
+    "    var_units = {\n",
+    "        'p': si.Pa,\n",
+    "        'T': si.K,\n",
+    "        'parcel_radius': si.m,\n",
+    "        'supersaturation': si.dimensionless,\n",
+    "        'w_v': si.dimensionless,\n",
+    "        'n': si.dimensionless,\n",
+    "        'm': si.kg\n",
+    "    }\n",
+    "\n",
+    "    der_unit = si.metre\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def __make_storage(shape, deriv=False):\n",
+    "        def getter(self, idx, unit):\n",
+    "            return self[idx] * unit\n",
+    "\n",
+    "        def setter(self, value, idx, unit):\n",
+    "            self[idx] = (value.to(unit) / unit).magnitude\n",
+    "\n",
+    "        properties = {'z_unit': Storage.der_unit}\n",
+    "        for i, key in enumerate(Storage.var_units.keys()):\n",
+    "            kwargs = {\n",
+    "                'unit': Storage.var_units[key] / (Storage.der_unit if deriv else 1),\n",
+    "                'idx': i if i + 1 != len(Storage.var_units) else slice(i, None)\n",
+    "            }\n",
+    "            properties[key] = property(\n",
+    "                functools.partial(getter, **kwargs),\n",
+    "                functools.partial(setter, **kwargs),\n",
+    "            )\n",
+    "\n",
+    "        return type(\"StorageImpl\", (np.ndarray,), properties)(shape)\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def make_state(n_particles):\n",
+    "        \"\"\" returns a newly allocated unit-aware storage of size relevant for `n_particles` simulation \"\"\"\n",
+    "        return Storage.__make_storage((len(Storage.var_units) - 1 + n_particles,))\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def make_deriv(state):\n",
+    "        \"\"\" returns a newly allocated unit-aware storage with size of `state` and derivative dimensions \"\"\"\n",
+    "        return Storage.__make_storage(state.shape, deriv=True)\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def view_state(array):\n",
+    "        \"\"\" returns a newly allocated unit-aware storage with size and data from unit-unaware `array` \"\"\"\n",
+    "        storage = Storage.__make_storage(array.shape)\n",
+    "        storage[:] = array[:]\n",
+    "        return storage"
+   ],
+   "outputs": [],
+   "execution_count": 14
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "nLBfqaJ8F4CI",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.645769Z",
+     "start_time": "2024-12-03T13:46:36.638213Z"
+    }
+   },
+   "source": [
+    "class System:\n",
+    "    def __init__(self, *, w, ent_Tdiff, ent_RH, ent_mu, ent_n, r_dry, kappa):\n",
+    "        self.w = w\n",
+    "        self.ent_mu = ent_mu\n",
+    "        self.ent_Tdiff = ent_Tdiff\n",
+    "        self.ent_RH = ent_RH\n",
+    "        self.a_dry_3 = r_dry**3\n",
+    "        self.kappa = kappa\n",
+    "        self.ent_n = ent_n\n",
+    "\n",
+    "    def __call__(self, _, state):\n",
+    "        state = Storage.view_state(state)\n",
+    "        deriv = Storage.make_deriv(state)\n",
+    "\n",
+    "        #(8)\n",
+    "        deriv.parcel_radius = state.parcel_radius * self.ent_mu / 2 #rough appox of eq.8 to get things working (assumes constant updraft and negligible variability in dry air density)\n",
+    "\n",
+    "        rho = Formulae.rho(state.p, Constants.R_a, state.T) \n",
+    "\n",
+    "        # eq. (4)\n",
+    "        deriv.p = -rho * Constants.g\n",
+    "\n",
+    "        # eq. (12) PER DROPLET (implied loop)\n",
+    "        drop_radius = (3*state.m/4/np.pi/Constants.rho_w)**(1/3)\n",
+    "        rho_eq = Formulae.p_eq(state.T) / Constants.R_v / state.T\n",
+    "        deriv.m = 4 * np.pi * Constants.rho_w * drop_radius * Formulae.r_dr_dt(\n",
+    "            Formulae.S_eq(drop_radius,self.kappa,self.a_dry_3,state.T), state.T, state.supersaturation, rho_eq\n",
+    "        ) / self.w\n",
+    "\n",
+    "        # eq. (5)\n",
+    "        volume = (4/3)*np.pi*state.parcel_radius**3 # new total volume, as we are evolving R with bubble expansion\n",
+    "        total_mass = rho * volume\n",
+    "        dwl_dz = np.sum(deriv.m * state.n)/total_mass\n",
+    "\n",
+    "        env_T = state.T - self.ent_Tdiff\n",
+    "        env_pv = self.ent_RH * Formulae.p_eq(env_T)\n",
+    "        env_w_v = Formulae.rho(env_pv, Constants.R_v, env_T) / rho # to keep a constant relative humidity following conditions of BarahonaNenes2007\n",
+    "\n",
+    "        # eq. (2)\n",
+    "        deriv.w_v = - dwl_dz - self.ent_mu * (state.w_v - env_w_v + np.sum(state.m * state.n)/rho/volume)\n",
+    "\n",
+    "        # eq. (1)\n",
+    "        deriv.T = (deriv.p/rho - deriv.w_v * Constants.l_v) / Constants.c_p + \\\n",
+    "            - self.ent_mu * ( (Constants.l_v/Constants.c_p)*(state.w_v-env_w_v) + (state.T-env_T) )\n",
+    "\n",
+    "        #(3)\n",
+    "        deriv.supersaturation = state.p/(Constants.epsilon*Formulae.p_eq(state.T)) * deriv.w_v \\\n",
+    "            - (1+state.supersaturation)*(\n",
+    "                (Constants.epsilon*Constants.l_v/(Constants.R_a*state.T**2))*deriv.T +\n",
+    "                (Constants.g/(Constants.R_a*state.T))\n",
+    "            )\n",
+    "\n",
+    "        #(6)\n",
+    "        deriv.n = -self.ent_mu * (state.n - self.ent_n)\n",
+    "\n",
+    "        return deriv"
+   ],
+   "outputs": [],
+   "execution_count": 15
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "g4iCJUjOF4CI",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:46:36.656940Z",
+     "start_time": "2024-12-03T13:46:36.654273Z"
+    }
+   },
+   "source": [
+    "from scipy import integrate\n",
+    "def solve(system, state, displacement):\n",
+    "    integ = integrate.solve_ivp(\n",
+    "        system,\n",
+    "        [0, displacement / state.z_unit],\n",
+    "        state,\n",
+    "        max_step=(.1 * si.metre / state.z_unit).magnitude,\n",
+    "        method='LSODA'\n",
+    "    )\n",
+    "    assert integ.success, integ.message\n",
+    "    return Storage.view_state(integ.y), integ.t * state.z_unit"
+   ],
+   "outputs": [],
+   "execution_count": 16
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "id": "LFFo1xrUF4CI",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:47:21.983842Z",
+     "start_time": "2024-12-03T13:46:36.665326Z"
+    }
+   },
+   "source": [
+    "n_size_sections = 10\n",
+    "T0 = 300 * si.kelvins\n",
+    "p0 = 1000 * si.hectopascals\n",
+    "s0 = -0.01 * si.dimensionless\n",
+    "w = 5 * si.meter / si.second\n",
+    "\n",
+    "pv0 = (1 + s0) * Formulae.p_eq(T0)\n",
+    "displacement = 250 * si.metres\n",
+    "R0 = 350 * si.metres\n",
+    "volume = 4/3 * np.pi * R0**3\n",
+    "w_v0 = Constants.epsilon / (p0/pv0 - 1)\n",
+    "\n",
+    "# entrainment parameters\n",
+    "ent_mu = 0 / si.meter\n",
+    "ent_Tdiff = 0.3 * si.kelvin # T-T'\n",
+    "ent_RH = 0.9 * si.dimensionless #relative humidity\n",
+    "ent_n = 0.0 * si.dimensionless\n",
+    "\n",
+    "kappa = 1.2\n",
+    "geometric_stdev = 1.3\n",
+    "median_dry_radius = 1 * si.um\n",
+    "aerosol_concentration = 50 / si.centimetre**3\n",
+    "\n",
+    "dry_radii_quantiles = scipy.stats.lognorm(\n",
+    "    np.log(geometric_stdev),\n",
+    "    0,\n",
+    "    median_dry_radius.to(si.m).magnitude\n",
+    ").ppf(\n",
+    "    np.linspace(0, 1, 2 * n_size_sections + 1)[1:-1:2]\n",
+    ") * si.m\n",
+    "\n",
+    "wet_radii_quantiles = np.asarray([scipy.optimize.root_scalar(\n",
+    "    f=lambda r: s0 - Formulae.S_eq(r*si.m, kappa, r_dry**3, T0),\n",
+    "    bracket=(\n",
+    "        r_dry.to(si.m).magnitude,\n",
+    "        Formulae.r_cr(kappa, r_dry**3, T0, Constants.sigma_w).to(si.m).magnitude\n",
+    "    )\n",
+    ").root for r_dry in dry_radii_quantiles]) * si.m\n",
+    "\n",
+    "systems = {}\n",
+    "solutions = {}\n",
+    "zsteps = {}\n",
+    "\n",
+    "def e_c(RH, T, Tp):\n",
+    "    \"\"\"Equation 23b from Barahona & Nenes 2007\"\"\"\n",
+    "    alpha = Constants.g * Constants.M_v * Constants.l_v / Constants.c_p / Constants.R_str / (T**2) \\\n",
+    "        - Constants.g * Constants.M_a / Constants.R_str / T\n",
+    "    return alpha / ((1-RH) - Constants.l_v * Constants.M_v / Constants.R_str / (T**2) * (T - Tp))\n",
+    "\n",
+    "for mu in [0.0 * si.metre**-1, e_c(RH = 1 + s0, T = T0, Tp = T0 - ent_Tdiff)]:\n",
+    "    state = Storage.make_state(n_size_sections)\n",
+    "    state.p = p0\n",
+    "    state.T = T0\n",
+    "    state.n = aerosol_concentration * volume / n_size_sections\n",
+    "    state.m = 4/3 * np.pi * Constants.rho_w * wet_radii_quantiles**3\n",
+    "    state.supersaturation = s0\n",
+    "    state.parcel_radius = R0\n",
+    "    state.w_v = w_v0\n",
+    "\n",
+    "    systems[mu] = System(w=w, ent_mu=mu, ent_Tdiff=ent_Tdiff, ent_RH=ent_RH, ent_n=ent_n, r_dry=dry_radii_quantiles, kappa=kappa)\n",
+    "    solutions[mu], zsteps[mu] = solve(systems[mu], state, displacement)"
+   ],
+   "outputs": [],
+   "execution_count": 17
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 410
+    },
+    "id": "T1lffCOOF4CK",
+    "outputId": "29fd460d-a17a-4a2d-9a6d-d515fc1ac6cb",
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:47:22.266670Z",
+     "start_time": "2024-12-03T13:47:22.028365Z"
+    }
+   },
+   "source": [
+    "fig, axs = pyplot.subplots(3, 1, sharex=True, figsize=(5, 12))\n",
+    "\n",
+    "for mu in solutions.keys():\n",
+    "    sys = systems[mu]\n",
+    "    sol = solutions[mu]\n",
+    "    t = zsteps[mu] / w\n",
+    "\n",
+    "    axs[0].plot(t, sol.supersaturation, label=mu)\n",
+    "    axs[0].yaxis.set_units(si.percent)\n",
+    "    \n",
+    "    axs[1].plot(t, np.mean(sol.m, axis=0), label=mu)\n",
+    "    axs[1].yaxis.set_units(si.micrograms)\n",
+    "\n",
+    "    axs[2].plot(t, sol.w_v, label=mu)\n",
+    "    axs[2].yaxis.set_units(si.grams / si.kilogram)\n",
+    "    break\n",
+    "    \n",
+    "for i in range(len(axs)):\n",
+    "    axs[i].legend(loc='upper left')\n",
+    "    axs[i].grid()\n",
+    "_ = axs[0].set_title('Supersaturation [%]')\n",
+    "_ = axs[1].set_title('Average drop mass')\n",
+    "_ = axs[2].set_title('vapour mixing ratio [g/kg]')"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 500x1200 with 3 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 18
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-12-03T13:47:22.276829Z",
+     "start_time": "2024-12-03T13:47:22.275583Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "",
+   "outputs": [],
+   "execution_count": null
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": [],
+   "include_colab_link": true
+  },
+  "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": 0
+}