smartg 2.0.2__tar.gz → 2.0.3__tar.gz

{smartg-2.0.2/smartg.egg-info → smartg-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartg
-Version: 2.0.2
+Version: 2.0.3
 Summary: SMART-G (Speed-up Monte Carlo Advanced Radiative Transfer Code using GPU) is a radiative transfer code using a Monte-Carlo technique to simulate the propagation of the polarized light in the atmosphere and/or ocean, and using GPU acceleration.
 Author-email: Mustapha Moulana <mm@hygeos.com>, Didier Ramon <dr@hygeos.com>, François Steinmetz <fs@hygeos.com>, Dominique Jolivet <dj@hygeos.com>, Mathieu Compiègne <mc@hygeos.com>
 Project-URL: Source, https://github.com/hygeos/smartg
@@ -326,6 +326,11 @@ environment. Without them it skips itself with a message rather than
 failing, so run it with `pixi run -e extra pytest
 smartg/tests/test_smartg_jax.py`.
 
+`test_jax_context.py` needs JAX on a GPU, in the same environment, and
+a pytest process of its own: `test_smartg_jax.py` keeps JAX on the CPU
+for the whole process, and the test then skips itself. Run it with
+`pixi run -e extra pytest smartg/tests/test_jax_context.py`.
+
 To avoid repeating some pytest arguments, a `pytest.ini` file can be created at the root of the project. The following is an example of the contents of such a file:
 
 ```

{smartg-2.0.2 → smartg-2.0.3}/README.md

@@ -275,6 +275,11 @@ environment. Without them it skips itself with a message rather than
 failing, so run it with `pixi run -e extra pytest
 smartg/tests/test_smartg_jax.py`.
 
+`test_jax_context.py` needs JAX on a GPU, in the same environment, and
+a pytest process of its own: `test_smartg_jax.py` keeps JAX on the CPU
+for the whole process, and the test then skips itself. Run it with
+`pixi run -e extra pytest smartg/tests/test_jax_context.py`.
+
 To avoid repeating some pytest arguments, a `pytest.ini` file can be created at the root of the project. The following is an example of the contents of such a file:
 
 ```

{smartg-2.0.2 → smartg-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=61"]
 
 [project]
 name = "smartg"
-version = "2.0.2"
+version = "2.0.3"
 description = """
 SMART-G (Speed-up Monte Carlo Advanced Radiative Transfer Code using GPU) is a radiative \
 transfer code using a Monte-Carlo technique to simulate the propagation of the polarized \

{smartg-2.0.2 → smartg-2.0.3}/smartg/smartg.py

@@ -32,6 +32,8 @@ reduce_diff
     Post-process ALIS finite-difference runs into sensitivities.
 """
 
+import atexit
+import functools
 import os
 import subprocess
 import tempfile
@@ -402,7 +404,7 @@ class Alis:
     """
     The options of the ALIS method, for Smartg.run.
 
-    ALIS (Emde et al. 2010) computes the spectrum of a whole band from
+    ALIS (Emde et al. 2011) computes the spectrum of a whole band from
     a single set of photon paths, by weighting each path with the
     absorption of every wavelength. The Smartg object must have been
     compiled with alis=True, together with alt_pp=True or pp=False.
@@ -850,6 +852,122 @@ class LocalEstimate:
         )
 
 
+# The CUDA contexts that clear_context destroyed, kept referenced so
+# that no new context takes the place of one of them. The Smartg objects
+# of a process share the context of pycuda.autoinit: once one of them
+# clears it, the others must not make it current again, which crashes
+# the driver.
+_RELEASED_CONTEXTS: list[Any] = []
+
+
+def _released(ctx: Any) -> bool:
+    """Return whether ctx is a context that clear_context destroyed."""
+    return any(c is ctx for c in _RELEASED_CONTEXTS)
+
+
+def _make_current(ctx: Any) -> bool:
+    """Make the CUDA context ctx the current one, if it is not.
+
+    Another library of the process (JAX for instance) may have made its
+    own context current, where the kernels of SMART-G are unknown
+    ('invalid resource handle'). Returns True if ctx was pushed, to be
+    popped by the caller. Raises a RuntimeError if ctx was destroyed by
+    the clear_context of another Smartg object that shared it.
+    """
+    if ctx is None:
+        return False
+    if _released(ctx):
+        raise RuntimeError(
+            'The CUDA context of this Smartg object was destroyed by the '
+            'clear_context of another Smartg object that shared it: '
+            'create a new Smartg object.')
+    # PyCUDA only knows the contexts it pushed itself: ask the driver
+    if _driver_current_context() == ctx.handle:
+        return False
+    ctx.push()
+    return True
+
+
+def _autoinit_current_at_exit(sg: 'Smartg') -> None:
+    """At exit, make the pycuda.autoinit context of sg current again.
+
+    The exit handler of pycuda.autoinit pops its context, which fails
+    ('cannot pop non-current context') if another library (JAX) made
+    its own context current in the meantime.
+    """
+    import sys
+    mod = sys.modules.get('pycuda.autoinit')
+    if (sg.ctx is None or _released(sg.ctx) or mod is None
+            or getattr(mod, 'context', None) is not sg.ctx):
+        return
+    # set it current at the driver level: pushing it would leave it
+    # twice on the stack of PyCUDA, which aborts at the module cleanup
+    if _driver_current_context() == sg.ctx.handle:
+        return
+    try:
+        import ctypes
+        for name in ('libcuda.so.1', 'libcuda.so', 'nvcuda.dll'):
+            try:
+                set_current = ctypes.CDLL(name).cuCtxSetCurrent
+                break
+            except (OSError, AttributeError):
+                continue
+        else:
+            return
+        set_current(ctypes.c_void_p(sg.ctx.handle))
+    # an exit handler must not raise: the one of pycuda.autoinit, which
+    # runs next, reports a context that is still not current
+    except Exception:  # noqa: BLE001, S110
+        pass
+
+
+def _driver_current_context() -> int | None:
+    """Handle of the current CUDA context of the driver, or None."""
+    global _CU_CTX_GET_CURRENT
+    if _CU_CTX_GET_CURRENT is None:
+        import ctypes
+        import ctypes.util
+        names = ('libcuda.so.1', 'libcuda.so', 'nvcuda.dll',
+                 ctypes.util.find_library('cuda'))
+        for name in names:
+            if not name:
+                continue
+            try:
+                _CU_CTX_GET_CURRENT = ctypes.CDLL(name).cuCtxGetCurrent
+                break
+            except (OSError, AttributeError):
+                continue
+        else:
+            _CU_CTX_GET_CURRENT = False
+    if not _CU_CTX_GET_CURRENT:
+        return None
+    import ctypes
+    handle = ctypes.c_void_p()
+    if _CU_CTX_GET_CURRENT(ctypes.byref(handle)) != 0:
+        return None
+    return handle.value
+
+
+_CU_CTX_GET_CURRENT = None
+
+
+def _in_context(method: Callable[..., Any]) -> Callable[..., Any]:
+    """Run a method of Smartg with its CUDA context current."""
+
+    @functools.wraps(method)
+    def wrapper(self: 'Smartg', *args: Any, **kwargs: Any) -> Any:
+        pushed = _make_current(self.ctx)
+        try:
+            return method(self, *args, **kwargs)
+        finally:
+            # run may have popped and released the context itself
+            # (autoinit=False, keep_context=False)
+            if pushed and self.ctx is not None:
+                cuda.Context.pop()  # pyright: ignore[reportAttributeAccessIssue]
+
+    return wrapper
+
+
 class Smartg:
     """Initialize the Smartg object.
 
@@ -872,7 +990,7 @@ class Smartg:
     double : bool, optional
         Accumulate photons table in double precision (default double).
     alis : bool, optional
-        Use the ALIS method (Emde et al. 2010) for treating gaseous
+        Use the ALIS method (Emde et al. 2011) for treating gaseous
         absorption and perturbed profile. Needs alt_pp=True or
         pp=False. The 3D objects are not available with it.
     back : bool, optional
@@ -906,7 +1024,8 @@ class Smartg:
         Include the Sun Induced Fluorescence, an experimental option.
         Needs alis=True, together with alt_pp=True or pp=False.
     thermal : bool, optional
-        Still in dev...
+        Still in dev... The forward mode (back=False) needs alt_pp=True
+        in the plane parallel geometry.
     rng : str, optional
         The pseudo-random number generator to use, only 2 choice:
         - PHILOX
@@ -1027,6 +1146,13 @@ class Smartg:
                 "geometry (pp=True): the spherical move does not follow "
                 "its cells"
             )
+        if thermal and not back and pp and not alt_pp:
+            raise ValueError(
+                "The forward thermal emission (thermal=True, back=False) "
+                "needs alt_pp=True in the plane parallel geometry: the "
+                "fast move does not start the emitted photons at their "
+                "altitude"
+            )
 
         if device is not None:
             env_modif = {'CUDA_DEVICE': str(device)}
@@ -1091,6 +1217,10 @@ class Smartg:
                 self.ctx = make_default_context()
 
         self.autoinit = autoinit
+        if autoinit:
+            # registered after the exit handler of pycuda.autoinit, so
+            # run before it: its context must be current to be popped
+            atexit.register(_autoinit_current_at_exit, self)
         self.pp = pp
         self.double = double
         self.alis = alis
@@ -1197,6 +1327,9 @@ class Smartg:
             # 3D Object mode
             options.append('-DOBJ3D')
         options.append('-D' + rng)
+        # CUDA 13 deprecates double4 (warning 1444) for double4_16a and
+        # double4_32a, which older toolkits lack
+        options.append('-diag-suppress=1444')
         # options.append('-lineinfo')
 
         #
@@ -1208,23 +1341,29 @@ class Smartg:
         with open(SRC_DEVICE, encoding='ascii', errors='ignore') as f:
             src_device_content = f.read()
 
-        # kernel compilation
-        self.mod = SourceModule(
-            src_device_content,
-            nvcc='nvcc',
-            options=options,
-            no_extern_c=True,
-            cache_dir=str(cache_dir),
-            include_dirs=[
-                str(DIR_SRC),
-                str(DIR_SRC / 'incRNGs' / 'Random123'),
-            ],
-        )
+        # kernel compilation, in the context of this object (another
+        # library may have made its own context current)
+        pushed = _make_current(self.ctx)
+        try:
+            self.mod = SourceModule(
+                src_device_content,
+                nvcc='nvcc',
+                options=options,
+                no_extern_c=True,
+                cache_dir=str(cache_dir),
+                include_dirs=[
+                    str(DIR_SRC),
+                    str(DIR_SRC / 'incRNGs' / 'Random123'),
+                ],
+            )
 
-        # load the kernel
-        self.kernel = self.mod.get_function('launchKernel')
-        # self.kernel2 = self.mod.get_function('launchKernel2')
-        self.kernel2 = self.mod.get_function('reduce_absorption_gpu')
+            # load the kernel
+            self.kernel = self.mod.get_function('launchKernel')
+            # self.kernel2 = self.mod.get_function('launchKernel2')
+            self.kernel2 = self.mod.get_function('reduce_absorption_gpu')
+        finally:
+            if pushed:
+                cuda.Context.pop()  # pyright: ignore[reportAttributeAccessIssue]
 
         #
         # common attributes
@@ -1280,25 +1419,34 @@ class Smartg:
         Notes
         -----
         Once this method has been called, the run method can no longer
-        be used: the Smartg object must be reinitialized.
+        be used: the Smartg object must be reinitialized. The Smartg
+        objects with autoinit share one context: once one of them has
+        cleared it, the others can no longer run, and their own
+        clear_context only prints that there is no context to clear.
         """
         try:
             assert self.ctx is not None
+            # another library (JAX) may have made its context current
+            _make_current(self.ctx)
             self.ctx.pop()
             self.ctx.detach()
+            _RELEASED_CONTEXTS.append(self.ctx)
             self.ctx = None
             from pycuda.tools import clear_context_caches
 
             clear_context_caches()
             if self.autoinit:
-                # In case of autoinit delete pycuda.autoinit
+                # With autoinit, delete pycuda.autoinit and its exit
+                # handler, which would pop the destroyed context
                 import pycuda.autoinit
 
+                atexit.unregister(pycuda.autoinit._finish_up)
                 del pycuda.autoinit
         # pycuda's own error classes again, nothing else to do here
         except Exception:  # noqa: BLE001
             print("There is no current context to clear.")
 
+    @_in_context
     def run(
         self,
         wavelength: NumericArrayLike | BandSet | Sequence[BandLike],

{smartg-2.0.2 → smartg-2.0.3}/smartg/src/device.cu

@@ -3529,7 +3529,9 @@ __device__ void move_pp2(Photon* ph, struct Profile *prof_atm, struct Profile *p
             h_cur    = coef_cur * intTime1;
 
             #ifndef ALIS
-            h_cur_abs = prof[cell[ph->layer].iabs+ilam].OD_abs * intTime1;
+            // the absorption of the cell: gases of the level, and the
+            // particles of a 3D component (its own optical properties)
+            h_cur_abs = prof[cell[ph->layer].iopt+ilam].OD_abs * intTime1;
             #endif
 
             //
@@ -3552,7 +3554,12 @@ __device__ void move_pp2(Photon* ph, struct Profile *prof_atm, struct Profile *p
                 for (int k=0; k<NLOWd; k++)
                 {
                     coef = get_OD(1,prof[cell[ph->layer].iopt + k*DL*NL]);
-			        ph->weight_sca[k] *= exp(-(coef-coef_cur)*intTime1);
+                    // the absorption of the particles of a 3D component,
+                    // smooth in wavelength, goes with the weights at the
+                    // nodes; that of the gases with the distances
+                    const float dabs = fmaxf(prof[cell[ph->layer].iopt + k*DL*NL].OD_abs
+                                             - prof[cell[ph->layer].iabs + k*DL*NL].OD_abs, 0.F);
+			        ph->weight_sca[k] *= exp(-(coef-coef_cur+dabs)*intTime1);
                 }
                 #endif
                 break;
@@ -3579,7 +3586,9 @@ __device__ void move_pp2(Photon* ph, struct Profile *prof_atm, struct Profile *p
                 for (int k=0; k<NLOWd; k++)
                 {
                     coef = get_OD(1,prof[cell[ph->layer].iopt + k*DL*NL]);
-			        ph->weight_sca[k] *= __expf(-(coef-coef_cur)*intTime1);
+                    const float dabs = fmaxf(prof[cell[ph->layer].iopt + k*DL*NL].OD_abs
+                                             - prof[cell[ph->layer].iabs + k*DL*NL].OD_abs, 0.F);
+			        ph->weight_sca[k] *= __expf(-(coef-coef_cur+dabs)*intTime1);
                 }
                 #endif
 
@@ -4923,11 +4932,13 @@ __device__ void surfaceWaterRough(Photon* ph, int le,
 
      // A refraction crosses the facet: the incident and the refracted
      // directions both go against its normal, else the photon would
-     // reach the facet from behind and there is no transmission
+     // reach the facet from behind and there is no transmission. The
+     // virtual photon is removed rather than given a null weight, which
+     // the counts of photons (N_*) took for a photon
      if (((ph->loc==SURF0P) && (count_level==DOWN0M) ||
           (ph->loc==SURF0M) && (count_level==UP0P)) &&
          ((dot(no, ph->v) >= 0.F) || (dot(no, v) >= 0.F))) {
-         ph->weight = 0.;
+         ph->loc=REMOVED;
          return;
      }
 
@@ -7610,14 +7621,16 @@ __device__ void countPhoton(Photon* ph, struct Spectrum *spectrum,
           /*for (int n=0; n<(NATMd); n++){
               wabs += prof_atm[n+1 + il*(NATMd+1)].OD_abs * ph->cdist_atm[n];
           }*/
+          // the 3D move adds the path in a cell to cdist_*[iabs], iabs
+          // counted from 1 at the top: level n+1 goes with cdist_*[n+1]
           for (int n=0; n<(NATM_ABSd); n++){
-              wabs += prof_atm[n+1 + il*(NATMd+1)].OD_abs * ph->cdist_atm[n];
+              wabs += prof_atm[n+1 + il*(NATMd+1)].OD_abs * ph->cdist_atm[n+1];
           }
           /*for (int n=0; n<(NOCEd); n++){
               wabs += prof_oc[ n+1 + il*(NOCEd+1)].OD_abs * ph->cdist_oc[n];
           }*/
           for (int n=0; n<(NOCE_ABSd); n++){
-              wabs += prof_oc[ n+1 + il*(NOCEd+1)].OD_abs * ph->cdist_oc[n];
+              wabs += prof_oc[ n+1 + il*(NOCEd+1)].OD_abs * ph->cdist_oc[n+1];
           }
           #endif
 
@@ -7702,7 +7715,11 @@ __device__ void countPhoton(Photon* ph, struct Spectrum *spectrum,
      #if ( defined(SPHERIQUE) || defined(ALT_PP) )
      unsigned long long K   = NBTHETAd*NBPHId*NSENSORd; /* number of potential output per photon*/
      unsigned long long LL;
-     if (HISTd==1 && ((count_level==UPTOA) || (count_level==DOWN0P))) { // Histories stored for absorption computation afterward (only spherical || alt_pp)
+     // Histories stored for absorption computation afterward (only
+     // spherical || alt_pp); a count of zero intensity (a local estimate
+     // that did not reach the level, for instance) contributes nothing
+     if (HISTd==1 && ((count_level==UPTOA) || (count_level==DOWN0P))
+         && (weight*(st.x+st.y) != 0.F)) {
           //int idx = blockIdx.x * blockDim.x + threadIdx.x;
           unsigned long long counter2;
           counter2=atomicAdd(NPhotonsOut, 1);
@@ -7821,10 +7838,10 @@ __device__ void countPhoton(Photon* ph, struct Spectrum *spectrum,
        }
        #else
        for (int n=0; n<(NATM_ABSd); n++){
-           wabs_cdist += prof_atm[n+1 + ph->ilam*(NATMd+1)].OD_abs * ph->cdist_atm[n];
+           wabs_cdist += prof_atm[n+1 + ph->ilam*(NATMd+1)].OD_abs * ph->cdist_atm[n+1];
        }
        for (int n=0; n<(NOCE_ABSd); n++){
-           wabs_cdist += prof_oc[n+1 + ph->ilam*(NOCEd+1)].OD_abs * ph->cdist_oc[n];
+           wabs_cdist += prof_oc[n+1 + ph->ilam*(NOCEd+1)].OD_abs * ph->cdist_oc[n+1];
        }
        #endif
        wabs_cdist = exp(-wabs_cdist);

smartg-2.0.3/smartg/tests/test_jax_context.py

@@ -0,0 +1,46 @@
+"""Tests of the CUDA context of SMART-G next to the one of JAX.
+
+JAX opens a CUDA context of its own on the GPU, where the kernels of
+SMART-G are unknown. These tests need JAX with a GPU (the extra
+environment) and are skipped otherwise. Run them in a pytest process of
+their own: test_smartg_jax.py keeps JAX on the CPU for the whole
+process.
+"""
+
+import os
+
+import numpy as np
+import pytest
+
+from smartg.atmosphere import Atm1D
+from smartg.smartg import LocalEstimate, Smartg
+
+
+def test_run_after_jax_on_gpu() -> None:
+    """Check that Smartg runs after JAX has made its context current.
+
+    The Smartg object compiled before runs again, and a new one
+    compiles and runs, with the radiance of the first run. They failed
+    with 'invalid resource handle' before 2.0.3.
+    """
+    # a small share of the GPU memory is enough for this test
+    os.environ.setdefault("XLA_PYTHON_CLIENT_PREALLOCATE", "false")
+    jax = pytest.importorskip("jax")
+    if not any(dv.platform == "gpu" for dv in jax.devices()):
+        pytest.skip("JAX has no GPU")
+    import jax.numpy as jnp
+
+    kwargs = {
+        "atmosphere": Atm1D("afglms"),
+        "le": LocalEstimate(th_deg=[0.0], phi_deg=[0.0]),
+        "n_photons": 1e5,
+        "seed": 1,
+        "progress": False,
+    }
+    s1 = Smartg()
+    i1 = s1.run(550.0, **kwargs)["I_up (TOA)"].values
+    float(jnp.sum(jnp.arange(10.0)))
+    i2 = s1.run(550.0, **kwargs)["I_up (TOA)"].values
+    i3 = Smartg(alt_pp=True).run(550.0, **kwargs)["I_up (TOA)"].values
+    np.testing.assert_allclose(i2, i1, rtol=0.05)
+    np.testing.assert_allclose(i3, i1, rtol=0.05)

{smartg-2.0.2 → smartg-2.0.3}/smartg/tests/test_smartg.py

@@ -6,6 +6,10 @@ the outputs and the arguments the run accepts.
 """
 
 import math
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
 from typing import Any
 
 import numpy as np
@@ -17,7 +21,7 @@ from pycuda.compiler import SourceModule
 import smartg.smartg as smartg_mod
 from smartg import conftest
 from smartg.albedo import AlbedoCst, AlbedoMap
-from smartg.atmosphere import AerOPAC, Atm1D, Atm3D, Cloud
+from smartg.atmosphere import Aer3D, AerOPAC, Atm1D, Atm3D, Cloud, od2k
 from smartg.cdf import icdf_2d
 from smartg.grid3d import Grid3D
 from smartg.reptran import Reptran, reduce_reptran
@@ -72,6 +76,38 @@ def test_basic(request: pytest.FixtureRequest) -> None:
     conftest.savefig(request)
 
 
+def test_clear_context_leaves_nothing_to_pop_at_exit() -> None:
+    """Check that clear_context leaves pycuda no context to pop at exit.
+
+    Two Smartg objects of one process run in turn, each cleared after
+    its run. The exit handler of pycuda.autoinit used to pop the
+    contexts that clear_context had destroyed, and printed 'context::pop
+    failed' twice. The script runs in a subprocess, whose exit is the
+    point.
+    """
+    script = textwrap.dedent(
+        """
+        from smartg.atmosphere import Atm1D
+        from smartg.smartg import Smartg
+
+        for alt_pp in (False, True):
+            sg = Smartg(alt_pp=alt_pp)
+            sg.run(550.0, atmosphere=Atm1D("afglt"), n_photons=1e4,
+                   progress=False)
+            sg.clear_context()
+        print("done")
+        """
+    )
+    out = subprocess.run(
+        [sys.executable, "-c", script], capture_output=True, text=True,
+        timeout=600, check=False,
+    )
+    assert out.returncode == 0, out.stderr[-2000:]
+    assert "done" in out.stdout
+    assert "There is no current context" not in out.stdout
+    assert "context::pop failed" not in out.stderr
+
+
 @pytest.mark.parametrize("wavelength", wavelength_list)
 def test_atm(sg: Smartg, wavelength: Wavelength) -> None:
     """Check that a run keeps a wavelength axis only for a list."""
@@ -1130,6 +1166,108 @@ def test_brdf_surface_in_3d_atmosphere() -> None:
     )
 
 
