reboost 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

reboost/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.7.0'
-__version_tuple__ = version_tuple = (0, 7, 0)
+__version__ = version = '0.8.0'
+__version_tuple__ = version_tuple = (0, 8, 0)
 
 __commit_id__ = commit_id = None

reboost/core.py

@@ -325,8 +325,6 @@ def get_one_detector_mapping(
         out_list = list(output_detector_expression)
 
     for expression_tmp in out_list:
-        func, globs = utils.get_function_string(expression_tmp)
-
         # if no package was imported its just a name
         try:
             objs = evaluate_object(expression_tmp, local_dict={"ARGS": args, "OBJECTS": objects})

reboost/optmap/cli.py

@@ -35,21 +35,7 @@ def optical_cli() -> None:
 
     subparsers = parser.add_subparsers(dest="command", required=True)
 
-    # 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 with detector ids of all optical channels.",
-    )
-    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
+    # STEP 1a: build map file from evt tier
     map_parser = subparsers.add_parser("createmap", help="build optical map from evt file(s)")
     map_parser.add_argument(
         "--settings",
@@ -91,42 +77,67 @@ def optical_cli() -> None:
     )
     map_parser.add_argument("output", help="output map LH5 file", metavar="OUTPUT_MAP")
 
-    # STEP 2b: view maps
-    mapview_parser = subparsers.add_parser("viewmap", help="view optical map")
+    # STEP 1b: view maps
+    mapview_parser = subparsers.add_parser(
+        "viewmap",
+        help="view optical map (arrows: navigate slices/axes, 'c': channel selector)",
+        formatter_class=argparse.RawTextHelpFormatter,
+        description=(
+            "Interactively view optical maps stored in LH5 files.\n\n"
+            "Keyboard controls:\n"
+            "  left/right  - previous/next slice along the current axis\n"
+            "  up/down     - switch slicing axis (x, y, z)\n"
+            "  c           - open channel selector overlay to switch detector map\n\n"
+            "Display notes:\n"
+            "  - Cells where no primary photons were simulated are shown in white.\n"
+            "  - Cells where no photons were detected are shown in grey.\n"
+            "  - Cells with values above the colormap maximum are shown in red.\n"
+            "  - Use --hist to choose which histogram to display. 'prob_unc_rel' shows the\n"
+            "    relative uncertainty prob_unc / prob where defined.\n"
+            "  - Use --divide to show the ratio of two map files (this/other)."
+        ),
+        epilog=(
+            "Examples:\n"
+            "  reboost-optical viewmap mymap.lh5\n"
+            "  reboost-optical viewmap mymap.lh5 --channel _1067205\n"
+            "  reboost-optical viewmap mymap.lh5 --hist prob_unc_rel --min 0 --max 1\n"
+            "  reboost-optical viewmap mymap.lh5 --divide other.lh5 --title 'Comparison'"
+        ),
+    )
     mapview_parser.add_argument("input", help="input map LH5 file", metavar="INPUT_MAP")
     mapview_parser.add_argument(
         "--channel",
         action="store",
         default="all",
-        help="default: %(default)s",
+        help="channel to display ('all' or '_<detid>'). Press 'c' in the viewer to switch. default: %(default)s",
     )
     mapview_parser.add_argument(
         "--hist",
-        choices=("nr_gen", "nr_det", "p_det", "p_det_err", "p_det_err_rel"),
+        choices=("_nr_gen", "_nr_det", "prob", "prob_unc", "prob_unc_rel"),
         action="store",
-        default="p_det",
+        default="prob",
         help="select optical map histogram to show. default: %(default)s",
     )
     mapview_parser.add_argument(
         "--divide",
         action="store",
-        help="default: none",
+        help="divide by another map file before display (ratio). default: none",
     )
     mapview_parser.add_argument(
         "--min",
         default=1e-4,
         type=(lambda s: s if s == "auto" else float(s)),
-        help="colormap min value. default: %(default)e",
+        help="colormap min value; use 'auto' for automatic scaling. default: %(default)e",
     )
     mapview_parser.add_argument(
         "--max",
         default=1e-2,
         type=(lambda s: s if s == "auto" else float(s)),
-        help="colormap max value. default: %(default)e",
+        help="colormap max value; use 'auto' for automatic scaling. default: %(default)e",
     )
     mapview_parser.add_argument("--title", help="title of figure. default: stem of filename")
 
-    # STEP 2c: merge maps
+    # STEP 1c: merge maps
     mapmerge_parser = subparsers.add_parser("mergemap", help="merge optical maps")
     mapmerge_parser.add_argument(
         "input", help="input map LH5 files", metavar="INPUT_MAP", nargs="+"
@@ -151,49 +162,10 @@ def optical_cli() -> None:
         help="""Check map statistics after creation. default: %(default)s""",
     )
 
-    # STEP 2d: check map
+    # STEP 1d: check map
     checkmap_parser = subparsers.add_parser("checkmap", help="check optical maps")
     checkmap_parser.add_argument("input", help="input map LH5 file", metavar="INPUT_MAP")
 
-    # STEP 3: convolve with hits from non-optical simulations
-    convolve_parser = subparsers.add_parser(
-        "convolve", help="convolve non-optical hits with optical map"
-    )
-    convolve_parser.add_argument(
-        "--material",
-        action="store",
-        choices=("lar", "pen", "fiber"),
-        default="lar",
-        help="default: %(default)s",
-    )
-    convolve_parser.add_argument(
-        "--map",
-        action="store",
-        required=True,
-        metavar="INPUT_MAP",
-        help="input map LH5 file",
-    )
-    convolve_parser.add_argument(
-        "--edep",
-        action="store",
-        required=True,
-        metavar="INPUT_EDEP",
-        help="input non-optical LH5 hit file",
-    )
-    convolve_parser.add_argument(
-        "--edep-lgdo",
-        action="store",
-        required=True,
-        metavar="LGDO_PATH",
-        help="path to LGDO inside non-optical LH5 hit file (e.g. /stp/detXX)",
-    )
-    convolve_parser.add_argument(
-        "--dist-mode",
-        action="store",
-        default="poisson+no-fano",
-    )
-    convolve_parser.add_argument("--output", help="output hit LH5 file", metavar="OUTPUT_HIT")
-
     # STEP X: rebin maps
     rebin_parser = subparsers.add_parser("rebin", help="rebin optical maps")
     rebin_parser.add_argument("input", help="input map LH5 files", metavar="INPUT_MAP")
@@ -205,24 +177,7 @@ def optical_cli() -> None:
     log_level = (None, logging.INFO, logging.DEBUG)[min(args.verbose, 2)]
     setup_log(log_level)
 
-    # STEP 1: build evt file from hit tier
-    if args.command == "evt":
-        from .evt import build_optmap_evt, get_optical_detectors_from_geom
-
-        _check_input_file(parser, args.input)
-        _check_output_file(parser, args.output)
-
-        # 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)
-
-    # STEP 2a: build map file from evt tier
+    # STEP 1a: build map file from evt tier
     if args.command == "createmap":
         from .create import create_optical_maps
 
