nanodisort 0.1.0.dev1__tar.gz

nanodisort-0.1.0.dev1/.github/workflows/build.yml

@@ -0,0 +1,59 @@
+name: Build
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.4.1
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  upload_pypi:
+    name: Publish to PyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/nanodisort
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

nanodisort-0.1.0.dev1/.github/workflows/lint.yml

@@ -0,0 +1,8 @@
+name: Lint
+on: [ push, pull_request ]
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/ruff-action@v3

nanodisort-0.1.0.dev1/.github/workflows/test.yml

@@ -0,0 +1,49 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
+      - name: Install dependencies
+        run: |
+          uv sync --all-packages --all-extras
+
+      - name: Build extension
+        run: |
+          uv pip install -ve .
+
+      - name: Run tests
+        run: |
+          uv run pytest --cov=nanodisort --cov-report=xml --cov-report=term
+
+      - name: Upload coverage to Codecov
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
+        uses: codecov/codecov-action@v4
+        with:
+          file: ./coverage.xml
+          fail_ci_if_error: false

nanodisort-0.1.0.dev1/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+.cmake
+.DS_Store
+.venv
+*.egg-info
+*.py[oc]
+build/
+dist/
+docs/_build/
+wheels/
+.vscode/
+.idea/
+.ipynb_checkpoints/
+CLAUDE.md

nanodisort-0.1.0.dev1/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.7
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+  - repo: https://github.com/ComPWA/taplo-pre-commit
+    rev: v0.9.3
+    hooks:
+      - id: taplo-format
+  - repo: https://github.com/kynan/nbstripout
+    rev: 0.8.1
+    hooks:
+      - id: nbstripout

nanodisort-0.1.0.dev1/.python-version

@@ -0,0 +1 @@
+3.12

nanodisort-0.1.0.dev1/AGENTS.md

@@ -0,0 +1,93 @@
+# AGENTS.md
+
+This file provides guidance to coding agents when working with this repository.
+
+## Project Overview
+
+nanodisort is a Python binding for cdisort, a C implementation of the DISORT (Discrete Ordinates Radiative Transfer) solver. It provides a Pythonic interface to solve the radiative transfer equation in plane-parallel atmospheres with support for multiple scattering, absorption, emission, and various boundary conditions.
+
+## Build & Development Commands
+
+```bash
+# Setup development environment
+uv sync --dev
+
+# (Re)build C++ extension module
+uv pip install -ve .
+
+# Run all tests
+uv run task test
+
+# Run tests with coverage
+uv run task test-cov
+
+# Run a single test file
+uv run pytest tests/test_disotest.py -v
+
+# Run a specific test
+uv run pytest tests/test_disotest.py::TestDisort01::test_case_1a -v
+
+# Lint
+uv run task lint
+
+# Format
+uv run task format
+
+# Check (lint + format check)
+uv run task check
+
+# Build docs
+uv run task docs
+```
+
+## Architecture
+
+### Directory Structure
+
+- `src/nanodisort/` - Python package with C++ bindings
+- `src/nanodisort/_core.cpp` - nanobind C++ extension wrapping cdisort
+- `src/nanodisort/utils/phase_functions.py` - Phase function moment generators
+- `ext/cdisort-2.1.3/` - Vendored cdisort C library
+- `tests/` - pytest test suite
+- `benchmarks/` - pytest-benchmark suite
+
+### Build System
+
+- scikit-build-core for Python/CMake integration
+- nanobind for C++17/Python bindings
+- CMake builds cdisort as a static library, then links to the `_core` extension
+
+### Core Components
+
+**DisortState** (`__init__.py` wraps `_core.cpp`): Main solver interface
+
+- Configure dimensions: `nstr`, `nlyr`, `nmom`, `ntau`, `numu`, `nphi`
+- Set flags: `usrtau`, `usrang`, `lamber`, `planck`, `onlyfl`, `quiet`, `intensity_correction`, `spher`
+- Set boundary conditions: `fbeam`, `umu0`, `phi0`, `fisot`, `albedo`, etc.
+- Set optical properties: `dtauc` (layer optical depths), `ssalb` (single scattering albedo), `pmom` (phase function moments)
+- Call `allocate()` then `solve()`
+- Read outputs: `rfldir`, `rfldn`, `flup`, `dfdt`, `uu` (intensity), etc.
+
+**Phase Functions** (`utils/phase_functions.py`): Generate Legendre moment arrays
+
+- `isotropic(nmom)`, `rayleigh(nmom)`, `henyey_greenstein(gg, nmom)`
+- `haze_l(nmom)`, `cloud_c1(nmom)` - tabulated aerosol/cloud phase functions
+
+### Array Conventions
+
+- C++ bindings handle Fortran-to-C array order conversion automatically
+- `pmom` array shape: `(nmom_nstr+1, nlyr)` in C order
+- `uu` intensity output shape: `(numu, ntau, nphi)` in C order
+
+### Testing
+
+- `test_disotest.py` - Ported tests from cdisort's disotest.c, validated against Van de Hulst, Sweigart, Garcia-Siewert benchmarks
+- `test_core.py` - Basic solver functionality
+- `test_batch.py` - Batch solve tests
+- `test_error_handling.py` - Error condition tests
+
+## Key Implementation Details
+
+- Error handling: cdisort calls a registered callback that throws C++ exceptions, converted to Python RuntimeError by nanobind
+- Memory: `DisortState.allocate()` must be called after setting dimensions and before setting arrays or calling `solve()`
+- The `nmom` parameter controls phase function truncation; set `nmom >= nstr` for proper scattering

