obdeect 0.6.0__tar.gz → 0.7.0__tar.gz

{obdeect-0.6.0 → obdeect-0.7.0}/.github/workflows/ci.yml

@@ -22,11 +22,9 @@ jobs:
         with:
           python-version: '3.14'
       - name: Install linters
-        run: python -m pip install --upgrade pip pre-commit ruff clang-format
+        run: python -m pip install --upgrade pip pre-commit clang-format
       - name: Run repository hooks
         run: pre-commit run --all-files
-      - name: Check Python formatting and lint
-        run: ruff format --check python && ruff check python
       - name: Check C++ formatting
         run: >-
           find cpp -type f \( -name '*.cpp' -o -name '*.hpp' \) -print0

{obdeect-0.6.0 → obdeect-0.7.0}/.github/workflows/pypi.yml

@@ -36,7 +36,7 @@ jobs:
       - name: Build and smoke-test wheels
         env:
           CIBW_BUILD: "cp314-*"
-          CIBW_TEST_REQUIRES: "pytest scipy"
+          CIBW_TEST_REQUIRES: "pytest matplotlib"
           CIBW_TEST_COMMAND: python -m pytest {project}/python/tests -q
         run: python -m cibuildwheel --output-dir wheelhouse
       - uses: actions/upload-artifact@v7

{obdeect-0.6.0 → obdeect-0.7.0}/.github/workflows/tests.yml

@@ -27,7 +27,7 @@ jobs:
         with:
           python-version: '3.14'
       - name: Install Python package and test dependencies
-        run: python -m pip install --upgrade pip && python -m pip install . pytest scipy
+        run: python -m pip install --upgrade pip && python -m pip install ".[plot]" pytest
       - name: Configure and build
         run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build --parallel
       - name: Run native and Python tests

{obdeect-0.6.0 → obdeect-0.7.0}/AGENTS.md

@@ -5,8 +5,20 @@
 `obdeect` is a portable C++20 optical ray tracer with a thin Python interface.
 It traces photons from a defined entrance surface to a focal/sensor surface.
 Air-shower generation, electronics, triggers, and event writing are out of
-scope. Read the relevant code and tests first; use the workspace plans and
-validation matrix for architectural or scientific changes.
+scope. Read the relevant code and tests first; use `docs/VALIDATION.md` and
+`docs/optical-models.md` for architectural or scientific changes.
+
+## Layout
+
+- `cpp/include/obdeect/`: C++ core headers (kernels, optical models, public API).
+- `cpp/bindings/core.cpp`: nanobind extension; the only C++ file that may
+  depend on Python.
+- `cpp/tests/`: native tests (`test_*.cpp`), shared helpers (`check.hpp`),
+  and fixtures in `cpp/tests/data/`.
+- `cpp/bench/`: benchmarks and the replay comparison tool.
+- `python/obdeect/`: Python boundary (compile, trace, formats, plotting, CLI).
+- `python/tests/`: pytest suite; `telescopes.py` holds shared test helpers.
+- `docs/`: Sphinx sources. `docs/changes/` is towncrier input (see below).
 
 ## Design rules
 
@@ -34,7 +46,7 @@ validation matrix for architectural or scientific changes.
 - CTAO support is an explicit importer/adapter or versioned fixture only. It
   must not be required to build, test, or run the generic engine, and it must
   never be an implicit fallback.
-- Use python >3.14. Do not fall back to earlier versions.
+- Use Python >=3.14 (as in `pyproject.toml`). Do not fall back to earlier versions.
 
 ## Changes and validation
 
@@ -55,9 +67,11 @@ validation matrix for architectural or scientific changes.
 ## Build, test, and lint
 
 Run from this directory. Configure before static analysis so the compilation