@@ -250,7 +205,7 @@ def optical_cli() -> None:
             geom_fn=args.geom,
         )
 
-    # STEP 2b: view maps
+    # STEP 1b: view maps
     if args.command == "viewmap":
         from .mapview import view_optmap
 
@@ -267,7 +222,7 @@ def optical_cli() -> None:
             histogram_choice=args.hist,
         )
 
-    # STEP 2c: merge maps
+    # STEP 1c: merge maps
     if args.command == "mergemap":
         from .create import merge_optical_maps
 
@@ -281,29 +236,13 @@ def optical_cli() -> None:
             args.input, args.output, settings, check_after_create=args.check, n_procs=args.n_procs
         )
 
-    # STEP 2d: check maps
+    # STEP 1d: check maps
     if args.command == "checkmap":
         from .create import check_optical_map
 
         _check_input_file(parser, args.input)
         check_optical_map(args.input)
 
-    # STEP 3: convolve with hits from non-optical simulations
-    if args.command == "convolve":
-        from .convolve import convolve
-
-        _check_input_file(parser, [args.map, args.edep])
-        _check_output_file(parser, args.output, optional=True)
-        convolve(
-            args.map,
-            args.edep,
-            args.edep_lgdo,
-            args.material,
-            args.output,
-            args.bufsize,
-            dist_mode=args.dist_mode,
-        )
-
     # STEP X: rebin maps
     if args.command == "rebin":
         from .create import rebin_optical_maps

reboost/optmap/convolve.py

@@ -10,12 +10,9 @@ import numba
 import numpy as np
 from legendoptics import fibers, lar, pen
 from lgdo import lh5
-from lgdo.lh5 import LH5Iterator
 from lgdo.types import Array, Histogram, Table
-from numba import njit, prange
-from numpy.lib.recfunctions import structured_to_unstructured
+from numba import njit
 from numpy.typing import NDArray
-from pint import Quantity
 
 from .numba_pdg import numba_pdgid_funcs
 
@@ -42,7 +39,7 @@ def open_optmap(optmap_fn: str) -> OptmapForConvolve:
     detids = np.array([int(m.lstrip("_")) for m in det_ntuples])
     detidx = np.arange(0, detids.shape[0])
 
-    optmap_all = lh5.read("/all/p_det", optmap_fn)
+    optmap_all = lh5.read("/all/prob", optmap_fn)
     assert isinstance(optmap_all, Histogram)
     optmap_edges = tuple([b.edges for b in optmap_all.binning])
 
@@ -50,7 +47,7 @@ def open_optmap(optmap_fn: str) -> OptmapForConvolve:
     # 0, ..., len(detidx)-1 AND OPTMAP_ANY_CH might be negative.
     ow[OPTMAP_ANY_CH] = optmap_all.weights.nda
     for i, nt in zip(detidx, det_ntuples, strict=True):
-        optmap = lh5.read(f"/{nt}/p_det", optmap_fn)
+        optmap = lh5.read(f"/{nt}/prob", optmap_fn)
         assert isinstance(optmap, Histogram)
         ow[i] = optmap.weights.nda
 
@@ -98,7 +95,7 @@ def open_optmap_single(optmap_fn: str, spm_det_uid: int) -> OptmapForConvolve:
     except lh5.exceptions.LH5DecodeError:  # the _hitcounts_exp might not be always present.
         pass
 
-    optmap = lh5.read(f"/_{spm_det_uid}/p_det", optmap_fn)
+    optmap = lh5.read(f"/_{spm_det_uid}/prob", optmap_fn)
     assert isinstance(optmap, Histogram)
     ow = np.empty((1, *optmap.weights.nda.shape), dtype=np.float64)
     ow[0] = optmap.weights.nda
@@ -107,67 +104,13 @@ def open_optmap_single(optmap_fn: str, spm_det_uid: int) -> OptmapForConvolve:
     return OptmapForConvolve(np.array([spm_det_uid]), np.array([0]), optmap_edges, ow)
 
 
-def iterate_stepwise_depositions(
-    edep_df: np.rec.recarray,
-    optmap: OptmapForConvolve,
-    scint_mat_params: sc.ComputedScintParams,
-    rng: np.random.Generator = None,
-    dist: str = "poisson",
-    mode: str = "no-fano",
-):
-    # those np functions are not supported by numba, but needed for efficient array access below.
-    if "xloc_pre" in edep_df.dtype.names:
-        x0 = structured_to_unstructured(edep_df[["xloc_pre", "yloc_pre", "zloc_pre"]], np.float64)
-        x1 = structured_to_unstructured(
-            edep_df[["xloc_post", "yloc_post", "zloc_post"]], np.float64
-        )
-    else:
-        x0 = structured_to_unstructured(edep_df[["xloc", "yloc", "zloc"]], np.float64)
-        x1 = None
-
-    rng = np.random.default_rng() if rng is None else rng
-    output_map, res = _iterate_stepwise_depositions(
-        edep_df,
-        x0,
-        x1,
-        rng,
-        optmap.detids,
-        optmap.detidx,
-        optmap.edges,
-        optmap.weights,
-        scint_mat_params,
-        dist,
-        mode,
-    )
-    if res["any_no_stats"] > 0 or res["det_no_stats"] > 0:
-        log.warning(
-            "had edep out in voxels without stats: %d (%.2f%%)",
-            res["any_no_stats"],
-            res["det_no_stats"],
-        )
-    if res["oob"] > 0:
-        log.warning(
-            "had edep out of map bounds: %d (%.2f%%)",
-            res["oob"],
-            (res["oob"] / (res["ib"] + res["oob"])) * 100,
-        )
-    log.debug(
-        "VUV_primary %d ->hits_any %d ->hits %d (%.2f %% primaries detected)",
-        res["vuv_primary"],
-        res["hits_any"],
-        res["hits"],
-        (res["hits_any"] / res["vuv_primary"]) * 100,
-    )
-    log.debug("hits/hits_any %.2f", res["hits"] / res["hits_any"])
-    return output_map
-
-
 def iterate_stepwise_depositions_pois(
     edep_hits: ak.Array,
     optmap: OptmapForConvolve,
     scint_mat_params: sc.ComputedScintParams,
     det_uid: int,
     map_scaling: float = 1,
+    map_scaling_sigma: float = 0,
     rng: np.random.Generator | None = None,
 ):
     if edep_hits.particle.ndim == 1:
@@ -180,6 +123,7 @@ def iterate_stepwise_depositions_pois(
         rng,
         np.where(optmap.detids == det_uid)[0][0],
         map_scaling,
+        map_scaling_sigma,
         optmap.edges,
         optmap.weights,
         scint_mat_params,
@@ -254,184 +198,6 @@ def _pdgid_to_particle(pdgid: int) -> sc.ParticleIndex:
 __counts_per_bin_key_type = numba.types.UniTuple(numba.types.int64, 3)
 
 
-# - run with NUMBA_FULL_TRACEBACKS=1 NUMBA_BOUNDSCHECK=1 for testing/checking
-# - cache=True does not work with outer prange, i.e. loading the cached file fails (numba bug?)
-# - the output dictionary is not threadsafe, so parallel=True is not working with it.
-@njit(parallel=False, nogil=True, cache=True)
-def _iterate_stepwise_depositions(
-    edep_df,
-    x0,
-    x1,
-    rng,
-    detids,
-    detidx,
-    optmap_edges,
-    optmap_weights,
-    scint_mat_params: sc.ComputedScintParams,
-    dist: str,
-    mode: str,
-):
-    pdgid_map = {}
-    output_map = {}
-    oob = ib = ph_cnt = ph_det = ph_det2 = any_no_stats = det_no_stats = 0  # for statistics
-    for rowid in prange(edep_df.shape[0]):
-        # if rowid % 100000 == 0:
-        #     print(rowid)
-        t = edep_df[rowid]
-
-        # get the particle information.
-        if t.particle not in pdgid_map:
-            pdgid_map[t.particle] = (_pdgid_to_particle(t.particle), _pdg_func.charge(t.particle))
-
-        # do the scintillation.
-        part, charge = pdgid_map[t.particle]
-
-        # if we have both pre and post step points use them
-        # else pass as None
-
-        scint_times = sc.scintillate(
-            scint_mat_params,
-            x0[rowid],
-            x1[rowid] if x1 is not None else None,
-            t.v_pre if x1 is not None else None,
-            t.v_post if x1 is not None else None,
-            t.time,
-            part,
-            charge,
-            t.edep,
-            rng,
-            emission_term_model=("poisson" if mode == "no-fano" else "normal_fano"),
-        )
-        if scint_times.shape[0] == 0:  # short-circuit if we have no photons at all.
-            continue
-        ph_cnt += scint_times.shape[0]
-
-        # coordinates -> bins of the optical map.
-        bins = np.empty((scint_times.shape[0], 3), dtype=np.int64)
-        for j in range(3):
-            bins[:, j] = np.digitize(scint_times[:, j + 1], optmap_edges[j])
-            # normalize all out-of-bounds bins just to one end.
-            bins[:, j][bins[:, j] == optmap_edges[j].shape[0]] = 0
-
-        # there are _much_ less unique bins, unfortunately np.unique(..., axis=n) does not work
-        # with numba; also np.sort(..., axis=n) also does not work.
-
-        counts_per_bin = numba.typed.Dict.empty(
-            key_type=__counts_per_bin_key_type,
-            value_type=np.int64,
-        )
-
-        # get probabilities from map.
-        hitcount = np.zeros((detidx.shape[0], bins.shape[0]), dtype=np.int64)
-        for j in prange(bins.shape[0]):
-            # note: subtract 1 from bins, to account for np.digitize output.
-            cur_bins = (bins[j, 0] - 1, bins[j, 1] - 1, bins[j, 2] - 1)
-            if cur_bins[0] == -1 or cur_bins[1] == -1 or cur_bins[2] == -1:
-                oob += 1
-                continue  # out-of-bounds of optmap
-            ib += 1
-
-            px_any = optmap_weights[OPTMAP_ANY_CH, cur_bins[0], cur_bins[1], cur_bins[2]]
-            if px_any < 0.0:
-                any_no_stats += 1
-                continue
-            if px_any == 0.0:
-                continue
-
-            if dist == "multinomial":
-                if rng.uniform() >= px_any:
-                    continue
-                ph_det += 1
-                # we detect this energy deposition; we should at least get one photon out here!
-
-                detsel_size = 1
-
-                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.
-                detp = np.empty(detidx.shape, dtype=np.float64)
-                had_det_no_stats = 0
-                for d in detidx:
-                    # normalize so that sum(detp) = 1
-                    detp[d] = optmap_weights[d, cur_bins[0], cur_bins[1], cur_bins[2]] / px_sum
-                    if detp[d] < 0.0:
-                        had_det_no_stats = 1
-                        detp[d] = 0.0
-                det_no_stats += had_det_no_stats
-
-                # 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")
-                ]
-                for d in detsel:
-                    hitcount[d, j] += 1
-                ph_det2 += detsel.shape[0]
-
-            elif dist == "poisson":
-                # store the photon count in each bin, to sample them all at once below.
-                if cur_bins not in counts_per_bin:
-                    counts_per_bin[cur_bins] = 1
-                else:
-                    counts_per_bin[cur_bins] += 1
-
-            else:
-                msg = "unknown distribution"
-                raise RuntimeError(msg)
-
-        if dist == "poisson":
-            for j, (cur_bins, ph_counts_to_poisson) in enumerate(counts_per_bin.items()):
-                had_det_no_stats = 0
-                had_any = 0
-                for d in detidx:
-                    detp = optmap_weights[d, cur_bins[0], cur_bins[1], cur_bins[2]]
-                    if detp < 0.0:
-                        had_det_no_stats = 1
-                        continue
-                    pois_cnt = rng.poisson(lam=ph_counts_to_poisson * detp)
-                    hitcount[d, j] += pois_cnt
-                    ph_det2 += pois_cnt
-                    had_any = 1
-                ph_det += had_any
-                det_no_stats += had_det_no_stats
-
-        assert scint_times.shape[0] >= hitcount.shape[1]  # TODO: use the right assertion here.
-        out_hits_len = np.sum(hitcount)
-        if out_hits_len > 0:
-            out_times = np.empty(out_hits_len, dtype=np.float64)
-            out_det = np.empty(out_hits_len, dtype=np.int64)
-            out_idx = 0
-            for d in detidx:
-                hc_d_plane_max = np.max(hitcount[d, :])
-                # untangle the hitcount array in "planes" that only contain the given number of hits per
-                # channel. example: assume a "histogram" of hits per channel:
-                #     x |   |    <-- this is plane 2 with 1 hit ("max plane")
-                #     x |   | x  <-- this is plane 1 with 2 hits
-                # ch: 1 | 2 | 3
-                for hc_d_plane_cnt in range(1, hc_d_plane_max + 1):
-                    hc_d_plane = hitcount[d, :] >= hc_d_plane_cnt
-                    hc_d_plane_len = np.sum(hc_d_plane)
-                    if hc_d_plane_len == 0:
-                        continue
-
-                    # note: we assume "immediate" propagation after scintillation. Here, a single timestamp
-                    # might be coipied to output/"detected" twice.
-                    out_times[out_idx : out_idx + hc_d_plane_len] = scint_times[hc_d_plane, 0]
-                    out_det[out_idx : out_idx + hc_d_plane_len] = detids[d]
-                    out_idx += hc_d_plane_len
-            assert out_idx == out_hits_len  # ensure that all of out_{det,times} is filled.
-            output_map[np.int64(rowid)] = (t.evtid, out_det, out_times)
-
-    stats = {
-        "oob": oob,
-        "ib": ib,
-        "vuv_primary": ph_cnt,
-        "hits_any": ph_det,
-        "hits": ph_det2,
-        "any_no_stats": any_no_stats,
-        "det_no_stats": det_no_stats,
-    }
-    return output_map, stats
-
-
 # - run with NUMBA_FULL_TRACEBACKS=1 NUMBA_BOUNDSCHECK=1 for testing/checking
 # - cache=True does not work with outer prange, i.e. loading the cached file fails (numba bug?)
 # - the output dictionary is not threadsafe, so parallel=True is not working with it.