+def _scene_3d(
+    comp_3d: list[Aer3D] | None = None,
+    mol_abs_1d: NDArray[np.floating] | None = None,
+) -> dict[str, Any]:
+    """Return the run arguments of a periodic 3D atmosphere.
+
+    The AFGL US standard atmosphere on 7 layers, 10 km wide with
+    0.25 km columns along x, at 430 and 440 nm. Six sensors at the
+    TOA above x 4.75-5.25 km look at it in backward mode, through a
+    local estimate at 40 degrees, over a Lambertian ground of albedo
+    0.3. mol_abs_1d replaces the absorption coefficients of the
+    levels (km-1, levels from the top).
+    """
+    z = np.array([100.0, 60.0, 30.0, 15.0, 8.0, 4.0, 1.0, 0.0])
+    dx = 0.25
+    grid3 = Grid3D(
+        np.arange(0.0, 10.0 + dx / 2, dx),
+        np.array([0.0, 4.0, 6.0, 10.0]),
+        z[::-1],
+        periodic=True,
+    )
+    wavelengths = np.array([430.0, 440.0])
+    p1 = Atm1D("afglus", grid=z).calc(wavelengths)
+    if mol_abs_1d is None:
+        mol_abs_1d = np.asarray(od2k(p1, "OD_g"))
+    atmosphere = Atm3D(
+        atm_1d=Atm1D("afglus"),
+        grid_3d=grid3,
+        comp_3d=comp_3d,
+        mol_sca_1d=np.asarray(od2k(p1, "OD_r")),
+        mol_abs_1d=mol_abs_1d,
+    ).calc(wavelengths)
+    sensors = get_sensors_grid(
+        np.array([4.75, 5.0, 5.25]), np.array([4.0, 6.0]), pos_z=100.0,
+        th_deg=180.0, ph_deg=0.0, loc="ATMOS", grid_3d=grid3,
+    )
+    return {
+        "wavelength": wavelengths,
+        "atmosphere": atmosphere,
+        "surface": LambSurface(alb=AlbedoCst(0.3)),
+        "sensor": sensors,
+        "le": LocalEstimate(
+            th_deg=[40.0], phi_deg=[180.0], count_level=[0]
+        ),
+        "n_photons": 2e5,
+        "seed": 1,
+        "stdev": True,
+        "progress": False,
+    }
+
+
+def test_3d_alis_absorbs_each_layer_along_its_path() -> None:
+    """Check that 3D ALIS applies each layer's absorption to its path.
+
+    Only the lowest layer (0-1 km) of a horizontally uniform 3D
+    atmosphere absorbs. ALIS, which applies the absorption to the path
+    lengths when the photon is counted, must agree with the
+    Beer-Lambert absorption of the move. Before 2.0.3 the count paired
+    each layer with the path in the layer above: here the 1-4 km layer,
+    three times thicker.
+    """
+    kabs = np.zeros((2, 8))  # (wavelength, level from the top)
+    kabs[:, -1] = 0.5
+    kwargs = _scene_3d(mol_abs_1d=kabs)
+    beer = Smartg(opt3d=True, alt_pp=True, back=True, double=True).run(
+        beer=1, **kwargs
+    )
+    alis = Smartg(
+        opt3d=True, alt_pp=True, alis=True, back=True, double=True
+    ).run(alis_options=Alis(n_low=2), **kwargs)
+    assert np.all(np.abs(_z_scores(alis, beer, "up (TOA)")) < 4)
+
+
+def test_absorbing_3d_particles_with_beer_and_alis() -> None:
+    """Check that the particles of a 3D component absorb in every mode.
+
+    A plume of desert particles of single scattering albedo 0.8 fills
+    x 4-6 km and z 0-4 km under the sensors. Its absorption must be the
+    same whether the photon weight carries it through the single
+    scattering albedo (beer=0), the Beer-Lambert law (beer=1) or the
+    ALIS weights. Before 2.0.3 the last two read the absorption of the
+    1D level, without the particles: 1.6 times the beer=0 radiance.
+    """
+    # 1-based (ix, iy, iz): x 4-6 km, the middle y cell, z 0-4 km
+    cells = np.array(
+        [[i, 2, k] for i in range(17, 25) for k in (1, 2)], dtype=np.int32
+    )
+    plume = Aer3D(
+        "desert", w_ref=435.0, ext_ref=np.full(len(cells), 1.0),
+        cell_indices=cells, rh=np.full(len(cells), 50.0), ssa_cst=0.8,
+    )
+    kwargs = _scene_3d(comp_3d=[plume])
+    sg = Smartg(opt3d=True, alt_pp=True, back=True, double=True)
+    ssa = sg.run(beer=0, **kwargs)
+    beer = sg.run(beer=1, **kwargs)
+    alis = Smartg(
+        opt3d=True, alt_pp=True, alis=True, back=True, double=True
+    ).run(alis_options=Alis(n_low=2), **kwargs)
+    assert np.all(np.abs(_z_scores(beer, ssa, "up (TOA)")) < 4)
+    assert np.all(np.abs(_z_scores(alis, ssa, "up (TOA)")) < 4)
+
+
 def _sza_max_run(
     sg: Smartg, n_theta: int, sza_max: float, seed: int
 ) -> xr.Dataset:
