reboost 0.8.3__tar.gz → 0.8.5__tar.gz

{reboost-0.8.3/src/reboost.egg-info → reboost-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.8.3
+Version: 0.8.5
 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
@@ -28,7 +28,7 @@ Requires-Dist: scipy
 Requires-Dist: numba>=0.60
 Requires-Dist: legend-pydataobj>=1.15.1
 Requires-Dist: legend-pygeom-optics>=0.15.0
-Requires-Dist: legend-pygeom-tools>=0.0.25
+Requires-Dist: legend-pygeom-tools>=0.0.26
 Requires-Dist: legend-pygeom-hpges
 Requires-Dist: hist
 Requires-Dist: dbetto

{reboost-0.8.3 → reboost-0.8.5}/pyproject.toml

@@ -39,7 +39,7 @@ dependencies = [
     "numba >=0.60",
     "legend-pydataobj >=1.15.1",
     "legend-pygeom-optics >=0.15.0",
-    "legend-pygeom-tools >=0.0.25",
+    "legend-pygeom-tools >=0.0.26",
     "legend-pygeom-hpges",
     "hist",
     "dbetto",

reboost-0.8.5/src/reboost/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .cli import cli
+
+if __name__ == "__main__":
+    cli()

{reboost-0.8.3 → reboost-0.8.5}/src/reboost/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.8.3'
-__version_tuple__ = version_tuple = (0, 8, 3)
+__version__ = version = '0.8.5'
+__version_tuple__ = version_tuple = (0, 8, 5)
 
-__commit_id__ = commit_id = 'g2085bdbed'
+__commit_id__ = commit_id = 'g5d57bf6e0'

reboost-0.8.5/src/reboost/optmap/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .cli import optical_cli
+
+if __name__ == "__main__":
+    optical_cli()

{reboost-0.8.3 → reboost-0.8.5}/src/reboost/optmap/convolve.py

@@ -32,7 +32,7 @@ class OptmapForConvolve(NamedTuple):
 
 def open_optmap(optmap_fn: str) -> OptmapForConvolve:
     dets = lh5.ls(optmap_fn, "/channels/")
-    detidx = np.arange(0, dets.shape[0])
+    detidx = np.arange(0, len(dets))
 
     optmap_all = lh5.read("/all/prob", optmap_fn)
     assert isinstance(optmap_all, Histogram)
@@ -61,14 +61,14 @@ def open_optmap(optmap_fn: str) -> OptmapForConvolve:
             raise ValueError(msg)
     else:
         detidx = np.array([OPTMAP_ANY_CH])
-        dets = np.array(["all"])
+        dets = ["all"]
 
     # check the exponent from the optical map file
     if "_hitcounts_exp" in lh5.ls(optmap_fn):
         msg = "found _hitcounts_exp which is not supported any more"
         raise RuntimeError(msg)
 
-    dets = [d.replace("/channels/", "") for d in dets]
+    dets = np.array([d.replace("/channels/", "") for d in dets])
 
     return OptmapForConvolve(dets, detidx, optmap_edges, ow)
 
@@ -156,15 +156,70 @@ def iterate_stepwise_depositions_scintillate(
         raise ValueError(msg)
 
     rng = np.random.default_rng() if rng is None else rng
-    output_list = _iterate_stepwise_depositions_scintillate(edep_hits, rng, scint_mat_params, mode)
+    counts = ak.num(edep_hits.edep)
+    output_array = _iterate_stepwise_depositions_scintillate(
+        edep_hits, rng, scint_mat_params, mode, ak.sum(counts)
+    )
 
-    # convert the numba result back into an awkward array.
-    builder = ak.ArrayBuilder()
-    for r in output_list:
-        with builder.list():
-            builder.extend(r)
+    return ak.unflatten(output_array, counts)
 
-    return builder.snapshot()
+
+def iterate_stepwise_depositions_numdet(
+    edep_hits: ak.Array,
+    optmap: OptmapForConvolve,
+    det: str,
+    map_scaling: float = 1,
+    map_scaling_sigma: float = 0,
+    rng: np.random.Generator | None = None,
+):
+    if edep_hits.xloc.ndim == 1:
+        msg = "the pe processors only support already reshaped output"
+        raise ValueError(msg)
+
+    rng = np.random.default_rng() if rng is None else rng
+    counts = ak.num(edep_hits.num_scint_ph)
+    output_array, res = _iterate_stepwise_depositions_numdet(
+        edep_hits,
+        rng,
+        np.where(optmap.dets == det)[0][0],
+        map_scaling,
+        map_scaling_sigma,
+        optmap.edges,
+        optmap.weights,
+        ak.sum(counts),
+    )
+
+    if res["det_no_stats"] > 0:
+        log.warning(
+            "had edep out in voxels without stats: %d",
+            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,
+        )
+
+    return ak.unflatten(output_array, counts)
+
+
+def iterate_stepwise_depositions_times(
+    edep_hits: ak.Array,
+    scint_mat_params: sc.ComputedScintParams,
+    rng: np.random.Generator | None = None,
+):
+    if edep_hits.particle.ndim == 1:
+        msg = "the pe processors only support already reshaped output"
+        raise ValueError(msg)
+
+    rng = np.random.default_rng() if rng is None else rng
+    counts = ak.sum(edep_hits.num_det_ph, axis=1)
+    output_array = _iterate_stepwise_depositions_times(
+        edep_hits, rng, scint_mat_params, ak.sum(counts)
+    )
+
+    return ak.unflatten(output_array, counts)
 
 
 _pdg_func = numba_pdgid_funcs()
@@ -270,17 +325,15 @@ def _iterate_stepwise_depositions_pois(
 # - cache=True does not work with outer prange, i.e. loading the cached file fails (numba bug?)
 @njit(parallel=False, nogil=True, cache=True)
 def _iterate_stepwise_depositions_scintillate(
-    edep_hits, rng, scint_mat_params: sc.ComputedScintParams, mode: str
+    edep_hits, rng, scint_mat_params: sc.ComputedScintParams, mode: str, output_length: int
 ):
     pdgid_map = {}
-    output_list = []
+    output = np.empty(shape=output_length, dtype=np.int64)
 
+    output_index = 0
     for rowid in range(len(edep_hits)):  # iterate hits
         hit = edep_hits[rowid]
-        hit_output = []
-
-        # iterate steps inside the hit
-        for si in range(len(hit.particle)):
+        for si in range(len(hit.particle)):  # iterate steps inside the hit
             # get the particle information.
             particle = hit.particle[si]
             if particle not in pdgid_map:
@@ -295,12 +348,106 @@ def _iterate_stepwise_depositions_scintillate(
                 rng,
                 emission_term_model=("poisson" if mode == "no-fano" else "normal_fano"),
             )
-            hit_output.append(num_phot)
+            output[output_index] = num_phot
+            output_index += 1
 
-        assert len(hit_output) == len(hit.particle)
-        output_list.append(hit_output)
+    assert output_index == output_length
+    return output
+
+
+# - 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?)
+@njit(parallel=False, nogil=True, cache=True)
+def _iterate_stepwise_depositions_numdet(
+    edep_hits,
+    rng,
+    detidx: int,
+    map_scaling: float,
+    map_scaling_sigma: float,
+    optmap_edges,
+    optmap_weights,
+    output_length: int,
+):
+    oob = ib = det_no_stats = 0
+    output = np.empty(shape=output_length, dtype=np.int64)
+
+    output_index = 0
+    for rowid in range(len(edep_hits)):  # iterate hits
+        hit = edep_hits[rowid]
+
+        map_scaling_evt = map_scaling
+        if map_scaling_sigma > 0:
+            map_scaling_evt = rng.normal(loc=map_scaling, scale=map_scaling_sigma)
+
+        # iterate steps inside the hit
+        for si in range(len(hit.xloc)):
+            loc = np.array([hit.xloc[si], hit.yloc[si], hit.zloc[si]], dtype=np.float64)
+            # coordinates -> bins of the optical map.
+            bins = np.empty(3, dtype=np.int64)
+            for j in range(3):
+                edges = optmap_edges[j].astype(np.float64)
+                start = edges[0]
+                width = edges[1] - edges[0]
+                nbins = edges.shape[0] - 1
+                bins[j] = int((loc[j] - start) / width)
+
+                if bins[j] < 0 or bins[j] >= nbins:
+                    bins[j] = -1  # normalize all out-of-bounds bins just to one end.
+
+            if bins[0] == -1 or bins[1] == -1 or bins[2] == -1:
+                detp = 0.0  # out-of-bounds of optmap
+                oob += 1
+            else:
+                # get probabilities from map.
+                detp = optmap_weights[detidx, bins[0], bins[1], bins[2]] * map_scaling_evt
+                if detp < 0:
+                    det_no_stats += 1
+                ib += 1
+
+            pois_cnt = 0 if detp <= 0.0 else rng.poisson(lam=hit.num_scint_ph[si] * detp)
+            output[output_index] = pois_cnt
+            output_index += 1
+
+    assert output_index == output_length
+    return output, {"oob": oob, "ib": ib, "det_no_stats": det_no_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.
+@njit(parallel=False, nogil=True, cache=True)
+def _iterate_stepwise_depositions_times(
+    edep_hits, rng, scint_mat_params: sc.ComputedScintParams, output_length: int
+):
+    pdgid_map = {}
+    output = np.empty(shape=output_length, dtype=np.float64)
+
+    output_index = 0
+    for rowid in range(len(edep_hits)):  # iterate hits
+        hit = edep_hits[rowid]
+
+        assert len(hit.particle) == len(hit.num_det_ph)
+        # iterate steps inside the hit
+        for si in range(len(hit.particle)):
+            pois_cnt = hit.num_det_ph[si]
+            if pois_cnt <= 0:
+                continue
+
+            # get the particle information.
+            particle = hit.particle[si]
+            if particle not in pdgid_map:
+                pdgid_map[particle] = (_pdgid_to_particle(particle), _pdg_func.charge(particle))
+            part, _charge = pdgid_map[particle]
+
+            # get time spectrum.
+            # note: we assume "immediate" propagation after scintillation.
+            scint_times = sc.scintillate_times(scint_mat_params, part, pois_cnt, rng) + hit.time[si]
+            assert len(scint_times) == pois_cnt
+            output[output_index : output_index + len(scint_times)] = scint_times
+            output_index += len(scint_times)
 
-    return output_list
+    assert output_index == output_length
+    return output
 
 
 def _get_scint_params(material: str):

{reboost-0.8.3 → reboost-0.8.5}/src/reboost/optmap/evt.py

@@ -131,9 +131,9 @@ def get_optical_detectors_from_geom(geom_fn) -> dict[int, str]:
     import pygeomtools
 
     geom_registry = pyg4ometry.gdml.Reader(geom_fn).getRegistry()
-    detectors = pygeomtools.get_all_sensvols(geom_registry)
+    detectors = pygeomtools.get_all_sensvols(geom_registry, type_filter="optical")
     return OrderedDict(
-        [(d.uid, name) for name, d in detectors.items() if d.detector_type == "optical"]
+        [(d.uid, d.ntuple_name if d.ntuple_name else name) for name, d in detectors.items()]
     )
 
 

{reboost-0.8.3 → reboost-0.8.5}/src/reboost/optmap/mapview.py

@@ -95,7 +95,7 @@ def _read_data(
     histogram_choice: str = "prob",
 ) -> tuple[tuple[NDArray], NDArray]:
     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
+    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])

reboost-0.8.5/src/reboost/spms/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from .pe import (
+    detected_photoelectrons,
+    emitted_scintillation_photons,
+    load_optmap,
+    load_optmap_all,
+    number_of_detected_photoelectrons,
+    photoelectron_times,
+)
+
+__all__ = [
+    "detected_photoelectrons",
+    "emitted_scintillation_photons",
+    "load_optmap",
+    "load_optmap_all",
+    "number_of_detected_photoelectrons",
+    "photoelectron_times",
+]

{reboost-0.8.3 → reboost-0.8.5}/src/reboost/spms/pe.py

@@ -109,7 +109,12 @@ def detected_photoelectrons(
     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.
+    """Derive the number and arrival times of detected photoelectrons (p.e.) from scintillator hits using an optical map.
+
+    .. deprecated :: 0.8.5
+        Use the other, more fine-granular and split processors
+        :func:`number_of_detected_photoelectrons` and :func:`photoelectron_times` to
+        replace this legacy processor.
 
     Parameters
     ----------
@@ -140,8 +145,8 @@ def detected_photoelectrons(
     """
     hits = ak.Array(
         {
-            "num_scint_ph": num_scint_ph,
-            "particle": particle,
+            "num_scint_ph": units_conv_ak(num_scint_ph, "dimensionless"),
+            "particle": units_conv_ak(particle, "dimensionless"),
             "time": units_conv_ak(time, "ns"),
             "xloc": units_conv_ak(xloc, "m"),
             "yloc": units_conv_ak(yloc, "m"),
@@ -171,8 +176,87 @@ def emitted_scintillation_photons(
     material
         scintillating material name.
     """
-    hits = ak.Array({"edep": units_conv_ak(edep, "keV"), "particle": particle})
+    hits = ak.Array(
+        {
+            "edep": units_conv_ak(edep, "keV"),
+            "particle": units_conv_ak(particle, "dimensionless"),
+        }
+    )
 
     scint_mat_params = convolve._get_scint_params(material)
     ph = convolve.iterate_stepwise_depositions_scintillate(hits, scint_mat_params)
     return VectorOfVectors(ph)
+
+
+def number_of_detected_photoelectrons(
+    xloc: ak.Array,
+    yloc: ak.Array,
+    zloc: ak.Array,
+    num_scint_ph: ak.Array,
+    optmap: convolve.OptmapForConvolve,
+    spm_detector: str,
+    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.
+
+    Parameters
+    ----------
+    xloc
+        array of x coordinate position of scintillation events.
+    yloc
+        array of y coordinate position of scintillation events.
+    zloc
+        array of z coordinate position of scintillation events.
+    num_scint_ph
+        array of emitted scintillation photons, as generated by
+        :func:`emitted_scintillation_photons`.
+    detp
+    """
+    hits = ak.Array(
+        {
+            "xloc": units_conv_ak(xloc, "m"),
+            "yloc": units_conv_ak(yloc, "m"),
+            "zloc": units_conv_ak(zloc, "m"),
+            "num_scint_ph": units_conv_ak(num_scint_ph, "dimensionless"),
+        }
+    )
+
+    ph = convolve.iterate_stepwise_depositions_numdet(
+        hits, optmap, spm_detector, map_scaling, map_scaling_sigma
+    )
+    return VectorOfVectors(ph)
+
+
+def photoelectron_times(
+    num_det_ph: ak.Array,
+    particle: ak.Array,
+    time: ak.Array,
+    material: str,
+) -> VectorOfVectors:
+    """Derive the arrival times of scintillation photons.
+
+    Parameters
+    ----------
+    num_det_ph
+        array of detected scintillation photons, as generated by
+        :func:`emitted_scintillation_photons`.
+    particle
+        array of particle PDG IDs of scintillation events.
+    time
+        array of timestamps of scintillation events.
+    material
+        scintillating material name.
+    """
+    hits = ak.Array(
+        {
+            "num_det_ph": units_conv_ak(num_det_ph, "dimensionless"),
+            "particle": units_conv_ak(particle, "dimensionless"),
+            "time": units_conv_ak(time, "ns"),
+        }
+    )
+
+    scint_mat_params = convolve._get_scint_params(material)
+    pe = convolve.iterate_stepwise_depositions_times(hits, scint_mat_params)
+
+    return VectorOfVectors(pe, attrs={"units": "ns"})

{reboost-0.8.3 → reboost-0.8.5}/src/reboost/utils.py

@@ -445,7 +445,7 @@ def write_lh5(
         time_dict.update_field("write", start_time)
 
 
-def get_remage_detector_uids(h5file: str | Path) -> dict:
+def get_remage_detector_uids(h5file: str | Path, *, lh5_table: str = "stp") -> dict:
     """Get mapping of detector names to UIDs from a remage output file.
 
     The remage LH5 output files contain a link structure that lets the user
@@ -483,7 +483,7 @@ def get_remage_detector_uids(h5file: str | Path) -> dict:
 
     out = {}
     with h5py.File(h5file, "r") as f:
-        g = f["/stp/__by_uid__"]
+        g = f[f"/{lh5_table}/__by_uid__"]
         # loop over links
         for key in g:
             # is this a link?

{reboost-0.8.3 → reboost-0.8.5/src/reboost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.8.3
+Version: 0.8.5
 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
@@ -28,7 +28,7 @@ Requires-Dist: scipy
 Requires-Dist: numba>=0.60
 Requires-Dist: legend-pydataobj>=1.15.1
 Requires-Dist: legend-pygeom-optics>=0.15.0
-Requires-Dist: legend-pygeom-tools>=0.0.25
+Requires-Dist: legend-pygeom-tools>=0.0.26
 Requires-Dist: legend-pygeom-hpges
 Requires-Dist: hist
 Requires-Dist: dbetto

{reboost-0.8.3 → reboost-0.8.5}/src/reboost.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/reboost/__init__.py
+src/reboost/__main__.py
 src/reboost/_version.py
 src/reboost/build_evt.py
 src/reboost/build_glm.py
@@ -31,6 +32,7 @@ src/reboost/math/__init__.py
 src/reboost/math/functions.py
 src/reboost/math/stats.py
 src/reboost/optmap/__init__.py
+src/reboost/optmap/__main__.py
 src/reboost/optmap/cli.py
 src/reboost/optmap/convolve.py
 src/reboost/optmap/create.py

{reboost-0.8.3 → reboost-0.8.5}/src/reboost.egg-info/requires.txt

@@ -5,7 +5,7 @@ scipy
 numba>=0.60
 legend-pydataobj>=1.15.1
 legend-pygeom-optics>=0.15.0
-legend-pygeom-tools>=0.0.25
+legend-pygeom-tools>=0.0.26
 legend-pygeom-hpges
 hist
 dbetto

{reboost-0.8.3 → reboost-0.8.5}/tests/hit/configs/spms.yaml

@@ -1,5 +1,6 @@
 objects:
   spms: "['S001', 'S002']"
+  optmap_test: reboost.spms.load_optmap_all(ARGS.optmap_path)
 
 processing_groups:
   - name: spms
@@ -14,6 +15,7 @@ processing_groups:
       - edep
       - pe_times
       - pe_times_lar
+      - pe_times_lar_full
 
     pre_operations:
       num_scint_ph:
@@ -24,7 +26,13 @@ processing_groups:
       optmap_lar: reboost.spms.load_optmap(ARGS.optmap_path, DETECTOR)
 
     operations:
+      num_det_ph: reboost.spms.number_of_detected_photoelectrons(
+        HITS.xloc, HITS.yloc, HITS.zloc, HITS.num_scint_ph,
+        DETECTOR_OBJECTS.optmap_lar, DETECTOR)
       pe_times_lar:
+        reboost.spms.photoelectron_times(HITS.num_det_ph, HITS.particle,
+        HITS.time, "lar")
+      pe_times_lar_full:
         reboost.spms.detected_photoelectrons( HITS.num_scint_ph, HITS.particle,
         HITS.time, HITS.xloc, HITS.yloc, HITS.zloc, DETECTOR_OBJECTS.optmap_lar,
         "lar", DETECTOR )

{reboost-0.8.3 → reboost-0.8.5}/tests/hit/test_build_hit.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import awkward as ak
 import dbetto
 import h5py
+import numpy as np
 import pytest
 from lgdo import Array, Struct, Table, VectorOfVectors, lh5
 
@@ -333,6 +334,7 @@ def test_spms(test_gen_lh5_scint, tmptestdir):
     m.create_probability()
     m.write_lh5(map_file, "channels/S001", "overwrite_file")
     m.write_lh5(map_file, "channels/S002", "write_safe")
+    m.write_lh5(map_file, "all", "write_safe")
 
     outfile = f"{tmptestdir}/spms_hit.lh5"
     reboost.build_hit(
@@ -349,3 +351,12 @@ def test_spms(test_gen_lh5_scint, tmptestdir):
     assert "S002" in hits
 
     assert isinstance(hits["S001"]["pe_times_lar"], VectorOfVectors)
+    assert isinstance(hits["S001"]["pe_times_lar_full"], VectorOfVectors)
+
+    pe_split = hits["S001"]["pe_times_lar"].view_as("ak")
+    pe_full = hits["S001"]["pe_times_lar_full"].view_as("ak")
+    pe_ratio = ak.count(pe_split) / ak.count(pe_full)
+
+    assert np.abs(pe_ratio - 1) < 0.1
+
+    # TODO: test they are statistically close

reboost-0.8.3/src/reboost/spms/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from .pe import detected_photoelectrons, emitted_scintillation_photons, load_optmap
-
-__all__ = ["detected_photoelectrons", "emitted_scintillation_photons", "load_optmap"]