reboost 0.6.0__tar.gz → 0.6.1__tar.gz

{reboost-0.6.0 → reboost-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.6.0
+Version: 0.6.1
 Summary: New LEGEND Monte-Carlo simulation post-processing
 Author-email: Manuel Huber <info@manuelhu.de>, Toby Dixon <toby.dixon.23@ucl.ac.uk>, Luigi Pertoldi <gipert@pm.me>
 Maintainer: The LEGEND Collaboration
@@ -703,6 +703,7 @@ Requires-Dist: scipy
 Requires-Dist: numba
 Requires-Dist: legend-pydataobj>=1.14
 Requires-Dist: legend-pygeom-optics>=0.9.2
+Requires-Dist: legend-pygeom-tools>=0.0.11
 Requires-Dist: hist
 Requires-Dist: dbetto
 Requires-Dist: particle
@@ -722,8 +723,6 @@ Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: legend-pygeom-hpges; extra == "test"
-Requires-Dist: legend-pygeom-tools; extra == "test"
-Requires-Dist: pyg4ometry; extra == "test"
 Requires-Dist: pylegendtestdata>=0.6; extra == "test"
 Dynamic: license-file
 

{reboost-0.6.0 → reboost-0.6.1}/pyproject.toml

@@ -37,8 +37,9 @@ dependencies = [
     "numpy",
     "scipy",
     "numba",
-    "legend-pydataobj>=1.14",
-    "legend-pygeom-optics>=0.9.2",
+    "legend-pydataobj >=1.14",
+    "legend-pygeom-optics >=0.9.2",
+    "legend-pygeom-tools >=0.0.11",
     "hist",
     "dbetto",
     "particle",
@@ -75,10 +76,7 @@ test = [
     "pytest>=6.0",
     "pytest-cov",
     "legend-pygeom-hpges",
-    "legend-pygeom-tools",
-    "pyg4ometry",
     "pylegendtestdata>=0.6",
-
 ]
 
 [project.scripts]

{reboost-0.6.0 → reboost-0.6.1}/src/reboost/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.6.1'
+__version_tuple__ = version_tuple = (0, 6, 1)

{reboost-0.6.0 → reboost-0.6.1}/src/reboost/optmap/cli.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import argparse
-import json
 import logging
-from pathlib import Path
+
+import dbetto
 
 from ..log_utils import setup_log
 from ..utils import _check_input_file, _check_output_file
@@ -35,14 +35,18 @@ def optical_cli() -> None:
 
     subparsers = parser.add_subparsers(dest="command", required=True)
 
-    # STEP 1: build evt file from hit tier
-    evt_parser = subparsers.add_parser("evt", help="build evt file from remage hit file")
-    evt_parser.add_argument(
+    # STEP 1: build evt file from stp tier
+    evt_parser = subparsers.add_parser("evt", help="build optmap-evt file from remage stp file")
+    evt_parser_det_group = evt_parser.add_mutually_exclusive_group(required=True)
+    evt_parser_det_group.add_argument(
+        "--geom",
+        help="GDML geometry file",
+    )
+    evt_parser_det_group.add_argument(
         "--detectors",
-        help="file that contains a list of detector ids that are part of the input file",
-        required=True,
+        help="file with detector ids of all optical channels.",
     )
-    evt_parser.add_argument("input", help="input hit LH5 file", metavar="INPUT_HIT")
+    evt_parser.add_argument("input", help="input stp LH5 file", metavar="INPUT_STP")
     evt_parser.add_argument("output", help="output evt LH5 file", metavar="OUTPUT_EVT")
 
     # STEP 2a: build map file from evt tier
@@ -55,7 +59,20 @@ def optical_cli() -> None:
     )
     map_parser.add_argument(
         "--detectors",
-        help="file that contains a list of detector ids that will be produced as additional output maps.",
+        help=(
+            "file that contains a list of detector ids that will be produced as additional output maps."
+            + "By default, all channels will be included."
+        ),
+    )
+    map_parser_det_group = map_parser.add_mutually_exclusive_group(required=True)
+    map_parser_det_group.add_argument(
+        "--geom",
+        help="GDML geometry file",
+    )
+    map_parser_det_group.add_argument(
+        "--evt",
+        action="store_true",
+        help="the input file is already an optmap-evt file.",
     )
     map_parser.add_argument(
         "--n-procs",
@@ -69,7 +86,9 @@ def optical_cli() -> None:
         action="store_true",
         help="""Check map statistics after creation. default: %(default)s""",
     )
-    map_parser.add_argument("input", help="input evt LH5 file", metavar="INPUT_EVT", nargs="+")
+    map_parser.add_argument(
+        "input", help="input stp or optmap-evt LH5 file", metavar="INPUT_EVT", nargs="+"
+    )
     map_parser.add_argument("output", help="output map LH5 file", metavar="OUTPUT_MAP")
 
     # STEP 2b: view maps
@@ -171,7 +190,7 @@ def optical_cli() -> None:
     convolve_parser.add_argument(
         "--dist-mode",
         action="store",
-        default="multinomial+no-fano",
+        default="poisson+no-fano",
     )
     convolve_parser.add_argument("--output", help="output hit LH5 file", metavar="OUTPUT_HIT")
 
@@ -188,15 +207,18 @@ def optical_cli() -> None:
 
     # STEP 1: build evt file from hit tier
     if args.command == "evt":
-        from .evt import build_optmap_evt
+        from .evt import build_optmap_evt, get_optical_detectors_from_geom
 
-        _check_input_file(parser, args.detectors)
         _check_input_file(parser, args.input)
         _check_output_file(parser, args.output)
 
-        # load detector ids from a JSON array
-        with Path.open(Path(args.detectors)) as detectors_f:
-            detectors = json.load(detectors_f)
+        # load detector ids from the geometry.
+        if args.geom is not None:
+            _check_input_file(parser, args.geom, "geometry")
+            detectors = get_optical_detectors_from_geom(args.geom)
+        else:
+            _check_input_file(parser, args.detectors, "detectors")
+            detectors = dbetto.utils.load_dict(args.detectors)
 
         build_optmap_evt(args.input, args.output, detectors, args.bufsize)
 
@@ -209,23 +231,23 @@ def optical_cli() -> None:
 
         # load settings for binning from config file.
         _check_input_file(parser, args.input, "settings")
-        with Path.open(Path(args.settings)) as settings_f:
-            settings = json.load(settings_f)
+        settings = dbetto.utils.load_dict(args.settings)
 
-        chfilter = ()
+        chfilter = "*"
         if args.detectors is not None:
-            # load detector ids from a JSON array
-            with Path.open(Path(args.detectors)) as detectors_f:
-                chfilter = json.load(detectors_f)
+            # load detector ids from a JSON/YAML array
+            chfilter = dbetto.utils.load_dict(args.detectors)
 
         create_optical_maps(
             args.input,
             settings,
             args.bufsize,
+            is_stp_file=(not args.evt),
             chfilter=chfilter,
             output_lh5_fn=args.output,
             check_after_create=args.check,
             n_procs=args.n_procs,
+            geom_fn=args.geom,
         )
 
     # STEP 2b: view maps
@@ -251,8 +273,7 @@ def optical_cli() -> None:
 
         # load settings for binning from config file.
         _check_input_file(parser, args.input, "settings")
-        with Path.open(Path(args.settings)) as settings_f:
-            settings = json.load(settings_f)
+        settings = dbetto.utils.load_dict(args.settings)
 
         _check_input_file(parser, args.input)
         _check_output_file(parser, args.output)

{reboost-0.6.0 → reboost-0.6.1}/src/reboost/optmap/convolve.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import re
 
 import legendoptics.scintillate as sc
 import numba
@@ -24,8 +25,8 @@ OPTMAP_SUM_CH = -2
 
 def open_optmap(optmap_fn: str):
     maps = lh5.ls(optmap_fn)
-    # TODO: rewrite logic to only accept _<number> instead of a blacklist
-    det_ntuples = [m for m in maps if m not in ("all", "_hitcounts", "_hitcounts_exp", "all_orig")]
+    # only accept _<number> (/all is read separately)
+    det_ntuples = [m for m in maps if re.match(r"_\d+$", m)]
     detids = np.array([int(m.lstrip("_")) for m in det_ntuples])
     detidx = np.arange(0, detids.shape[0])
 
@@ -53,17 +54,25 @@ def open_optmap(optmap_fn: str):
 
     # give this check some numerical slack.
     if np.any(
-        ow[OPTMAP_SUM_CH][ow[OPTMAP_ANY_CH] >= 0] - ow[OPTMAP_ANY_CH][ow[OPTMAP_ANY_CH] >= 0]
+        np.abs(
+            ow[OPTMAP_SUM_CH][ow[OPTMAP_ANY_CH] >= 0] - ow[OPTMAP_ANY_CH][ow[OPTMAP_ANY_CH] >= 0]
+        )
         < -1e-15
     ):
         msg = "optical map does not fulfill relation sum(p_i) >= p_any"
         raise ValueError(msg)
 
-    # get the exponent from the optical map file
-    optmap_multi_det_exp = lh5.read("/_hitcounts_exp", optmap_fn).value
-    assert isinstance(optmap_multi_det_exp, float)
+    try:
+        # check the exponent from the optical map file
+        optmap_multi_det_exp = lh5.read("/_hitcounts_exp", optmap_fn).value
+        assert isinstance(optmap_multi_det_exp, float)
+        if np.isfinite(optmap_multi_det_exp):
+            msg = f"found finite _hitcounts_exp {optmap_multi_det_exp} which is not supported any more"
+            raise RuntimeError(msg)
+    except KeyError:  # the _hitcounts_exp might not be always present.
+        pass
 
-    return detids, detidx, optmap_edges, ow, optmap_multi_det_exp
+    return detids, detidx, optmap_edges, ow
 
 
 def iterate_stepwise_depositions(
@@ -71,7 +80,7 @@ def iterate_stepwise_depositions(
     optmap_for_convolve,
     scint_mat_params: sc.ComputedScintParams,
     rng: np.random.Generator = None,
-    dist: str = "multinomial",
+    dist: str = "poisson",
     mode: str = "no-fano",
 ):
     # those np functions are not supported by numba, but needed for efficient array access below.
@@ -144,7 +153,6 @@ def _iterate_stepwise_depositions(
     detidx,
     optmap_edges,
     optmap_weights,
-    optmap_multi_det_exp,
     scint_mat_params: sc.ComputedScintParams,
     dist: str,
     mode: str,
@@ -223,8 +231,6 @@ def _iterate_stepwise_depositions(
                 # we detect this energy deposition; we should at least get one photon out here!
 
                 detsel_size = 1
-                if np.isfinite(optmap_multi_det_exp):
-                    detsel_size = rng.geometric(1 - np.exp(-optmap_multi_det_exp))
 
                 px_sum = optmap_weights[OPTMAP_SUM_CH, cur_bins[0], cur_bins[1], cur_bins[2]]
                 assert px_sum >= 0.0  # should not be negative.
@@ -238,7 +244,7 @@ def _iterate_stepwise_depositions(
                         detp[d] = 0.0
                 det_no_stats += had_det_no_stats
 
-                # should be equivalent to rng.choice(detidx, size=(detsel_size, p=detp)
+                # should be equivalent to rng.choice(detidx, size=detsel_size, p=detp)
                 detsel = detidx[
                     np.searchsorted(np.cumsum(detp), rng.random(size=(detsel_size,)), side="right")
                 ]
@@ -339,7 +345,7 @@ def convolve(
     material: str,
     output_file: str | None = None,
     buffer_len: int = int(1e6),
-    dist_mode: str = "multinomial+no-fano",
+    dist_mode: str = "poisson+no-fano",
 ):
     if material not in ["lar", "pen"]:
         msg = f"unknown material {material} for scintillation"
@@ -356,13 +362,18 @@ def convolve(
             (1 * pint.get_application_registry().ns),  # dummy!
         )
 
-    log.info("opening map %s", map_file)
-    optmap_for_convolve = open_optmap(map_file)
-
     # special handling of distributions and flags.
     dist, mode = dist_mode.split("+")
-    assert dist in ("multinomial", "poisson")
-    assert mode in ("", "no-fano")
+    if (
+        dist not in ("multinomial", "poisson")
+        or mode not in ("", "no-fano")
+        or (dist == "poisson" and mode != "no-fano")
+    ):
+        msg = f"unsupported statistical distribution {dist_mode} for scintillation emission"
+        raise ValueError(msg)
+
+    log.info("opening map %s", map_file)
+    optmap_for_convolve = open_optmap(map_file)
 
     log.info("opening energy deposition hit output %s", edep_file)
     it = LH5Iterator(edep_file, edep_path, buffer_len=buffer_len)

{reboost-0.6.0 → reboost-0.6.1}/src/reboost/optmap/create.py

@@ -14,7 +14,12 @@ from numba import njit
 from numpy.typing import NDArray
 
 from ..log_utils import setup_log
-from .evt import EVT_TABLE_NAME, read_optmap_evt
+from .evt import (
+    EVT_TABLE_NAME,
+    generate_optmap_evt,
+    get_optical_detectors_from_geom,
+    read_optmap_evt,
+)
 from .optmap import OpticalMap
 
 log = logging.getLogger(__name__)
@@ -109,12 +114,13 @@ def _create_optical_maps_process_init(optmaps, log_level) -> None:
 
 
 def _create_optical_maps_process(
-    optmap_events_fn, buffer_len, all_det_ids, ch_idx_to_map_idx
+    optmap_events_fn, buffer_len, is_stp_file, all_det_ids, ch_idx_to_map_idx
 ) -> None:
     log.info("started worker task for %s", optmap_events_fn)
     x = _create_optical_maps_chunk(
         optmap_events_fn,
         buffer_len,
+        is_stp_file,
         all_det_ids,
         _shared_optmaps,
         ch_idx_to_map_idx,
@@ -124,9 +130,12 @@ def _create_optical_maps_process(
 
 
 def _create_optical_maps_chunk(
-    optmap_events_fn, buffer_len, all_det_ids, optmaps, ch_idx_to_map_idx
+    optmap_events_fn, buffer_len, is_stp_file, all_det_ids, optmaps, ch_idx_to_map_idx
 ) -> None:
-    optmap_events_it = read_optmap_evt(optmap_events_fn, buffer_len)
+    if not is_stp_file:
+        optmap_events_it = read_optmap_evt(optmap_events_fn, buffer_len)
+    else:
+        optmap_events_it = generate_optmap_evt(optmap_events_fn, all_det_ids, buffer_len)
 
     hits_per_primary = np.zeros(10, dtype=np.int64)
     hits_per_primary_len = 0
@@ -156,19 +165,24 @@ def create_optical_maps(
     optmap_events_fn: list[str],
     settings,
     buffer_len: int = int(5e6),
+    is_stp_file: bool = True,
     chfilter: tuple[str | int] | Literal["*"] = (),
     output_lh5_fn: str | None = None,
     after_save: Callable[[int, str, OpticalMap]] | None = None,
     check_after_create: bool = False,
     n_procs: int | None = 1,
+    geom_fn: str | None = None,
 ) -> None:
     """Create optical maps.
 
     Parameters
     ----------
     optmap_events_fn
-        list of filenames to lh5 files with a table ``/optmap_evt`` with columns ``{x,y,z}loc``
-        and one column (with numeric header) for each SiPM channel.
+        list of filenames to lh5 files, that can either be stp files from remage or "optmap-evt"
+        files with a table ``/optmap_evt`` with columns ``{x,y,z}loc`` and one column (with numeric
+        header) for each SiPM channel.
+    is_stp_file
+        if true, do convert a remage output file (stp file) on-the-fly to an optmap-evt file.
     chfilter
         tuple of detector ids that will be included in the resulting optmap. Those have to match
         the column names in ``optmap_events_fn``.
@@ -181,9 +195,13 @@ def create_optical_maps(
 
     use_shmem = n_procs is None or n_procs > 1
 
-    optmap_evt_columns = list(
-        lh5.read(EVT_TABLE_NAME, optmap_events_fn[0], start_row=0, n_rows=1).keys()
-    )  # peek into the (first) file to find column names.
+    if not is_stp_file:
+        optmap_evt_columns = list(
+            lh5.read(EVT_TABLE_NAME, optmap_events_fn[0], start_row=0, n_rows=1).keys()
+        )  # peek into the (first) file to find column names.
+    else:
+        optmap_evt_columns = [str(i) for i in get_optical_detectors_from_geom(geom_fn)]
+
     all_det_ids, optmaps, optmap_det_ids = _optmaps_for_channels(
         optmap_evt_columns, settings, chfilter=chfilter, use_shmem=use_shmem
     )
@@ -202,7 +220,9 @@ def create_optical_maps(
     if not use_shmem:
         for fn in optmap_events_fn:
             q.append(
-                _create_optical_maps_chunk(fn, buffer_len, all_det_ids, optmaps, ch_idx_to_map_idx)
+                _create_optical_maps_chunk(
+                    fn, buffer_len, is_stp_file, all_det_ids, optmaps, ch_idx_to_map_idx
+                )
             )
     else:
         ctx = mp.get_context("forkserver")
@@ -222,7 +242,7 @@ def create_optical_maps(
         for fn in optmap_events_fn:
             r = pool.apply_async(
                 _create_optical_maps_process,
-                args=(fn, buffer_len, all_det_ids, ch_idx_to_map_idx),
+                args=(fn, buffer_len, is_stp_file, all_det_ids, ch_idx_to_map_idx),
             )
             pool_results.append((r, fn))
 
@@ -401,6 +421,9 @@ def merge_optical_maps(
     hits_per_primary = np.zeros(10, dtype=np.int64)
     hits_per_primary_len = 0
     for optmap_fn in map_l5_files:
+        if "_hitcounts" not in lh5.ls(optmap_fn):
+            log.warning("skipping _hitcounts calculations, missing in file %s", optmap_fn)
+            return
         hitcounts = lh5.read("/_hitcounts", optmap_fn)
         assert isinstance(hitcounts, Array)
         hits_per_primary[0 : len(hitcounts)] += hitcounts
@@ -417,13 +440,18 @@ def merge_optical_maps(
 def check_optical_map(map_l5_file: str):
     """Run a health check on the map file.
 
-    This checks for consistency, and output details on map statistics.
+    This checks for consistency, and outputs details on map statistics.
     """
-    if lh5.read("_hitcounts_exp", lh5_file=map_l5_file).value != np.inf:
-        log.error("unexpected hitcount exp not equal to positive infinity")
+    if "_hitcounts_exp" not in lh5.ls(map_l5_file):
+        log.info("no _hitcounts_exp found")
+    elif lh5.read("_hitcounts_exp", lh5_file=map_l5_file).value != np.inf:
+        log.error("unexpected _hitcounts_exp not equal to positive infinity")
         return
-    if lh5.read("_hitcounts", lh5_file=map_l5_file).nda.shape != (2,):
-        log.error("unexpected hitcount shape")
+
+    if "_hitcounts" not in lh5.ls(map_l5_file):
+        log.info("no _hitcounts found")
+    elif lh5.read("_hitcounts", lh5_file=map_l5_file).nda.shape != (2,):
+        log.error("unexpected _hitcounts shape")
         return
 
     all_binning = None
@@ -477,4 +505,5 @@ def rebin_optical_maps(map_l5_file: str, output_lh5_file: str, factor: int):
 
     # just copy hitcounts exponent.
     for dset in ("_hitcounts_exp", "_hitcounts"):
-        lh5.write(lh5.read(dset, lh5_file=map_l5_file), dset, lh5_file=output_lh5_file)
+        if dset in lh5.ls(map_l5_file):
+            lh5.write(lh5.read(dset, lh5_file=map_l5_file), dset, lh5_file=output_lh5_file)

{reboost-0.6.0 → reboost-0.6.1}/src/reboost/optmap/evt.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Iterable
+from collections.abc import Generator, Iterable
 from pathlib import Path
 
 import numpy as np
@@ -14,20 +14,18 @@ log = logging.getLogger(__name__)
 EVT_TABLE_NAME = "optmap_evt"
 
 
-def build_optmap_evt(
-    lh5_in_file: str, lh5_out_file: str, detectors: Iterable[str | int], buffer_len: int = int(5e6)
-) -> None:
+def generate_optmap_evt(
+    lh5_in_file: str, detectors: Iterable[str | int], buffer_len: int = int(5e6)
+) -> Generator[Table, None, None]:
     """Create a faster map for lookup of the hits in each detector, for each primary event."""
     log.info("reading file %s", lh5_in_file)
 
-    lh5_out_file = Path(lh5_out_file)
-    lh5_out_file_tmp = lh5_out_file.with_stem(".evt-tmp." + lh5_out_file.stem)
-    if lh5_out_file_tmp.exists():
-        msg = f"temporary output file {lh5_out_file_tmp} already exists"
-        raise RuntimeError(msg)
     vert_it = LH5Iterator(lh5_in_file, "vtx", buffer_len=buffer_len)
     opti_it = LH5Iterator(lh5_in_file, "stp/optical", buffer_len=buffer_len)
 
+    if len(detectors) == 0:
+        msg = "detector array cannot be empty for optmap-evt building"
+        raise ValueError(msg)
     detectors = [str(d) for d in detectors]
     for d in detectors:
         if not d.isnumeric():
@@ -35,11 +33,11 @@ def build_optmap_evt(
 
     vert_df = None
     vert_df_bounds = None
-    vert_it_count = 0
     hits_expected = 0
+    had_last_chunk = False
 
-    def _store_vert_df():
-        nonlocal vert_df
+    def _store_vert_df(last_chunk: bool) -> Generator[Table, None, None]:
+        nonlocal vert_df, had_last_chunk
         if vert_df is None:
             return
 
@@ -49,8 +47,8 @@ def build_optmap_evt(
             hits_sum += np.sum(vert_df[d])
         assert hits_sum == hits_expected
 
-        log.info("store evt file %s (%d)", lh5_out_file_tmp, vert_it_count - 1)
-        lh5.write(Table(vert_df), name=EVT_TABLE_NAME, lh5_file=lh5_out_file_tmp, wo_mode="append")
+        yield Table(vert_df)
+        had_last_chunk = last_chunk
         vert_df = None
 
     # helper function for "windowed join". while iterating the optical hits, we have to
@@ -59,8 +57,8 @@ def build_optmap_evt(
     # This function follows the assumption, that the output event ids are at least "somewhat"
     # monotonic, i.e. later chunks do not contain lower evtids than the previous chunk(s).
     # Going back is not implemented.
-    def _ensure_vert_df(vert_it: LH5Iterator, evtid: int) -> None:
-        nonlocal vert_df, vert_df_bounds, vert_it_count, hits_expected
+    def _ensure_vert_df(vert_it: LH5Iterator, evtid: int) -> Generator[Table, None, None]:
+        nonlocal vert_df, vert_df_bounds, hits_expected
 
         # skipping multiple chunks is possible in sparsely populated simulations.
         while vert_df_bounds is None or evtid > vert_df_bounds[1] or evtid < vert_df_bounds[0]:
@@ -74,9 +72,8 @@ def build_optmap_evt(
             # here, evtid > vert_df_bounds[1] (or vert_df_bounds is still None). We need to fetch
             # the next event table chunk.
 
-            vert_it_count += 1
             # we might have filled a dataframe, save it to disk.
-            _store_vert_df()
+            yield from _store_vert_df(last_chunk=False)
 
             # read the next vertex chunk into memory.
             vert_df = next(vert_it).view_as("pd")
@@ -98,11 +95,28 @@ def build_optmap_evt(
         log.info("build evt table (%d)", opti_it_count)
 
         for t in opti_df[["evtid", "det_uid"]].itertuples(name=None, index=False):
-            _ensure_vert_df(vert_it, t[0])
+            yield from _ensure_vert_df(vert_it, t[0])
             vert_df.loc[t[0], str(t[1])] += 1
             hits_expected += 1
 
-    _store_vert_df()  # store the last chunk.
+    yield from _store_vert_df(last_chunk=True)  # store the last chunk.
+
+    assert had_last_chunk, "did not reach last chunk in optmap-evt building"
+
+
+def build_optmap_evt(
+    lh5_in_file: str, lh5_out_file: str, detectors: Iterable[str | int], buffer_len: int = int(5e6)
+) -> None:
+    """Create a faster map for lookup of the hits in each detector, for each primary event."""
+    lh5_out_file = Path(lh5_out_file)
+    lh5_out_file_tmp = lh5_out_file.with_stem(".evt-tmp." + lh5_out_file.stem)
+    if lh5_out_file_tmp.exists():
+        msg = f"temporary output file {lh5_out_file_tmp} already exists"
+        raise RuntimeError(msg)
+
+    for vert_it_count, chunk in enumerate(generate_optmap_evt(lh5_in_file, detectors, buffer_len)):
+        log.info("store evt file %s (%d)", lh5_out_file_tmp, vert_it_count - 1)
+        lh5.write(Table(chunk), name=EVT_TABLE_NAME, lh5_file=lh5_out_file_tmp, wo_mode="append")
 
     # after finishing the output file, rename to the actual output file name.
     if lh5_out_file.exists():
@@ -111,5 +125,14 @@ def build_optmap_evt(
     lh5_out_file_tmp.rename(lh5_out_file)
 
 
+def get_optical_detectors_from_geom(geom_fn) -> list[int]:
+    import pyg4ometry
+    import pygeomtools
+
+    geom_registry = pyg4ometry.gdml.Reader(geom_fn).getRegistry()
+    detectors = pygeomtools.get_all_sensvols(geom_registry)
+    return [d.uid for d in detectors.values() if d.detector_type == "optical"]
+
+
 def read_optmap_evt(lh5_file: str, buffer_len: int = int(5e6)) -> LH5Iterator:
     return LH5Iterator(lh5_file, EVT_TABLE_NAME, buffer_len=buffer_len)

{reboost-0.6.0 → reboost-0.6.1}/src/reboost.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.6.0
+Version: 0.6.1
 Summary: New LEGEND Monte-Carlo simulation post-processing
 Author-email: Manuel Huber <info@manuelhu.de>, Toby Dixon <toby.dixon.23@ucl.ac.uk>, Luigi Pertoldi <gipert@pm.me>
 Maintainer: The LEGEND Collaboration
@@ -703,6 +703,7 @@ Requires-Dist: scipy
 Requires-Dist: numba
 Requires-Dist: legend-pydataobj>=1.14
 Requires-Dist: legend-pygeom-optics>=0.9.2
+Requires-Dist: legend-pygeom-tools>=0.0.11
 Requires-Dist: hist
 Requires-Dist: dbetto
 Requires-Dist: particle
@@ -722,8 +723,6 @@ Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: legend-pygeom-hpges; extra == "test"
-Requires-Dist: legend-pygeom-tools; extra == "test"
-Requires-Dist: pyg4ometry; extra == "test"
 Requires-Dist: pylegendtestdata>=0.6; extra == "test"
 Dynamic: license-file
 

{reboost-0.6.0 → reboost-0.6.1}/src/reboost.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ tests/test_cli.py
 tests/test_core.py
 tests/test_math.py
 tests/test_optmap.py
+tests/test_optmap_dets.gdml
 tests/test_profile.py
 tests/test_shape.py
 tests/test_units.py

{reboost-0.6.0 → reboost-0.6.1}/src/reboost.egg-info/requires.txt

@@ -5,6 +5,7 @@ scipy
 numba
 legend-pydataobj>=1.14
 legend-pygeom-optics>=0.9.2
+legend-pygeom-tools>=0.0.11
 hist
 dbetto
 particle
@@ -27,6 +28,4 @@ pre-commit
 pytest>=6.0
 pytest-cov
 legend-pygeom-hpges
-legend-pygeom-tools
-pyg4ometry
 pylegendtestdata>=0.6

{reboost-0.6.0 → reboost-0.6.1}/tests/test_optmap.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pathlib import Path
+
 import numpy as np
 import pytest
 from lgdo import Array, Table, lh5
@@ -49,13 +51,13 @@ def tbl_hits(tmptestdir):
     hit_file = tmptestdir / "hit.lh5"
     lh5.write(tbl_vertices, name="vtx", lh5_file=hit_file, wo_mode="overwrite_file")
     lh5.write(tbl_optical, name="stp/optical", lh5_file=hit_file, wo_mode="overwrite")
-    return hit_file
+    return (str(hit_file),)
 
 
 def test_optmap_evt(tbl_hits, tmptestdir):
     evt_out_file = tmptestdir / "evt-out.lh5"
     build_optmap_evt(
-        str(tbl_hits),
+        tbl_hits[0],
         str(evt_out_file),
         detectors=("1", "002", "003"),
         buffer_len=20,  # note: shorter window sizes (e.g. 10) do not work.
@@ -67,16 +69,17 @@ def tbl_evt_fns(tmptestdir) -> tuple[str]:
     evt_count = 100
     rng = np.random.default_rng(1234)
     loc = rng.uniform(size=(evt_count, 3))
-    hits = rng.geometric(p=0.9, size=(evt_count, 3)) - 1
+    # hits = rng.geometric(p=0.9, size=(evt_count, 3)) - 1
+    hits = rng.choice([1, 2, 3], size=evt_count)
 
     tbl_evt = Table(
         {
             "xloc": Array(loc[:, 0]),
             "yloc": Array(loc[:, 1]),
             "zloc": Array(loc[:, 2]),
-            "001": Array(hits[:, 0]),
-            "002": Array(hits[:, 1]),
-            "003": Array(hits[:, 2]),
+            "001": Array((hits == 1).astype(int)),
+            "002": Array((hits == 2).astype(int)),
+            "003": Array((hits == 3).astype(int)),
         }
     )
 
@@ -86,43 +89,56 @@ def tbl_evt_fns(tmptestdir) -> tuple[str]:
 
 
 @pytest.mark.filterwarnings("ignore::scipy.optimize._optimize.OptimizeWarning")
-def test_optmap_create(tbl_evt_fns):
+@pytest.mark.parametrize("input_fixture", ["tbl_evt_fns", "tbl_hits"])
+def test_optmap_create(input_fixture, request):
     settings = {
         "range_in_m": [[0, 1], [0, 1], [0, 1]],
         "bins": [10, 10, 10],
     }
 
+    extra_params = {
+        "is_stp_file": input_fixture == "tbl_hits",
+        "geom_fn": (
+            f"{Path(__file__).parent}/test_optmap_dets.gdml" if input_fixture == "tbl_hits" else ""
+        ),
+    }
+    input_fixture = request.getfixturevalue(input_fixture)
+
     # test creation only with the summary map.
     create_optical_maps(
-        tbl_evt_fns,
+        input_fixture,
         settings,
         chfilter=(),
         output_lh5_fn=None,
+        **extra_params,
     )
 
     # test creation with all detectors.
     create_optical_maps(
-        tbl_evt_fns,
+        input_fixture,
         settings,
         chfilter=("001", "002", "003"),
         output_lh5_fn=None,
+        **extra_params,
     )
 
     # test creation with some detectors.
     create_optical_maps(
-        tbl_evt_fns,
+        input_fixture,
         settings,
         chfilter=("001"),
         output_lh5_fn=None,
+        **extra_params,
     )
 
     # test creation on multiple cores.
     create_optical_maps(
-        tbl_evt_fns,
+        input_fixture,
         settings,
         chfilter=("001", "002", "003"),
         output_lh5_fn=None,
         n_procs=2,
+        **extra_params,
     )
 
 
@@ -139,6 +155,7 @@ def test_optmap_merge(tbl_evt_fns, tmptestdir):
         settings,
         chfilter=("001", "002", "003"),
         output_lh5_fn=map1_fn,
+        is_stp_file=False,
     )
     map2_fn = str(tmptestdir / "map2.lh5")
     create_optical_maps(
@@ -146,6 +163,7 @@ def test_optmap_merge(tbl_evt_fns, tmptestdir):
         settings,
         chfilter=("001", "002", "003"),
         output_lh5_fn=map2_fn,
+        is_stp_file=False,
     )
 
     # test in sequential mode.
@@ -170,6 +188,7 @@ def test_optmap_rebin(tbl_evt_fns, tmptestdir):
         settings,
         chfilter=("001", "002", "003"),
         output_lh5_fn=map1_fn,
+        is_stp_file=False,
     )
 
     map_rebinned_fn = str(tmptestdir / "map-rebinned.lh5")
@@ -219,6 +238,7 @@ def test_optmap_convolve(tbl_evt_fns, tbl_edep, tmptestdir):
         settings,
         chfilter=("001"),
         output_lh5_fn=map_fn,
+        is_stp_file=False,
     )
 
     out_fn = str(tmptestdir / "convolved.lh5")
@@ -245,6 +265,7 @@ def test_optmap_save_and_load(tmptestdir, tbl_evt_fns):
         settings,
         chfilter=("001", "002", "003"),
         output_lh5_fn=map_fn,
+        is_stp_file=False,
     )
 
     assert list_optical_maps(map_fn) == ["_001", "_002", "_003", "all"]

reboost-0.6.1/tests/test_optmap_dets.gdml

@@ -0,0 +1,24 @@
+<?xml version="1.0" ?>
+<gdml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://cern.ch/service-spi/app/releases/GDML/schema/gdml.xsd">
+  <materials></materials>
+  <solids>
+    <box name="world" x="20" y="20" z="20" lunit="m"/>
+  </solids>
+  <structure>
+    <volume name="world">
+      <materialref ref="G4_Galactic"/>
+      <solidref ref="world"/>
+    </volume>
+  </structure>
+	<userinfo>
+	  <auxiliary auxtype="RMG_detector_meta" auxvalue=""/>
+		<auxiliary auxtype="RMG_detector" auxvalue="optical">
+			<auxiliary auxtype="S01" auxvalue="001"/>
+			<auxiliary auxtype="S02" auxvalue="002"/>
+			<auxiliary auxtype="S03" auxvalue="003"/>
+		</auxiliary>
+	</userinfo>
+	<setup>
+	  <world ref="world" />
+	</setup>
+</gdml>