@@ -1621,3 +1759,37 @@ def test_sensor_on_either_side_of_the_surface(name: str, alt_pp: bool) -> None:
     sb = bw["I_stdev_up (TOA)"].values.ravel()[0]
     assert b > 0.1
     assert abs(a - b) < 5 * np.hypot(sa, sb), (name, a, sa, b, sb)
+
+
+def test_clear_context_of_two_objects() -> None:
+    """Check that two Smartg objects sharing a context clear safely.
+
+    Both run in the context of pycuda.autoinit: once the first has
+    cleared it, the second refuses to run and to clear it again, where
+    it crashed the driver, and a new Smartg object runs. The objects
+    live in a subprocess, the context being that of the whole process.
+    """
+    code = textwrap.dedent("""
+        from smartg.atmosphere import Atm1D
+        from smartg.smartg import Smartg
+        a, b = Smartg(), Smartg(alt_pp=True)
+        a.clear_context()
+        b.clear_context()
+        try:
+            b.run(500.0, n_photons=1e3, progress=False)
+        except RuntimeError as err:
+            print("refused:", err)
+        c = Smartg()
+        m = c.run(500.0, atmosphere=Atm1D("afglms"), n_photons=1e4,
+                  progress=False)
+        print("run:", float(m["I_up (TOA)"].mean()))
+        c.clear_context()
+        """)
+    proc = subprocess.run(
+        [sys.executable, "-B", "-c", code], capture_output=True, text=True,
+        cwd=Path(__file__).resolve().parents[2], timeout=600, check=False,
+    )
+    assert proc.returncode == 0, proc.stderr[-2000:]
+    assert "There is no current context to clear." in proc.stdout
+    assert "refused: The CUDA context of this Smartg" in proc.stdout
+    assert "run: " in proc.stdout