@@ -441,6 +207,7 @@ def _iterate_stepwise_depositions_pois(
     rng,
     detidx: int,
     map_scaling: float,
+    map_scaling_sigma: float,
     optmap_edges,
     optmap_weights,
     scint_mat_params: sc.ComputedScintParams,
@@ -453,6 +220,10 @@ def _iterate_stepwise_depositions_pois(
         hit = edep_hits[rowid]
         hit_output = []
 
+        map_scaling_evt = map_scaling
+        if map_scaling_sigma > 0:
+            map_scaling_evt = rng.normal(loc=map_scaling, scale=map_scaling_sigma)
+
         assert len(hit.particle) == len(hit.num_scint_ph)
         # iterate steps inside the hit
         for si in range(len(hit.particle)):
@@ -473,7 +244,7 @@ def _iterate_stepwise_depositions_pois(
             ib += 1
 
             # get probabilities from map.
-            detp = optmap_weights[detidx, cur_bins[0], cur_bins[1], cur_bins[2]] * map_scaling
+            detp = optmap_weights[detidx, cur_bins[0], cur_bins[1], cur_bins[2]] * map_scaling_evt
             if detp < 0.0:
                 det_no_stats += 1
                 continue
@@ -563,50 +334,6 @@ def get_output_table(output_map):
     return ph_count_o, tbl
 
 
-def convolve(
-    map_file: str,
-    edep_file: str,
-    edep_path: str,
-    material: str | tuple[sc.ScintConfig, tuple[Quantity, ...]],
-    output_file: str | None = None,
-    buffer_len: int = int(1e6),
-    dist_mode: str = "poisson+no-fano",
-):
-    scint_mat_params = _get_scint_params(material)
-
-    # special handling of distributions and flags.
-    dist, mode = dist_mode.split("+")
-    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)
-
-    for it_count, edep_lgdo in enumerate(it):
-        edep_df = _reflatten_scint_vov(edep_lgdo.view_as("ak")).to_numpy()
-
-        log.info("start event processing (%d)", it_count)
-        output_map = iterate_stepwise_depositions(
-            edep_df, optmap_for_convolve, scint_mat_params, dist=dist, mode=mode
-        )
-
-        log.info("store output photon hits (%d)", it_count)
-        ph_count_o, tbl = get_output_table(output_map)
-        log.debug(
-            "output photons: %d energy depositions -> %d photons", len(output_map), ph_count_o
-        )
-        if output_file is not None:
-            lh5.write(tbl, "optical", lh5_file=output_file, group="stp", wo_mode="append")
-
-
 def _reflatten_scint_vov(arr: ak.Array) -> ak.Array:
     if all(arr[f].ndim == 1 for f in ak.fields(arr)):
         return arr

reboost/optmap/create.py

@@ -9,17 +9,14 @@ from pathlib import Path
 from typing import Literal
 
 import numpy as np
-import scipy.optimize
-from lgdo import Array, Histogram, Scalar, lh5
+from lgdo import Histogram, lh5
 from numba import njit
 from numpy.typing import NDArray
 
 from ..log_utils import setup_log
 from .evt import (
-    EVT_TABLE_NAME,
     generate_optmap_evt,
     get_optical_detectors_from_geom,
-    read_optmap_evt,
 )
 from .optmap import OpticalMap
 
@@ -27,23 +24,21 @@ log = logging.getLogger(__name__)
 
 
 def _optmaps_for_channels(
-    optmap_evt_columns: list[str],
+    all_det_ids: dict[int, str],
     settings,
     chfilter: tuple[str | int] | Literal["*"] = (),
     use_shmem: bool = False,
 ):
-    all_det_ids = [ch_id for ch_id in optmap_evt_columns if ch_id.isnumeric()]
-
     if chfilter != "*":
         chfilter = [str(ch) for ch in chfilter]  # normalize types
-        optmap_det_ids = [det for det in all_det_ids if str(det) in chfilter]
+        optmap_det_ids = {det: name for det, name in all_det_ids.items() if str(det) in chfilter}
     else:
         optmap_det_ids = all_det_ids
 
     log.info("creating empty optmaps")
     optmap_count = len(optmap_det_ids) + 1
     optmaps = [
-        OpticalMap("all" if i == 0 else optmap_det_ids[i - 1], settings, use_shmem)
+        OpticalMap("all" if i == 0 else list(optmap_det_ids.values())[i - 1], settings, use_shmem)
         for i in range(optmap_count)
     ]
 
@@ -76,34 +71,6 @@ def _fill_hit_maps(optmaps: list[OpticalMap], loc, hitcounts: NDArray, ch_idx_to
         optmaps[i].fill_hits(locm)
 
 
-def _count_multi_ph_detection(hitcounts) -> NDArray:
-    hits_per_primary = hitcounts.sum(axis=1)
-    bins = np.arange(0, hits_per_primary.max() + 1.5) - 0.5
-    return np.histogram(hits_per_primary, bins)[0]
-
-
-def _fit_multi_ph_detection(hits_per_primary) -> float:
-    if len(hits_per_primary) <= 2:  # have only 0 and 1 hits, can't fit (and also don't need to).
-        return np.inf
-
-    x = np.arange(0, len(hits_per_primary))
-    popt, pcov = scipy.optimize.curve_fit(
-        lambda x, p0, k: p0 * np.exp(-k * x), x[1:], hits_per_primary[1:]
-    )
-    best_fit_exponent = popt[1]
-
-    log.info(
-        "p(> 1 detected photon)/p(1 detected photon) = %f",
-        sum(hits_per_primary[2:]) / hits_per_primary[1],
-    )
-    log.info(
-        "p(> 1 detected photon)/p(<=1 detected photon) = %f",
-        sum(hits_per_primary[2:]) / sum(hits_per_primary[0:2]),
-    )
-
-    return best_fit_exponent
-
-
 def _create_optical_maps_process_init(optmaps, log_level) -> None:
     # need to use shared global state. passing the shared memory arrays via "normal" arguments to
     # the worker function is not supported...
@@ -115,34 +82,29 @@ def _create_optical_maps_process_init(optmaps, log_level) -> None:
 
 
 def _create_optical_maps_process(
-    optmap_events_fn, buffer_len, is_stp_file, all_det_ids, ch_idx_to_map_idx
-) -> None:
+    optmap_events_fn, buffer_len, all_det_ids, ch_idx_to_map_idx
+) -> bool:
     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,
     )
     log.info("finished worker task for %s", optmap_events_fn)
-    return tuple(int(i) for i in x)
+    return x
 
 
 def _create_optical_maps_chunk(
-    optmap_events_fn, buffer_len, is_stp_file, all_det_ids, optmaps, ch_idx_to_map_idx
-) -> None:
-    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)
+    optmap_events_fn, buffer_len, all_det_ids, optmaps, ch_idx_to_map_idx
+) -> bool:
+    cols = [str(c) for c in all_det_ids]
+    optmap_events_it = generate_optmap_evt(optmap_events_fn, cols, buffer_len)
 