nanodisort-0.1.0.dev1/CITATION.cff

@@ -0,0 +1,15 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+type: software
+title: nanodisort
+abstract: Python bindings for CDISORT, a C implementation of the DISORT (Discrete Ordinates Radiative Transfer) solver for plane-parallel atmospheres.
+version: 0.1.0
+license: GPL-3.0-or-later
+repository-code: https://github.com/eradiate/nanodisort
+authors:
+  - family-names: Leroy
+    given-names: Vincent
+    email: vincent.leroy@rayference.eu
+  - family-names: Emde
+    given-names: Claudia
+    email: claudia.emde@rayference.eu

nanodisort-0.1.0.dev1/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.15...3.27)
+project(nanodisort VERSION 0.1.0 LANGUAGES C CXX)
+
+# Set C++17 standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Find Python and nanobind
+find_package(Python 3.9 REQUIRED COMPONENTS Interpreter Development.Module)
+find_package(nanobind CONFIG REQUIRED)
+find_package(Threads REQUIRED)
+
+# cdisort library sources
+set(CDISORT_SOURCES
+    ext/cdisort-2.1.3/cdisort.c
+    ext/cdisort-2.1.3/locate.c
+)
+
+set(CDISORT_HEADERS
+    ext/cdisort-2.1.3/cdisort.h
+    ext/cdisort-2.1.3/locate.h
+)
+
+# Build static cdisort library
+add_library(cdisort STATIC ${CDISORT_SOURCES} ${CDISORT_HEADERS})
+target_include_directories(cdisort PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/ext/cdisort-2.1.3)
+target_compile_options(cdisort PRIVATE
+    -O3
+    -fPIC  # Position independent code for shared library
+)
+target_link_libraries(cdisort PUBLIC m)  # Link math library
+
+# Python extension module using nanobind
+nanobind_add_module(_core
+    src/nanodisort/_core.cpp
+    src/nanodisort/thread_pool.cpp
+    NB_STATIC  # Use static linking with nanobind
+)
+
+# Link cdisort library to Python extension
+target_link_libraries(_core PRIVATE cdisort Threads::Threads)
+target_include_directories(_core PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/ext/cdisort-2.1.3
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/nanodisort
+)
+
+# Install the extension module
+install(TARGETS _core LIBRARY DESTINATION nanodisort COMPONENT python)