-database is current.
+database is current. The `debug` preset enables `OBDEECT_BUILD_TESTING` and
+writes to `build/debug/`; wheels build with `OBDEECT_BUILD_TESTING=OFF`.
 
 ```bash
+python -m pip install -e '.[dev]'   # editable install; rebuilds the extension on C++ changes
 cmake --preset debug
 cmake --build --preset debug
 ctest --test-dir build/debug --output-on-failure
@@ -77,7 +91,24 @@ the focused tests before the full suite. A clean handoff requires both
 `ruff format --check python` and `ruff check python`; do not rely on a passing
 test run alone because stale test references can fail collection or linting.
 
-Run `clang-tidy -p build/debug cpp/src/<changed-file>.cpp` for changed C++
-translation units when available, and `pre-commit run --all-files` before
-handoff. Start with the smallest relevant test; run the full checks for shared
-kernels, interfaces, configuration, or tooling changes.
+Run `clang-tidy -p build/debug <changed-file>` for changed C++ translation units
+(`cpp/tests/`, `cpp/bench/`, `cpp/bindings/`, or `cpp/include/obdeect/` headers)
+when available, and `pre-commit run --all-files` before handoff. Pre-commit runs
+ruff, codespell, markdownlint, yamllint, actionlint, pyproject-fmt, shellcheck,
+and the towncrier check. Start with the smallest relevant test; run the full
+checks for shared kernels, interfaces, configuration, or tooling changes.
+
+CI also builds and tests a `-DOBDEECT_USE_FMA=ON` Release configuration and an
+AddressSanitizer/UBSan Debug configuration. Run those locally for changes to
+floating-point kernels or memory-handling code:
+
+```bash
+cmake -S . -B build-sanitize -DCMAKE_BUILD_TYPE=Debug \
+  -DCMAKE_CXX_FLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer" \
+  -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address,undefined"
+cmake --build build-sanitize --parallel
+ctest --test-dir build-sanitize --output-on-failure
+```
+
+Docs build with warnings as errors: `sphinx-build -W --keep-going -b html docs docs/_build/html`.
+Regenerate figures only from new validation results, via `docs/figures/make_figures.py`.

{obdeect-0.6.0 → obdeect-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: obdeect
-Version: 0.6.0
+Version: 0.7.0
 Summary: Ray tracing for imaging atmospheric Cherenkov telescopes
 Author: obdeect contributors
 License: BSD 3-Clause License
@@ -39,21 +39,23 @@ Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.14
-Requires-Dist: matplotlib>=3.8
 Requires-Dist: numpy>=2.3
 Provides-Extra: dev
 Requires-Dist: nanobind>=3.1; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Requires-Dist: scipy; extra == "dev"
 Provides-Extra: docs
-Requires-Dist: astropy; extra == "docs"
 Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: pydata-sphinx-theme; extra == "docs"
 Requires-Dist: pyyaml; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-design; extra == "docs"
+Provides-Extra: figures
+Requires-Dist: astropy; extra == "figures"
+Requires-Dist: matplotlib>=3.8; extra == "figures"
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.8; extra == "plot"
 Description-Content-Type: text/markdown
 
 # obdeect

{obdeect-0.6.0 → obdeect-0.7.0}/cpp/bindings/core.cpp

@@ -189,14 +189,14 @@ public:
 
   // Photon bunches (see obdeect::trace_bunches). Acceptance and density are
   // given as arrays; the output arrays are views of the rows written.
-  nb::dict
-  trace_bunches(In1<float> x, In1<float> y, In1<float> cx, In1<float> cy, In1<float> time_ns,
-                In1<float> zem, In1<float> size, In1<float> wavelength_nm,
-                In1<std::uint64_t> bunch_id, In1<double> rotation, In1<double> offset_m,
-                double length_unit_m, double plane_z, std::uint64_t seed,
-                const std::optional<std::tuple<In1<double>, In1<double>, In1<double>>> &acceptance,
-                const std::optional<std::tuple<In1<double>, In1<double>>> &density, bool roulette,
-                bool classify_losses, obdeect::ThreadPool &pool) const {
+  nb::dict trace_bunches(
+      In1<float> x, In1<float> y, In1<float> cx, In1<float> cy, In1<float> time_ns, In1<float> zem,
+      In1<float> size, In1<float> wavelength_nm, In1<std::uint64_t> bunch_id, In1<double> rotation,
+      In1<double> offset_m, double length_unit_m, double plane_z, std::uint64_t seed,
+      const std::optional<std::tuple<In1<double>, In1<double>, In1<double>>> &acceptance,
+      const std::optional<std::tuple<In1<double>, In1<double>>> &density,
+      const std::optional<std::tuple<double, double>> &wavelength_law, bool roulette,
+      bool classify_losses, bool normalise_transmission, obdeect::ThreadPool &pool) const {
     const std::size_t n = x.shape(0);
     for (const std::size_t length :
          {y.shape(0), cx.shape(0), cy.shape(0), time_ns.shape(0), zem.shape(0), size.shape(0),
@@ -213,9 +213,11 @@ public:
 
     obdeect::Map2D acceptance_map;
     obdeect::LinearDensity wavelength_density;
+    obdeect::InverseSquareLaw law;
     obdeect::BunchOptions options;
     options.roulette = roulette;
     options.classify_losses = classify_losses;
+    options.normalise_transmission = normalise_transmission;
     try {
       if (acceptance) {
         const auto &[wavelengths, heights, values] = *acceptance;
@@ -234,6 +236,11 @@ public:
                                    {weights.data(), weights.data() + weights.shape(0)});
         options.wavelength_density = &wavelength_density;
       }
+      if (wavelength_law) {
+        const auto &[lo_nm, hi_nm] = *wavelength_law;
+        law = {lo_nm, hi_nm};
+        options.wavelength_law = &law;
+      }
     } catch (const std::invalid_argument &error) {
       throw nb::value_error(error.what());
     }
@@ -501,7 +508,8 @@ NB_MODULE(_core, module) {
       .def("trace_bunches", &Model::trace_bunches, "x"_a, "y"_a, "cx"_a, "cy"_a, "time_ns"_a,
            "zem"_a, "size"_a, "wavelength_nm"_a, "bunch_id"_a, "rotation"_a, "offset_m"_a,
            "length_unit_m"_a, "plane_z"_a, nb::kw_only(), "seed"_a, "acceptance"_a = nb::none(),
-           "wavelength_density"_a = nb::none(), "roulette"_a = true, "classify_losses"_a = true,
+           "wavelength_density"_a = nb::none(), "wavelength_law"_a = nb::none(),
+           "roulette"_a = true, "classify_losses"_a = true, "normalise_transmission"_a = false,
            "pool"_a)
       .def("obscurer_crossings", &Model::obscurer_crossings, "start"_a, "end"_a, "leg"_a);
   module.def("trace_many", &trace_many, "items"_a, nb::kw_only(), "seed"_a, "pool"_a);

{obdeect-0.6.0 → obdeect-0.7.0}/cpp/include/obdeect/bunches.hpp

@@ -33,6 +33,13 @@ struct BunchFrame {
   double plane_z{};          // Input units.
 };
 
+// Wavelength of bunches with wavelength 0: density proportional to 1/lambda^2
+// on [lo_nm, hi_nm], truncated to integer nm.
+struct InverseSquareLaw {
+  double lo_nm{};
+  double hi_nm{};
+};
+
 struct BunchOptions {
   // Acceptance outside the telescope as a function of wavelength [nm] (x) and
   // emission height [m] (y), values in [0, 1]; null means 1.
@@ -40,6 +47,10 @@ struct BunchOptions {
   const LinearDensity *wavelength_density{}; // Over nm, for bunches of wavelength 0.
   bool roulette{true};                       // Survivors get weight 1 (else the weight ratio).
   bool classify_losses{true};
+  // Roulette weights and bound relative to the telescope transmission's on-axis value.
+  bool normalise_transmission{false};
+  // Alternative to wavelength_density for bunches of wavelength 0 (not both).
+  const InverseSquareLaw *wavelength_law{};
 };
 
 // Output columns, with room for the rows the allocator was asked for. Vectors
@@ -102,8 +113,9 @@ public:
       const double size = in_.size[i];
       const double lambda = in_.wavelength_nm[i];
       if (!(size > 0.0 && size <= kMaxBunchSize) || !std::isfinite(lambda) || lambda < 0.0 ||
-          (lambda == 0.0 && !options_.wavelength_density) || !std::isfinite(in_.x[i]) ||
-          !std::isfinite(in_.y[i]) || !std::isfinite(in_.cx[i]) || !std::isfinite(in_.cy[i]) ||
+          (lambda == 0.0 && !options_.wavelength_density && !options_.wavelength_law) ||
+          !std::isfinite(in_.x[i]) || !std::isfinite(in_.y[i]) || !std::isfinite(in_.cx[i]) ||
+          !std::isfinite(in_.cy[i]) ||
           !(static_cast<double>(in_.cx[i]) * in_.cx[i] +
                 static_cast<double>(in_.cy[i]) * in_.cy[i] <=
             1.0 + 1e-6) ||
@@ -117,30 +129,40 @@ public:
 
   // Trace the bunches [begin, end), writing rows from `row` on; returns the
   // number of rows written.
-  std::size_t run(std::size_t begin, std::size_t end, const BunchResult &out,
-                  std::size_t row) const {
+  std::size_t run(std::size_t begin, std::size_t end, const BunchResult &out, std::size_t row,
+                  std::uint8_t *keep_flags, std::vector<double> &roulette_draws,
+                  bool thinning) const {
     const std::size_t first = row;
     const double u = frame_.length_unit_m;
     const double *r = frame_.rotation;
     // Position and direction in the telescope frame, computed for the first
     // photon of a bunch that survives the thinning.
+    // The model's axes offset O displaces the optical origin: P is traced at R P - O.
+    const auto &axes = model_.axes_offset_m;
     const auto transform = [&](std::size_t i) {
       const double x = u * in_.x[i], y = u * in_.y[i], z = u * frame_.plane_z;
       const double cx = in_.cx[i], cy = in_.cy[i];
       const double cz = -std::sqrt(std::max(0.0, 1.0 - cx * cx - cy * cy));
-      return Ray{{r[0] * x + r[1] * y + r[2] * z + frame_.offset_m[0],
-                  r[3] * x + r[4] * y + r[5] * z + frame_.offset_m[1],
-                  r[6] * x + r[7] * y + r[8] * z + frame_.offset_m[2]},
+      return Ray{{r[0] * x + r[1] * y + r[2] * z + frame_.offset_m[0] - axes[0],
+                  r[3] * x + r[4] * y + r[5] * z + frame_.offset_m[1] - axes[1],
+                  r[6] * x + r[7] * y + r[8] * z + frame_.offset_m[2] - axes[2]},
                  {r[0] * cx + r[1] * cy + r[2] * cz, r[3] * cx + r[4] * cy + r[5] * cz,
                   r[6] * cx + r[7] * cy + r[8] * cz}};
     };
-    // Bound and acceptance of the last wavelength (and height): showers have
-    // many bunches of one wavelength.
+    // Divisor of the bound and of the roulette weight: the on-axis transmission,
+    // if normalised. The telescope transmission enters the photon weights as
+    // t(theta) / t0 because sim_telarray already applies t0 in its bunch loop.
+    const double norm = options_.normalise_transmission && model_.telescope_transmission &&
+                                model_.telescope_transmission->on_axis > 0.0
+                            ? model_.telescope_transmission->on_axis
+                            : 1.0;
+    // Bound (relative to norm) and acceptance of the last wavelength (and
+    // height): showers have many bunches of one wavelength.
     double cached_lambda = -1.0, cached_zem = 0.0, cached_bound = 0.0, cached_acceptance = 1.0;
     const auto response = [&](double lambda, double zem_m) {
       if (lambda != cached_lambda) {
         cached_lambda = lambda;
-        cached_bound = response_bound(model_, lambda);
+        cached_bound = response_bound(model_, lambda) / norm;
         cached_zem = std::numeric_limits<double>::quiet_NaN();
       }
       if (zem_m != cached_zem) {
@@ -148,6 +170,7 @@ public:
         cached_acceptance = options_.acceptance ? options_.acceptance->at(lambda, zem_m) : 1.0;
       }
     };
+    std::size_t candidate = 0, survivor = 0;
     for (std::size_t i = begin; i < end; ++i) {
       const double zem_m = u * in_.zem[i];
       const double size = in_.size[i], time = in_.time_ns[i];
@@ -161,17 +184,36 @@ public:
       Ray ray;
       for (std::size_t k = 0; k < n_sub; ++k) {
         const auto sub = static_cast<std::uint32_t>(k);
+        const std::size_t flag = candidate++;
+        if (!thinning && !keep_flags[flag])
+          continue;
         const double frac = static_cast<double>(k + 1) <= size ? 1.0 : size - std::floor(size);
         if (!fixed) {
-          lambda =
-              options_.wavelength_density->sample(uniform4(seed_, id, Stream::wavelength, sub)[0]);
+          if (options_.wavelength_law) {
+            // Inverse transform of 1/lambda^2; u in (0, 1), so the value lies in (lo, hi).
+            const auto &law = *options_.wavelength_law;
+            const double u = uniform4(seed_, id, Stream::wavelength, sub)[0];
+            const double exact = 1.0 / (1.0 / law.lo_nm - u * (1.0 / law.lo_nm - 1.0 / law.hi_nm));
+            // Truncation to integer nm as sim_telarray does: lambda in [floor(lo), hi).
+            lambda = std::floor(exact);
+          } else {
+            lambda = options_.wavelength_density->sample(
+                uniform4(seed_, id, Stream::wavelength, sub)[0]);
+          }
           response(lambda, zem_m);
         }
         const double bound = cached_bound;
         const double keep = frac * cached_acceptance * bound;
-        const auto draw = uniform4(seed_, id, Stream::thinning, sub);
-        if (!(draw[0] < keep))
+        if (thinning) {
+          const auto draw = uniform4(seed_, id, Stream::thinning, sub);
+          keep_flags[flag] = draw[0] < keep;
+          if (keep_flags[flag]) {
+            roulette_draws.push_back(draw[1]);
+            ++row;
+          }
           continue;
+        }
+        const double roulette_draw = roulette_draws[survivor++];
         if (!placed) {
           ray = transform(i);
           placed = true;
@@ -180,8 +222,8 @@ public:
                                     options_.classify_losses, sub);
         if (t.status != Status::detected)
           continue;
-        const double ratio = std::min(1.0, t.weight / bound);
-        if (options_.roulette && !(draw[1] < ratio))
+        const double ratio = std::min(1.0, (t.weight / norm) / cached_bound);
+        if (options_.roulette && !(roulette_draw < ratio))
           continue;
         out.position_m[3 * row] = t.position.x;
         out.position_m[3 * row + 1] = t.position.y;
@@ -219,12 +261,12 @@ private:
 // unique per seed.
 //
 // Invalid input (a non-orthonormal frame, acceptance outside [0, 1], a bunch of
-// wavelength 0 without a density, bad sizes) throws std::invalid_argument
+// wavelength 0 without a density or law, bad sizes) throws std::invalid_argument
 // before any tracing; so does a transmission without a known maximum
 // (ModelError).
 //
-// `allocate(rows)` is called once, after validation, with the largest number
-// of rows the call can write, and returns the output columns for that many
+// `allocate(rows)` is called once, after validation, with the number
+// of thinning survivors, and returns the output columns for that many
 // rows. Returns the rows written; they come first, in input order, bunch by
 // bunch and sub-photon by sub-photon.
 template <class Allocate>
@@ -236,6 +278,15 @@ std::size_t trace_bunches(const OpticalModel &model, const BunchBlock &in, const
     detail::validate_acceptance(*options.acceptance);
   if (options.wavelength_density && !(options.wavelength_density->lower() > 0.0))
     throw std::invalid_argument("bunch wavelength density: nodes must start above 0 nm");
+  if (options.wavelength_law) {
+    const auto &law = *options.wavelength_law;
+    // lo_nm >= 1 keeps floor(lambda) >= 1 for every sample, so no photon is at wavelength 0.
+    if (!std::isfinite(law.lo_nm) || !std::isfinite(law.hi_nm) || !(law.lo_nm >= 1.0) ||
+        !(law.hi_nm > law.lo_nm))
+      throw std::invalid_argument("bunch wavelength law: need finite 1 <= lo_nm < hi_nm");
+    if (options.wavelength_density)
+      throw std::invalid_argument("bunch wavelength: set one wavelength law");
+  }
   validate_bound_support(model); // Throws ModelError for an unsupported transmission.
   const detail::BunchTask task(model, in, frame, options, seed);
 
@@ -250,15 +301,26 @@ std::size_t trace_bunches(const OpticalModel &model, const BunchBlock &in, const
   });
   if (std::find(bad.begin(), bad.end(), char{1}) != bad.end())
     throw std::invalid_argument("bunches: invalid size, position, direction, time or wavelength "
-                                "(wavelength 0 needs a wavelength density)");
+                                "(wavelength 0 needs a wavelength density or law)");
   for (std::size_t c = 0; c < chunks; ++c)
     start[c + 1] += start[c];
 
-  const BunchResult out = allocate(start.back());
+  // Record thinning once, including the roulette draw needed after tracing.
+  std::vector<std::uint8_t> keep_flags(start.back());
+  std::vector<std::vector<double>> roulette_draws(chunks);
+  pool.run(chunks, [&](std::size_t c) {
+    found[c] = task.run(c * kChunkSize, std::min(in.n, (c + 1) * kChunkSize), BunchResult{}, 0,
+                        keep_flags.data() + start[c], roulette_draws[c], true);
+  });
+  std::vector<std::size_t> output_start(chunks + 1, 0);
+  for (std::size_t c = 0; c < chunks; ++c)
+    output_start[c + 1] = output_start[c] + found[c];
+  const BunchResult out = allocate(output_start.back());
 
-  // Second pass: chunk c writes from start[c] on.
+  // Trace survivors into their chunk's allocated range.
   pool.run(chunks, [&](std::size_t c) {
-    found[c] = task.run(c * kChunkSize, std::min(in.n, (c + 1) * kChunkSize), out, start[c]);
+    found[c] = task.run(c * kChunkSize, std::min(in.n, (c + 1) * kChunkSize), out, output_start[c],
+                        keep_flags.data() + start[c], roulette_draws[c], false);
   });
 
   std::vector<detail::Column> columns;
@@ -269,8 +331,8 @@ std::size_t trace_bunches(const OpticalModel &model, const BunchBlock &in, const
   detail::add_column(columns, out.wavelength_nm, 1);
   detail::add_column(columns, out.bunch_index, 1);
   detail::add_column(columns, out.sub_photon, 1);
-  start.pop_back();
-  return detail::compact_chunks(columns, start, found);
+  output_start.pop_back();
+  return detail::compact_chunks(columns, output_start, found);
 }
 
 } // namespace obdeect

{obdeect-0.6.0 → obdeect-0.7.0}/cpp/include/obdeect/model.hpp

@@ -4,6 +4,7 @@
 #include "obdeect/surfaces.hpp"
 #include "obdeect/table.hpp"
 
+#include <array>
 #include <cstdint>
 #include <optional>
 #include <stdexcept>
@@ -72,6 +73,8 @@ struct OpticalModel {
   Obscurers obscurers;
   std::optional<TelescopeTransmission> telescope_transmission;
   double propagation_group_index{1.0};
+  // Optical origin offset O [m, telescope frame]: a ground point P is traced at R P - O.
+  std::array<double, 3> axes_offset_m{};
 };
 
 } // namespace obdeect

{obdeect-0.6.0 → obdeect-0.7.0}/cpp/include/obdeect/model_json.hpp

@@ -439,8 +439,15 @@ inline Obscurer obscurer(const Node &node, std::vector<Plane> &planes) {
     root["format"].fail("expected '" + std::string(kModelFormat) + "'");
   const Node optics = root["optics"];
   (void)optics.object({"propagation_group_index", "telescope_transmission", "primary", "secondary",
-                       "secondary_blocks_incoming", "focal_surface", "obscurers"});
+                       "secondary_blocks_incoming", "focal_surface", "obscurers", "axes_offset_m"});
   OpticalModel model;
+  if (optics.has("axes_offset_m")) {
+    const auto offset = optics["axes_offset_m"].array();
+    if (offset.size() != 3)
+      optics["axes_offset_m"].fail("expected three components");
+    for (std::size_t i = 0; i < 3; ++i)
+      model.axes_offset_m[i] = offset[i].number();
+  }
   std::vector<std::uint32_t> ids;
   model.propagation_group_index = optics["propagation_group_index"].number();
   if (!(model.propagation_group_index >= 1.0))

{obdeect-0.6.0 → obdeect-0.7.0}/cpp/tests/test_model_json.cpp

@@ -1,9 +1,16 @@
 // Optical-model loading: valid documents load; every error names its path.
 #include "check.hpp"
 
+#include "obdeect/bunches.hpp"
 #include "obdeect/model_json.hpp"
 
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <vector>
 
 using namespace obdeect;
 
@@ -63,6 +70,79 @@ bool contains(const std::string &text, const std::string &part) {
   return text.find(part) != std::string::npos;
 }
 
+// Columns of one trace_bunches call without roulette: positions and their row count.
+struct Traced {
+  std::vector<double> position;
+  std::size_t rows{};
+};
+
+Traced trace_bunches_of(const OpticalModel &model, const BunchBlock &in, const BunchFrame &frame) {
+  Traced out;
+  ThreadPool pool(2);
+  std::vector<double> direction, time, weight, wavelength;
+  std::vector<std::uint64_t> bunch;
+  std::vector<std::uint32_t> sub;
+  const auto allocate = [&](std::size_t rows) {
+    out.position.resize(3 * rows);
+    direction.resize(3 * rows);
+    time.resize(rows);
+    weight.resize(rows);
+    wavelength.resize(rows);
+    bunch.resize(rows);
+    sub.resize(rows);
+    return BunchResult{out.position.data(), direction.data(), time.data(), weight.data(),
+                       wavelength.data(),   bunch.data(),     sub.data()};
+  };
+  out.rows = trace_bunches(model, in, frame, BunchOptions{}, 7, pool, allocate);
+  return out;
+}
+
+// The loaded axes offset is applied by the tracer: a ground point P is traced at R P - O, the
+// same as the model without offset and frame offset -O.
+void axes_offset_is_applied_by_the_tracer() {
+  const std::string key = "\"optics\": {";
+  std::string text = kValid;
+  text.insert(text.find(key) + key.size(), "\n    \"axes_offset_m\": [0.5, -0.2, 0.1],");
+  auto shifted = load_model(text);
+  auto plain = load_model(kValid);
+  CHECK((shifted.axes_offset_m == std::array<double, 3>{0.5, -0.2, 0.1}));
+  CHECK((plain.axes_offset_m == std::array<double, 3>{}));
+  // Without the obscurers, which would shadow the photons, the photons reach the primary.
+  shifted.obscurers = Obscurers(std::vector<Obscurer>{}, std::vector<Plane>{});
+  plain.obscurers = Obscurers(std::vector<Obscurer>{}, std::vector<Plane>{});
+
+  constexpr std::size_t n = 200;
+  std::vector<float> x(n), y(n), zero(n, 0.0F), size(n, 1.0F), wavelength(n, 400.0F), time(n, 0.0F);
+  std::vector<std::uint64_t> ids(n);
+  for (std::size_t i = 0; i < n; ++i) {
+    x[i] = static_cast<float>(0.2 + 0.6 * static_cast<double>(i) / n);
+    y[i] = static_cast<float>(-0.4 + 0.8 * static_cast<double>((37 * i) % n) / n);
+    ids[i] = i;
+  }
+  const BunchBlock in{x.data(),    y.data(),    zero.data(),       zero.data(), time.data(),
+                      zero.data(), size.data(), wavelength.data(), ids.data(),  n};
+  BunchFrame origin;
+  origin.plane_z = 30.0;
+  BunchFrame explicit_offset = origin;
+  explicit_offset.offset_m[0] = -0.5;
+  explicit_offset.offset_m[1] = 0.2;
+  explicit_offset.offset_m[2] = -0.1;
+
+  const Traced offset_model = trace_bunches_of(shifted, in, origin);
+  const Traced reference = trace_bunches_of(plain, in, explicit_offset);
+  CHECK(offset_model.rows > 0);
+  CHECK(offset_model.rows == reference.rows);
+  CHECK(offset_model.position.size() == reference.position.size());
+  double largest = 0.0;
+  for (std::size_t i = 0; i < std::min(offset_model.position.size(), reference.position.size());
+       ++i)
+    largest = std::max(largest, std::abs(offset_model.position[i] - reference.position[i]));
+  CHECK(largest <= 1e-12);
+  // The offset is not a no-op: the same model without it traces the photons elsewhere.
+  const Traced unshifted = trace_bunches_of(plain, in, origin);
+  CHECK(unshifted.position != offset_model.position);
+}
+
 } // namespace
 
 void all_tests() {
@@ -92,6 +172,9 @@ void all_tests() {
   CHECK(contains(error_after(R"("plane_z_m": 16.0)", R"("asphere_x": 1)"),
                  "focal_surface: unknown key"));
   CHECK(contains(error_after("\"optics\": {", "\"optics\": {,"), "JSON syntax error"));
+  CHECK(contains(error_after("\"optics\": {", "\"optics\": {\"axes_offset_m\": [1, 2],"),
+                 "expected three components"));
+  axes_offset_is_applied_by_the_tracer();
 }
 
 int main() { return run_checks(all_tests); }

{obdeect-0.6.0 → obdeect-0.7.0}/cpp/tests/test_trace.cpp

@@ -591,7 +591,53 @@ template <class F> bool throws_invalid_argument(F &&f) {
   return false;
 }
 
-// trace_bunches rejects a wavelength density reaching 0 nm and bad acceptance axes.
+// Output allocation equals the number of thinning survivors, including fractional bunches.
+void bunch_survivor_allocation() {
+  constexpr std::size_t n = 2050;
+  const auto model = single_facet(10.0, 0.5);
+  std::vector<float> zero(n, 0.0F), size(n, 2.5F), wavelength(n, 400.0F);
+  std::vector<std::uint64_t> ids(n);
+  for (std::size_t i = 0; i < n; ++i)
+    ids[i] = i;
+  BunchBlock in{zero.data(), zero.data(), zero.data(),       zero.data(), zero.data(),
+                zero.data(), size.data(), wavelength.data(), ids.data(),  n};
+  const Map2D acceptance{{100.0, 1000.0}, {0.0, 1.0}, std::vector<double>(4, 0.2), false};
+  BunchOptions options;
+  options.acceptance = &acceptance;
+  BunchFrame frame;
+  frame.plane_z = 20.0;
+  constexpr std::uint64_t seed = 42;
+  std::size_t expected = 0;
+  const double bound = response_bound(model, 400.0);
+  for (std::size_t i = 0; i < n; ++i)
+    for (std::uint32_t k = 0; k < 3; ++k)
+      expected +=
+          uniform4(seed, ids[i], Stream::thinning, k)[0] < (k == 2 ? 0.5 : 1.0) * 0.2 * bound;
+  for (const std::size_t threads : {1, 6}) {
+    ThreadPool pool(threads);
+    std::vector<double> position, direction, time, weight, lambda;
+    std::vector<std::uint64_t> bunch;
+    std::vector<std::uint32_t> sub;
+    std::size_t allocated = 0;
+    const auto allocate = [&](std::size_t rows) {
+      allocated = rows;
+      position.resize(3 * rows);
+      direction.resize(3 * rows);
+      time.resize(rows);
+      weight.resize(rows);
+      lambda.resize(rows);
+      bunch.resize(rows);
+      sub.resize(rows);
+      return BunchResult{position.data(), direction.data(), time.data(), weight.data(),
+                         lambda.data(),   bunch.data(),     sub.data()};
+    };
+    const auto written = trace_bunches(model, in, frame, options, seed, pool, allocate);
+    CHECK(allocated == expected);
+    CHECK(written <= allocated);
+  }
+}
+
+// trace_bunches rejects a wavelength density or law reaching 0 nm and bad acceptance axes.
 void bunch_option_validation() {
   const auto model = single_facet(10.0, 0.5);
   const float zero = 0.0F, one = 1.0F;
@@ -617,6 +663,11 @@ void bunch_option_validation() {
   options.wavelength_density = &from_below;
   CHECK(throws_invalid_argument([&] { run(options); }));
 
+  const InverseSquareLaw from_sub_nm{0.5, 0.75};
+  options.wavelength_density = nullptr;
+  options.wavelength_law = &from_sub_nm;
+  CHECK(throws_invalid_argument([&] { run(options); }));
+
   const double nan = std::numeric_limits<double>::quiet_NaN();
   const std::vector<double> ok{100.0, 1000.0};
   for (const auto &[x, y] : {std::pair{std::vector<double>{100.0, 100.0}, ok},
@@ -628,6 +679,17 @@ void bunch_option_validation() {
     bad.acceptance = &acceptance;
     CHECK(throws_invalid_argument([&] { run(bad); }));
   }
+
+  // An unsupported telescope transmission is rejected with ModelError before any bunch is traced.
+  auto unsupported = model;
+  unsupported.telescope_transmission = TelescopeTransmission{1.0, -1.0, 0.1, 2.0, 1.0};
+  bool model_error = false;
+  try {
+    trace_bunches(unsupported, in, frame, BunchOptions{}, 1, pool, allocate);
+  } catch (const ModelError &) {
+    model_error = true;
+  }
+  CHECK(model_error);
 }
 
 } // namespace
@@ -645,6 +707,7 @@ void all_tests() {
   thread_pool();
   thread_pool_exceptions();
   bunch_option_validation();
+  bunch_survivor_allocation();
 }
 
 int main() { return run_checks(all_tests); }