-    hits_per_primary = np.zeros(10, dtype=np.int64)
-    hits_per_primary_len = 0
     for it_count, events_lgdo in enumerate(optmap_events_it):
         optmap_events = events_lgdo.view_as("pd")
-        hitcounts = optmap_events[all_det_ids].to_numpy()
+        hitcounts = optmap_events[cols].to_numpy()
         loc = optmap_events[["xloc", "yloc", "zloc"]].to_numpy()
 
         log.debug("filling vertex histogram (%d)", it_count)
@@ -150,23 +112,19 @@ def _create_optical_maps_chunk(
 
         log.debug("filling hits histogram (%d)", it_count)
         _fill_hit_maps(optmaps, loc, hitcounts, ch_idx_to_map_idx)
-        hpp = _count_multi_ph_detection(hitcounts)
-        hits_per_primary_len = max(hits_per_primary_len, len(hpp))
-        hits_per_primary[0 : len(hpp)] += hpp
 
     # commit the final part of the hits to the maps.
     for i in range(len(optmaps)):
         optmaps[i].fill_hits_flush()
         gc.collect()
 
-    return hits_per_primary[0:hits_per_primary_len]
+    return True
 
 
 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,
@@ -182,8 +140,6 @@ def create_optical_maps(
         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``.
@@ -196,12 +152,7 @@ def create_optical_maps(
 
     use_shmem = n_procs is None or n_procs > 1
 
-    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)]
+    optmap_evt_columns = 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
@@ -209,11 +160,17 @@ def create_optical_maps(
 
     # indices for later use in _compute_hit_maps.
     ch_idx_to_map_idx = np.array(
-        [optmap_det_ids.index(d) + 1 if d in optmap_det_ids else -1 for d in all_det_ids]
+        [
+            list(optmap_det_ids.keys()).index(d) + 1 if d in optmap_det_ids else -1
+            for d in all_det_ids
+        ]
     )
     assert np.sum(ch_idx_to_map_idx > 0) == len(optmaps) - 1
 
-    log.info("creating optical map groups: %s", ", ".join(["all", *optmap_det_ids]))
+    log.info(
+        "creating optical map groups: %s",
+        ", ".join(["all", *[str(t) for t in optmap_det_ids.items()]]),
+    )
 
     q = []
 
@@ -221,9 +178,7 @@ def create_optical_maps(
     if not use_shmem:
         for fn in optmap_events_fn:
             q.append(
-                _create_optical_maps_chunk(
-                    fn, buffer_len, is_stp_file, all_det_ids, optmaps, ch_idx_to_map_idx
-                )
+                _create_optical_maps_chunk(fn, buffer_len, all_det_ids, optmaps, ch_idx_to_map_idx)
             )
     else:
         ctx = mp.get_context("forkserver")
@@ -243,14 +198,14 @@ def create_optical_maps(
         for fn in optmap_events_fn:
             r = pool.apply_async(
                 _create_optical_maps_process,
-                args=(fn, buffer_len, is_stp_file, all_det_ids, ch_idx_to_map_idx),
+                args=(fn, buffer_len, all_det_ids, ch_idx_to_map_idx),
             )
             pool_results.append((r, fn))
 
         pool.close()
         for r, fn in pool_results:
             try:
-                q.append(np.array(r.get()))
+                q.append(r.get())
             except BaseException as e:
                 msg = f"error while processing file {fn}"
                 raise RuntimeError(msg) from e  # re-throw errors of workers.
@@ -258,17 +213,8 @@ def create_optical_maps(
         pool.join()
         log.info("joined worker process pool")
 
-    # merge hitcounts.
     if len(q) != len(optmap_events_fn):
         log.error("got %d results for %d files", len(q), len(optmap_events_fn))
-    hits_per_primary = np.zeros(10, dtype=np.int64)
-    hits_per_primary_len = 0
-    for hitcounts in q:
-        hits_per_primary[0 : len(hitcounts)] += hitcounts
-        hits_per_primary_len = max(hits_per_primary_len, len(hitcounts))
-
-    hits_per_primary = hits_per_primary[0:hits_per_primary_len]
-    hits_per_primary_exponent = _fit_multi_ph_detection(hits_per_primary)
 
     # all maps share the same vertex histogram.
     for i in range(1, len(optmaps)):
@@ -279,7 +225,7 @@ def create_optical_maps(
         optmaps[i].create_probability()
         if check_after_create:
             optmaps[i].check_histograms()
-        group = "all" if i == 0 else "_" + optmap_det_ids[i - 1]
+        group = "all" if i == 0 else "channels/" + list(optmap_det_ids.values())[i - 1]
         if output_lh5_fn is not None:
             optmaps[i].write_lh5(lh5_file=output_lh5_fn, group=group)
 
@@ -288,14 +234,12 @@ def create_optical_maps(
 
         optmaps[i] = None  # clear some memory.
 
-    if output_lh5_fn is not None:
-        lh5.write(Array(hits_per_primary), "_hitcounts", lh5_file=output_lh5_fn)
-        lh5.write(Scalar(hits_per_primary_exponent), "_hitcounts_exp", lh5_file=output_lh5_fn)
-
 
 def list_optical_maps(lh5_file: str) -> list[str]:
-    maps = lh5.ls(lh5_file)
-    return [m for m in maps if m not in ("_hitcounts", "_hitcounts_exp")]
+    maps = list(lh5.ls(lh5_file, "/channels/"))
+    if "all" in lh5.ls(lh5_file):
+        maps.append("all")
+    return maps
 
 
 def _merge_optical_maps_process(
@@ -313,9 +257,9 @@ def _merge_optical_maps_process(
 
     all_edges = None
     for optmap_fn in map_l5_files:
-        nr_det = lh5.read(f"/{d}/nr_det", optmap_fn)
+        nr_det = lh5.read(f"/{d}/_nr_det", optmap_fn)
         assert isinstance(nr_det, Histogram)
-        nr_gen = lh5.read(f"/{d}/nr_gen", optmap_fn)
+        nr_gen = lh5.read(f"/{d}/_nr_gen", optmap_fn)
         assert isinstance(nr_gen, Histogram)
 
         assert OpticalMap._edges_eq(nr_det.binning, nr_gen.binning)
@@ -333,7 +277,8 @@ def _merge_optical_maps_process(
         merged_map.check_histograms(include_prefix=True)
 
     if write_part_file:
-        output_lh5_fn = f"{output_lh5_fn}_{d}.mappart.lh5"
+        d_for_tmp = d.replace("/", "_")
+        output_lh5_fn = f"{output_lh5_fn}_{d_for_tmp}.mappart.lh5"
     wo_mode = "overwrite_file" if write_part_file else "write_safe"
     merged_map.write_lh5(lh5_file=output_lh5_fn, group=d, wo_mode=wo_mode)
 
@@ -410,7 +355,7 @@ def merge_optical_maps(
         # transfer to actual output file.
         for d, part_fn in q:
             assert isinstance(part_fn, str)
-            for h_name in ("nr_det", "nr_gen", "p_det", "p_det_err"):
+            for h_name in ("_nr_det", "_nr_gen", "prob", "prob_unc"):
                 obj = f"/{d}/{h_name}"
                 log.info("transfer %s from %s", obj, part_fn)
                 h = lh5.read(obj, part_fn)
@@ -418,43 +363,19 @@ def merge_optical_maps(
                 lh5.write(h, obj, output_lh5_fn, wo_mode="write_safe")
             Path(part_fn).unlink()
 
-    # merge hitcounts.
-    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
-        hits_per_primary_len = max(hits_per_primary_len, len(hitcounts))
-
-    hits_per_primary = hits_per_primary[0:hits_per_primary_len]
-    lh5.write(Array(hits_per_primary), "_hitcounts", lh5_file=output_lh5_fn)
-
-    # re-calculate hitcounts exponent.
-    hits_per_primary_exponent = _fit_multi_ph_detection(hits_per_primary)
-    lh5.write(Scalar(hits_per_primary_exponent), "_hitcounts_exp", lh5_file=output_lh5_fn)
-
 
 def check_optical_map(map_l5_file: str):
     """Run a health check on the map file.
 
     This checks for consistency, and outputs details on map statistics.
     """
-    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:
+    if (
+        "_hitcounts_exp" in lh5.ls(map_l5_file)
+        and lh5.read("_hitcounts_exp", lh5_file=map_l5_file).value != np.inf
+    ):
         log.error("unexpected _hitcounts_exp not equal to positive infinity")
         return
 
-    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
     for submap in list_optical_maps(map_l5_file):
         try:
@@ -503,8 +424,3 @@ def rebin_optical_maps(map_l5_file: str, output_lh5_file: str, factor: int):
         om_new.h_hits = _rebin_map(om.h_hits, factor)
         om_new.create_probability()
         om_new.write_lh5(lh5_file=output_lh5_file, group=submap, wo_mode="write_safe")
-
-    # just copy hitcounts exponent.
-    for dset in ("_hitcounts_exp", "_hitcounts"):
-        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/optmap/evt.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from collections import OrderedDict
 from collections.abc import Generator, Iterable
 from pathlib import Path
 
@@ -125,13 +126,15 @@ def build_optmap_evt(
     lh5_out_file_tmp.rename(lh5_out_file)
 
 
-def get_optical_detectors_from_geom(geom_fn) -> list[int]:
+def get_optical_detectors_from_geom(geom_fn) -> dict[int, str]:
     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"]
+    return OrderedDict(
+        [(d.uid, name) for name, d in detectors.items() if d.detector_type == "optical"]
+    )
 
 
 def read_optmap_evt(lh5_file: str, buffer_len: int = int(5e6)) -> LH5Iterator:

reboost/optmap/mapview.py

@@ -92,14 +92,16 @@ def _channel_selector(fig) -> None:
 def _read_data(
     optmap_fn: str,
     detid: str = "all",
-    histogram_choice: str = "p_det",
+    histogram_choice: str = "prob",
 ) -> tuple[tuple[NDArray], NDArray]:
-    histogram = histogram_choice if histogram_choice != "p_det_err_rel" else "p_det"
+    histogram = histogram_choice if histogram_choice != "prob_unc_rel" else "prob"
+    detid = f"channels/{detid}" if detid != all and not detid.startswith("channels/") else detid
+
     optmap_all = lh5.read(f"/{detid}/{histogram}", optmap_fn)
     optmap_edges = tuple([b.edges for b in optmap_all.binning])
     optmap_weights = optmap_all.weights.nda.copy()
-    if histogram_choice == "p_det_err_rel":
-        optmap_err = lh5.read(f"/{detid}/p_det_err", optmap_fn)
+    if histogram_choice == "prob_unc_rel":
+        optmap_err = lh5.read(f"/{detid}/prob_unc", optmap_fn)
         divmask = optmap_weights > 0
         optmap_weights[divmask] = optmap_err.weights.nda[divmask] / optmap_weights[divmask]
         optmap_weights[~divmask] = -1
@@ -112,13 +114,13 @@ def _prepare_data(
     divide_fn: str | None = None,
     cmap_min: float | Literal["auto"] = 1e-4,
     cmap_max: float | Literal["auto"] = 1e-2,
-    histogram_choice: str = "p_det",
+    histogram_choice: str = "prob",
     detid: str = "all",
 ) -> tuple[tuple[NDArray], NDArray]:
     optmap_edges, optmap_weights = _read_data(optmap_fn, detid, histogram_choice)
 
     if divide_fn is not None:
-        divide_edges, divide_map = _read_data(divide_fn, detid, histogram_choice)
+        _, divide_map = _read_data(divide_fn, detid, histogram_choice)
         divmask = divide_map > 0
         optmap_weights[divmask] = optmap_weights[divmask] / divide_map[divmask]
         optmap_weights[~divmask] = -1
@@ -158,7 +160,7 @@ def view_optmap(
     start_axis: int = 2,
     cmap_min: float | Literal["auto"] = 1e-4,
     cmap_max: float | Literal["auto"] = 1e-2,
-    histogram_choice: str = "p_det",
+    histogram_choice: str = "prob",
     title: str | None = None,
 ) -> None:
     available_dets = list_optical_maps(optmap_fn)

reboost/optmap/optmap.py

@@ -8,7 +8,7 @@ import multiprocessing as mp
 from collections.abc import Mapping
 
 import numpy as np
-from lgdo import Histogram, lh5
+from lgdo import Histogram, Struct, lh5
 from numpy.typing import NDArray
 
 log = logging.getLogger(__name__)
@@ -66,10 +66,10 @@ class OpticalMap:
                 raise RuntimeError(msg)
             return h.weights.nda, h.binning
 
-        om.h_vertex, bin_nr_gen = read_hist("nr_gen", lh5_file, group=group)
-        om.h_hits, bin_nr_det = read_hist("nr_det", lh5_file, group=group)
-        om.h_prob, bin_p_det = read_hist("p_det", lh5_file, group=group)
-        om.h_prob_uncert, bin_p_det_err = read_hist("p_det_err", lh5_file, group=group)
+        om.h_vertex, bin_nr_gen = read_hist("_nr_gen", lh5_file, group=group)
+        om.h_hits, bin_nr_det = read_hist("_nr_det", lh5_file, group=group)
+        om.h_prob, bin_p_det = read_hist("prob", lh5_file, group=group)
+        om.h_prob_uncert, bin_p_det_err = read_hist("prob_unc", lh5_file, group=group)
 
         for bins in (bin_nr_det, bin_p_det, bin_p_det_err):
             if not OpticalMap._edges_eq(bin_nr_gen, bins):
@@ -227,18 +227,17 @@ class OpticalMap:
 
         def write_hist(h: NDArray, name: str, fn: str, group: str, wo_mode: str):
             lh5.write(
-                Histogram(self._nda(h), self.binning),
-                name,
+                Struct({name: Histogram(self._nda(h), self.binning)}),
+                group,
                 fn,
-                group=group,
                 wo_mode=wo_mode,
             )
 
         # only use the passed wo_mode for the first file.
-        write_hist(self.h_vertex, "nr_gen", lh5_file, group, wo_mode)
-        write_hist(self.h_hits, "nr_det", lh5_file, group, "write_safe")
-        write_hist(self.h_prob, "p_det", lh5_file, group, "write_safe")
-        write_hist(self.h_prob_uncert, "p_det_err", lh5_file, group, "write_safe")
+        write_hist(self.h_vertex, "_nr_gen", lh5_file, group, wo_mode)
+        write_hist(self.h_hits, "_nr_det", lh5_file, group, "append_column")
+        write_hist(self.h_prob, "prob", lh5_file, group, "append_column")
+        write_hist(self.h_prob_uncert, "prob_unc", lh5_file, group, "append_column")
 
     def get_settings(self) -> dict:
         """Get the binning settings that were used to create this optical map instance."""

reboost/spms/pe.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 
 import awkward as ak
+import numpy as np
 from lgdo import VectorOfVectors
 
 from ..optmap import convolve
@@ -21,6 +22,80 @@ def load_optmap(map_file: str, spm_det_uid: int) -> convolve.OptmapForConvolve:
     return convolve.open_optmap_single(map_file, spm_det_uid)
 
 
+def _nested_unflatten(data: ak.Array, lengths: ak.Array):
+    return ak.unflatten(ak.unflatten(ak.flatten(data), ak.flatten(lengths)), ak.num(lengths))
+
+
+def corrected_photoelectrons(
+    simulated_pe: ak.Array,
+    simulated_uids: ak.Array,
+    data_pe: ak.Array,
+    data_uids: ak.Array,
+    *,
+    seed: int | None = None,
+) -> tuple[ak.Array, ak.Array]:
+    r"""Add a correction to the observed number of photoelectrons (p.e.) using forced trigger data.
+
+    For every simulated event a corresponding forced trigger event in data is chosen
+    and the resulting number of p.e. for each channel (i) is:
+
+     .. math::
+
+        n_i = n_{\text{sim},i} + n_{\text{data},i}
+
+    .. warning::
+       The number of supplied forced trigger events in data should ideally be
+       more than that in the simulations. If this is not the case and "allow_data_reuse"
+       is True then some data events will be used multiple times. This introduces
+       a small amount of correlation between the simulated events, but is probably acceptable
+       in most circumstances.
+
+    Parameters
+    ----------
+    simulated_pe
+        The number of number of detected pe per sipm channel.
+    simulated_uids
+        The unique identifier (uid) for each sipm hit.
+    data_pe
+        The collection of forced trigger pe.
+    data_uids
+        The uids for each forced trigger event.
+    seed
+        Seed for random number generator
+
+    Returns
+    -------
+    a tuple of the corrected pe and sipm uids.
+    """
+    rand = np.random.default_rng(seed=seed)
+    rand_ints = rand.integers(0, len(data_pe), size=len(simulated_pe))
+
+    selected_data_pe = data_pe[rand_ints]
+    selected_data_uids = data_uids[rand_ints]
+
+    # combine sims with data
+    pe_tot = ak.concatenate([simulated_pe, selected_data_pe], axis=1)
+    uid_tot = ak.concatenate([simulated_uids, selected_data_uids], axis=1)
+
+    # sort by uid
+    order = ak.argsort(uid_tot)
+    pe_tot = pe_tot[order]
+    uid_tot = uid_tot[order]
+
+    # add an extra axis
+    n = ak.run_lengths(uid_tot)
+
+    # add another dimension
+    pe_tot = _nested_unflatten(pe_tot, n)
+    uid_tot = _nested_unflatten(uid_tot, n)
+
+    # sum pe and take the first uid (should all be the same)
+    corrected_pe = ak.sum(pe_tot, axis=-1)
+    uid_tot = ak.fill_none(ak.firsts(uid_tot, axis=-1), np.nan)
+
+    return corrected_pe, uid_tot
+
+
 def detected_photoelectrons(
     num_scint_ph: ak.Array,
     particle: ak.Array,
@@ -32,6 +107,7 @@ def detected_photoelectrons(
     material: str,
     spm_detector_uid: int,
     map_scaling: float = 1,
+    map_scaling_sigma: float = 0,
 ) -> VectorOfVectors:
     """Derive the number of detected photoelectrons (p.e.) from scintillator hits using an optical map.
 
@@ -58,6 +134,9 @@ def detected_photoelectrons(
         SiPM detector uid as used in the optical map.
     map_scaling
         scale the detection probability in the map for this detector by this factor.
+    map_scaling_sigma
+        if larger than zero, sample the used scaling factor for each (reshaped) event
+        from a normal distribution with this standard deviation.
     """
     hits = ak.Array(
         {
@@ -72,7 +151,7 @@ def detected_photoelectrons(
 
     scint_mat_params = convolve._get_scint_params(material)
     pe = convolve.iterate_stepwise_depositions_pois(
-        hits, optmap, scint_mat_params, spm_detector_uid, map_scaling
+        hits, optmap, scint_mat_params, spm_detector_uid, map_scaling, map_scaling_sigma
     )
 
     return VectorOfVectors(pe, attrs={"units": "ns"})

reboost/utils.py

@@ -284,7 +284,7 @@ def get_function_string(expr: str, aliases: dict | None = None) -> tuple[str, di
         if "." not in func_call:
             continue
 
-        subpackage, func = func_call.rsplit(".", 1)
+        subpackage, _func = func_call.rsplit(".", 1)
         package = subpackage.split(".")[0]
 
         # import the subpackage

{reboost-0.7.0.dist-info → reboost-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.7.0
+Version: 0.8.0
 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
@@ -700,7 +700,7 @@ Requires-Dist: hdf5plugin
 Requires-Dist: colorlog
 Requires-Dist: numpy
 Requires-Dist: scipy
-Requires-Dist: numba
+Requires-Dist: numba>=0.60
 Requires-Dist: legend-pydataobj>=1.15.1
 Requires-Dist: legend-pygeom-optics>=0.12.0
 Requires-Dist: legend-pygeom-tools>=0.0.11
@@ -728,6 +728,8 @@ Dynamic: license-file
 
 # reboost
 
+[![PyPI](https://img.shields.io/pypi/v/reboost?logo=pypi)](https://pypi.org/project/reboost/)
+[![conda-forge](https://img.shields.io/conda/vn/conda-forge/reboost.svg)](https://anaconda.org/conda-forge/reboost)
 ![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/legend-exp/reboost?logo=git)
 [![GitHub Workflow Status](https://img.shields.io/github/checks-status/legend-exp/reboost/main?label=main%20branch&logo=github)](https://github.com/legend-exp/reboost/actions)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)

{reboost-0.7.0.dist-info → reboost-0.8.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
 reboost/__init__.py,sha256=VZz9uo7i2jgAx8Zi15SptLZnE_qcnGuNWwqkD3rYHFA,278
-reboost/_version.py,sha256=uLbRjFSUZAgfl7V7O8zKV5Db36k7tz87ZIVq3l2SWs0,704
+reboost/_version.py,sha256=Rttl-BDadtcW1QzGnNffCWA_Wc9mUKDMOBPZp--Mnsc,704
 reboost/build_evt.py,sha256=VXIfK_pfe_Cgym6gI8dESwONZi-v_4fll0Pn09vePQY,3767
 reboost/build_glm.py,sha256=IerSLQfe51ZO7CQP2kmfPnOIVaDtcfw3byOM02Vaz6o,9472
 reboost/build_hit.py,sha256=pjEaiPW63Q3MfpjI29uJXx9gtwfiOIgOcADRDrDpRrA,17409
 reboost/cli.py,sha256=68EzKiWTHJ2u1RILUv7IX9HaVq6nTTM80_W_MUnWRe4,6382
-reboost/core.py,sha256=wIIDxaPzEaozZOeKabz4l-29_IyY47RbNy6qS8Bai1Y,15297
+reboost/core.py,sha256=TPxvZgUaHZdxfQSDdX2zIerQXt3Gq-zQaA6AeXZKNvA,15232
 reboost/iterator.py,sha256=qlEqRv5qOh8eIs-dyVOLYTvH-ZpQDx9fLckpcAdtWjs,6975
 reboost/log_utils.py,sha256=VqS_9OC5NeNU3jcowVOBB0NJ6ssYvNWnirEY-JVduEA,766
 reboost/profile.py,sha256=EOTmjmS8Rm_nYgBWNh6Rntl2XDsxdyed7yEdWtsZEeg,2598
 reboost/units.py,sha256=LUwl6swLQoG09Rt9wcDdu6DTrwDsy-C751BNGzX4sz8,3651
-reboost/utils.py,sha256=SfrqWdQZPNXw0x0DVucxHC5OwFXewM43tO-PNnIwjKI,14562
+reboost/utils.py,sha256=-4315U6m1M-rwoaI_inI1wIo_l20kvoGmC84D_QOhkE,14563
 reboost/daq/__init__.py,sha256=rNPhxx1Yawt3tENYhmOYSum9_TdV57ZU5kjxlWFAGuo,107
 reboost/daq/core.py,sha256=Rs6Q-17fzEod2iX_2WqEmnqKnNRFoWTYURl3wYhFihU,9915
 reboost/daq/utils.py,sha256=KcH6zvlInmD2YiF6V--DSYBTYudJw3G-hp2JGOcES2o,1042
@@ -21,22 +21,22 @@ reboost/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reboost/math/functions.py,sha256=OymiYTcA0NXxxm-MBDw5kqyNwHoLCmuv4J48AwnSrbU,5633
 reboost/math/stats.py,sha256=Rq4Wdzv-3aoSK7EsPZCuOEHfnOz3w0moIzCEHbC07xw,3173
 reboost/optmap/__init__.py,sha256=imvuyld-GLw8qdwqW-lXCg2feptcTyQo3wIzPvDHwmY,93
-reboost/optmap/cli.py,sha256=CoH0P_WLEek1T9zxmlsM2TuxxzqobP-W-ym72uhxrO4,10252
-reboost/optmap/convolve.py,sha256=9fM5zVKkwp03a3kqBwWppe1UOGdVm1Q6yF4P0v2I8VQ,22936
-reboost/optmap/create.py,sha256=qwUvYiUotmLCrB6RsfwxRMGI4EYRn7Q4XlwppUTVZTE,18166
-reboost/optmap/evt.py,sha256=UrjjNNeS7Uie4Ah9y_f5PyroFutLGo5aOFcwReOEy7o,5556
-reboost/optmap/mapview.py,sha256=73kpe0_SKDj9bIhEx1ybX1sBP8TyvufiLfps84A_ijA,6798
+reboost/optmap/cli.py,sha256=KJFyO4Sd2oYlRC65Kvrdq0BN_Qygp6o7LgO36D5O6_s,8887
+reboost/optmap/convolve.py,sha256=UVc-KjiYvi8LoAlykL__5qDd5T8teT89aDjiE7WYjE4,12464
+reboost/optmap/create.py,sha256=R9W8Wyl8cgXIYESenVpCRuN_MoHhLfaEv4a44cf3AxU,14479
+reboost/optmap/evt.py,sha256=p5ngsCuvOxIZDDQNL9efcLn8Q4CfGL7G726BRrCpE6Y,5637
+reboost/optmap/mapview.py,sha256=_zGiONqCWc4kCp1yHvNFRkh7svvud4ZLqaSHkNieo_M,6878
 reboost/optmap/numba_pdg.py,sha256=y8cXR5PWE2Liprp4ou7vl9do76dl84vXU52ZJD9_I7A,731
-reboost/optmap/optmap.py,sha256=f8Y0zLmXZyOz4-GDUPViIY_vf_shY3ZQG9lSD31J8gc,12820
+reboost/optmap/optmap.py,sha256=3clc1RA8jA4YJte83w085MY8zLpG-G7DBkpZ2UeKPpM,12825
 reboost/shape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reboost/shape/cluster.py,sha256=nwR1Dnf00SDICGPqpXeM1Q7_DwTtO9uP3wmuML45c3g,8195
 reboost/shape/group.py,sha256=gOCYgir2gZqmW1JXtbNRPlQqP0gmUcbe7RVb9CbY1pU,5540
 reboost/shape/reduction.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reboost/spms/__init__.py,sha256=ffi0rH-ZFGmpURbFt-HY1ZAHCdady0mLXNsblRNh-JY,207
-reboost/spms/pe.py,sha256=9KWmc4fGW5_bx4imsguLm-xp6rokt89iZcM-WD62Tj4,3090
-reboost-0.7.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-reboost-0.7.0.dist-info/METADATA,sha256=-CFo2D7zHSJXcSsfMQtXIv8T4nx3qoR4OMD6EbaKLU0,44226
-reboost-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-reboost-0.7.0.dist-info/entry_points.txt,sha256=DxhD6BidSWNot9BrejHJjQ7RRLmrMaBIl52T75oWTwM,93
-reboost-0.7.0.dist-info/top_level.txt,sha256=q-IBsDepaY_AbzbRmQoW8EZrITXRVawVnNrB-_zyXZs,8
-reboost-0.7.0.dist-info/RECORD,,
+reboost/spms/pe.py,sha256=Q_GzN5HEp2BmgB4fni5mfc5ZOXh4mlJepDwZd1EzFdc,5696
+reboost-0.8.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+reboost-0.8.0.dist-info/METADATA,sha256=t8uYwYlKBZPoO5Rbrv4RVr5AQj4D_rglFCQ-HFrYe1I,44442
+reboost-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+reboost-0.8.0.dist-info/entry_points.txt,sha256=DxhD6BidSWNot9BrejHJjQ7RRLmrMaBIl52T75oWTwM,93
+reboost-0.8.0.dist-info/top_level.txt,sha256=q-IBsDepaY_AbzbRmQoW8EZrITXRVawVnNrB-_zyXZs,8
+reboost-0.8.0.dist-info/RECORD,,