nanodisort-0.1.0.dev1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.2
+Name: nanodisort
+Version: 0.1.0.dev1
+Summary: Python bindings for cdisort radiative transfer solver
+Author-Email: Vincent Leroy <vincent.leroy@rayference.eu>
+License: GPL-3.0-or-later
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: <3.14,>=3.9
+Requires-Dist: numpy>=1.20
+Description-Content-Type: text/markdown
+
+# nanodisort
+
+Python bindings for [CDISORT](http://www.libradtran.org/doku.php?id=cdisort), a C implementation of the DISORT (Discrete Ordinates Radiative Transfer) solver.
+
+## Overview
+
+DISORT is a widely-used radiative transfer solver for plane-parallel atmospheres. It uses the discrete ordinates method to solve the radiative transfer equation with support for:
+
+- Multiple scattering
+- Absorption and emission
+- Thermal emission (Planck function)
+- Various boundary conditions
+- Pseudo-spherical geometry for direct beam
+
+The CDISORT library offers improved performance over the original Fortran version through dynamic memory allocation and full double precision arithmetic.
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 to 3.13
+- NumPy 1.20 or later
+
+### From source
+
+```bash
+git clone https://github.com/rayference/nanodisort.git
+cd nanodisort
+uv sync --dev
+uv pip install -e .
+```
+
+## Quickstart
+
+```python
+import nanodisort as nd
+
+# Create solver state
+state = nd.DisortState()
+
+# Configure dimensions
+state.nstr = 8   # Number of streams
+state.nlyr = 6   # Number of layers
+state.nmom = 8   # Number of phase function moments
+state.ntau = 5   # Number of output optical depths
+state.numu = 4   # Number of output polar angles
+state.nphi = 3   # Number of output azimuthal angles
+
+# Allocate memory
+state.allocate()
+
+# Set optical properties, geometry, boundary conditions
+# ... (see documentation)
+
+# Solve
+state.solve()
+```
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 or later (GPL-3.0-or-later), consistent with the CDISORT library it wraps.
+
+## Acknowledgments
+
+nanodisort authors are grateful to the developers of the many implementations of DISORT, and, in particular, to
+
+- Timothy E. Dowling (original CDISORT C translation);
+- Robert Buras (phase function extensions);
+- Arve Kylling (pseudo-spherical approximation, testing);
+- the original DISORT Fortran authors.
+
+## Citation
+
+If you use nanodisort in your research, please cite the [CDISORT paper](https://doi.org/10.1016/j.jqsrt.2011.03.019) and the nanodisort repository:
+
+```bibtex
+@software{Leroy_nanodisort,
+    author = {Leroy, Vincent and Emde, Claudia},
+    license = {GPL-3.0-or-later},
+    title = {{nanodisort}},
+    url = {https://github.com/eradiate/nanodisort},
+    version = {0.1.0}
+}
+```

nanodisort-0.1.0.dev1/README.md

@@ -0,0 +1,84 @@
+# nanodisort
+
+Python bindings for [CDISORT](http://www.libradtran.org/doku.php?id=cdisort), a C implementation of the DISORT (Discrete Ordinates Radiative Transfer) solver.
+
+## Overview
+
+DISORT is a widely-used radiative transfer solver for plane-parallel atmospheres. It uses the discrete ordinates method to solve the radiative transfer equation with support for:
+
+- Multiple scattering
+- Absorption and emission
+- Thermal emission (Planck function)
+- Various boundary conditions
+- Pseudo-spherical geometry for direct beam
+
+The CDISORT library offers improved performance over the original Fortran version through dynamic memory allocation and full double precision arithmetic.
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 to 3.13
+- NumPy 1.20 or later
+
+### From source
+
+```bash
+git clone https://github.com/rayference/nanodisort.git
+cd nanodisort
+uv sync --dev
+uv pip install -e .
+```
+
+## Quickstart
+
+```python
+import nanodisort as nd
+
+# Create solver state
+state = nd.DisortState()
+
+# Configure dimensions
+state.nstr = 8   # Number of streams
+state.nlyr = 6   # Number of layers
+state.nmom = 8   # Number of phase function moments
+state.ntau = 5   # Number of output optical depths
+state.numu = 4   # Number of output polar angles
+state.nphi = 3   # Number of output azimuthal angles
+
+# Allocate memory
+state.allocate()
+
+# Set optical properties, geometry, boundary conditions
+# ... (see documentation)
+
+# Solve
+state.solve()
+```
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 or later (GPL-3.0-or-later), consistent with the CDISORT library it wraps.
+
+## Acknowledgments
+
+nanodisort authors are grateful to the developers of the many implementations of DISORT, and, in particular, to
+
+- Timothy E. Dowling (original CDISORT C translation);
+- Robert Buras (phase function extensions);
+- Arve Kylling (pseudo-spherical approximation, testing);
+- the original DISORT Fortran authors.
+
+## Citation
+
+If you use nanodisort in your research, please cite the [CDISORT paper](https://doi.org/10.1016/j.jqsrt.2011.03.019) and the nanodisort repository:
+
+```bibtex
+@software{Leroy_nanodisort,
+    author = {Leroy, Vincent and Emde, Claudia},
+    license = {GPL-3.0-or-later},
+    title = {{nanodisort}},
+    url = {https://github.com/eradiate/nanodisort},
+    version = {0.1.0}
+}
+```

nanodisort-0.1.0.dev1/benchmarks/benchmark_batch.py

@@ -0,0 +1,94 @@
+import numpy as np
+
+import nanodisort as nd
+from nanodisort.utils import phase_functions as pf
+
+# Benchmark parameters
+NSTR = 16
+NLYR = 120
+NMOM = 16
+NBATCH = 100
+
+# Shared configuration applied to both DisortState and BatchSolver
+_shared_config = {
+    "nstr": NSTR,
+    "nlyr": NLYR,
+    "nmom": NMOM,
+    "ntau": 0,
+    "numu": 0,
+    "nphi": 0,
+    "usrtau": False,
+    "usrang": False,
+    "lamber": True,
+    "planck": False,
+    "onlyfl": True,
+    "quiet": True,
+    "intensity_correction": False,
+    "spher": False,
+    "umu0": 0.5,
+    "phi0": 0.0,
+    "fisot": 0.0,
+    "fluor": 0.0,
+    "albedo": 0.1,
+    "accur": 0.0,
+    "wvnmlo": 0.0,
+    "wvnmhi": 0.0,
+    "btemp": 0.0,
+    "ttemp": 0.0,
+    "temis": 0.0,
+}
+
+# Pre-compute shared data
+_dtauc = np.full((NBATCH, NLYR), 0.5)
+_ssalb = np.random.default_rng(1).uniform(0.5, 1.0, (NBATCH, NLYR))
+_pmom_single = pf.henyey_greenstein(0.7, NMOM).reshape(-1, 1) * np.ones(NLYR)
+_pmom_batch = _pmom_single[:, :, np.newaxis] * np.ones(NBATCH)
+_fbeam = np.full(NBATCH, np.pi)
+_albedo = np.full(NBATCH, 0.1)
+
+
+def _apply_config(target):
+    for key, value in _shared_config.items():
+        setattr(target, key, value)
+
+
+def _make_single_state() -> nd.DisortState:
+    ds = nd.DisortState()
+    _apply_config(ds)
+    ds.allocate()
+    return ds
+
+
+def _make_batch_solver() -> nd.BatchSolver:
+    solver = nd.BatchSolver(nthreads=2)
+    _apply_config(solver)
+    solver.allocate(NBATCH)
+    solver.set_dtauc(_dtauc)
+    solver.set_ssalb(_ssalb)
+    solver.set_pmom(_pmom_batch)
+    solver.set_fbeam(_fbeam)
+    solver.set_albedo(_albedo)
+    return solver
+
+
+class BenchmarkBatch:
+    def benchmark_single(self, benchmark):
+        ds = _make_single_state()
+
+        def run():
+            for i in range(NBATCH):
+                ds.dtauc = _dtauc[i]
+                ds.ssalb = _ssalb[i]
+                ds.fbeam = _fbeam[i]
+                ds.pmom = _pmom_single
+                ds.solve()
+
+        benchmark(run)
+
+    def benchmark_batch(self, benchmark):
+        solver = _make_batch_solver()
+
+        def run():
+            solver.solve()
+
+        benchmark(run)

nanodisort-0.1.0.dev1/benchmarks/pytest.ini

@@ -0,0 +1,7 @@
+[pytest]
+python_files = benchmark_*.py
+python_functions = benchmark_*
+python_classes = Benchmark*
+addopts =
+    --benchmark-enable
+    --benchmark-columns=mean,stddev

nanodisort-0.1.0.dev1/docs/api/index.rst

@@ -0,0 +1,10 @@
+API Reference
+=============
+
+This page contains the API reference for nanodisort.
+
+.. toctree::
+   :maxdepth: 2
+
+   nanodisort
+   nanodisort.utils.phase_functions