reboost 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

reboost/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)

reboost/build_glm.py

@@ -232,7 +232,7 @@ def build_glm(
             glm_sum = None
 
         # start row for each table
-        start_row = {lh5_tab: 0 for lh5_tab in lh5_table_list}
+        start_row = dict.fromkeys(lh5_table_list, 0)
 
         vfield = f"stp/vertices/{id_name}"
 

reboost/build_hit.py

@@ -246,6 +246,8 @@ def build_hit(
         # loop over processing groups
         for group_idx, proc_group in enumerate(config["processing_groups"]):
             proc_name = proc_group.get("name", "default")
+            msg = f"... starting group {proc_name}"
+            log.info(msg)
 
             if proc_name not in time_dict:
                 time_dict[proc_name] = ProfileDict()
@@ -261,9 +263,11 @@ def build_hit(
                     for mapping in proc_group.get("detector_mapping")
                 ]
             )
-
             # loop over detectors
             for in_det_idx, (in_detector, out_detectors) in enumerate(detectors_mapping.items()):
+                msg = f"... processing {in_detector} (to {out_detectors})"
+                log.info(msg)
+
                 # get detector objects
                 det_objects = core.get_detector_objects(
                     output_detectors=out_detectors,
@@ -286,7 +290,7 @@ def build_hit(
                     time_dict=time_dict[proc_name],
                 )
                 for stps, _, chunk_idx, _ in glm_it:
-                    # converting to awwkard
+                    # converting to awkward
                     if stps is None:
                         continue
 

reboost/core.py

@@ -59,6 +59,7 @@ def evaluate_output_column(
     expr = expression.replace(f"{table_name}.", "")
 
     # get func call and modules to import
+
     func_call, globals_dict = utils.get_function_string(expr)
 
     msg = f"evaluating table with command {expr} and local_dict {local_dict.keys()}"
@@ -153,7 +154,7 @@ def get_global_objects(
 
 
 def get_detectors_mapping(
-    output_detector_expression: str,
+    output_detector_expression: str | list,
     objects: AttrsDict | None = None,
     input_detector_name: str | None = None,
 ) -> dict:
@@ -210,15 +211,21 @@ def get_detectors_mapping(
                                 input_detector_name = "dets",objects=objs)
     {'dets': ['ch0', 'ch1', 'ch2']}
     """
-    func, globs = utils.get_function_string(output_detector_expression)
     out_names = []
+    if isinstance(output_detector_expression, str):
+        out_list = [output_detector_expression]
+    else:
+        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(output_detector_expression, local_dict={"OBJECTS": objects})
-        out_names.extend(objs)
-    except Exception:
-        out_names.append(output_detector_expression)
+        # if no package was imported its just a name
+        try:
+            objs = evaluate_object(expression_tmp, local_dict={"OBJECTS": objects})
+            out_names.extend(objs)
+        except Exception:
+            out_names.append(expression_tmp)
 
     # simple one to one mapping
     if input_detector_name is None:
@@ -273,19 +280,19 @@ def get_detector_objects(
 
     det_objects_dict = {}
     for output_detector in output_detectors:
-        det_objects_dict[output_detector] = AttrsDict(
-            {
-                obj_name: evaluate_object(
-                    obj_expression,
-                    local_dict={
-                        "ARGS": args,
-                        "DETECTOR": output_detector,
-                        "OBJECTS": global_objects,
-                    },
-                )
-                for obj_name, obj_expression in expressions.items()
-            }
-        )
+        obj_dict = {}
+        for obj_name, obj_expression in expressions.items():
+            obj_dict[obj_name] = evaluate_object(
+                obj_expression,
+                local_dict={
+                    "ARGS": args,
+                    "DETECTOR": output_detector,
+                    "OBJECTS": global_objects,
+                    "DETECTOR_OBJECTS": AttrsDict(obj_dict),
+                },
+            )
+
+        det_objects_dict[output_detector] = AttrsDict(obj_dict)
     res = AttrsDict(det_objects_dict)
 
     if time_dict is not None:

reboost/math/functions.py

@@ -11,7 +11,7 @@ log = logging.getLogger(__name__)
 
 
 def piecewise_linear_activeness(
-    distances: VectorOfVectors | ak.Array, fccd: float, tl: float
+    distances: VectorOfVectors | ak.Array, fccd: float, dlf: float
 ) -> VectorOfVectors | Array:
     r"""Piecewise linear HPGe activeness model.
 
@@ -21,14 +21,15 @@ def piecewise_linear_activeness(
 
         f(d) =
         \begin{cases}
-        0 & \text{if } d < t, \\
-        \frac{x-l}{f - l} & \text{if } t \leq d < f, \\
+        0 & \text{if } d < f*l, \\
+        \frac{x-f*l}{f - f*l} & \text{if } t \leq d < f, \\
         1 & \text{otherwise.}
         \end{cases}
 
     Where:
+
     - `d`: Distance to surface,
-    - `l`: Depth of transition layer start
+    - `l`: Dead layer fraction, the fraction of the FCCD which is fully inactive
     - `f`: Full charge collection depth (FCCD).
 
     In addition, any distance of `np.nan` (for example if the calculation
@@ -43,8 +44,8 @@ def piecewise_linear_activeness(
 
     fccd
         the value of the FCCD
-    tl
-        the start of the transition layer.
+    dlf
+        the fraction of the FCCD which is fully inactive.
 
     Returns
     -------
@@ -58,10 +59,117 @@ def piecewise_linear_activeness(
     else:
         distances_ak = distances
 
+    dl = fccd * dlf
+    distances_flat = (
+        ak.flatten(distances_ak).to_numpy() if distances_ak.ndim > 1 else distances_ak.to_numpy()
+    )
+
     # compute the linear piecewise
-    results = ak.where(
-        (distances_ak > fccd) | np.isnan(distances_ak),
-        1,
-        ak.where(distances_ak <= tl, 0, (distances_ak - tl) / (fccd - tl)),
+    results = np.full_like(distances_flat, np.nan, dtype=np.float64)
+    lengths = ak.num(distances_ak) if distances_ak.ndim > 1 else len(distances_ak)
+
+    mask1 = (distances_flat > fccd) | np.isnan(distances_flat)
+    mask2 = (distances_flat <= dl) & (~mask1)
+    mask3 = ~(mask1 | mask2)
+
+    # assign the values
+    results[mask1] = 1
+    results[mask2] = 0
+    results[mask3] = (distances_flat[mask3] - dl) / (fccd - dl)
+
+    # reshape
+    results = ak.unflatten(ak.Array(results), lengths) if distances_ak.ndim > 1 else results
+
+    return VectorOfVectors(results) if results.ndim > 1 else Array(results)
+
+
+def vectorised_active_energy(
+    distances: VectorOfVectors | ak.Array,
+    edep: VectorOfVectors | ak.Array,
+    fccd: float | list,
+    dlf: float | list,
+) -> VectorOfVectors | Array:
+    r"""Energy after piecewise linear HPGe activeness model vectorised over FCCD or dead layer fraction.
+
+    Based on the same linear activeness function as :func:`piecewise_linear_activeness`. However,
+    this function vectorises the calculation to provide a range of output energies varying the fccd or
+    dead layer fraction. Either fccd or dlf can be a list. This adds an extra dimension to the
+    output, with the same length as the input fccd or dlf list.
+
+    .. warning:
+        It is not currently implemented to vary both dlf and fccd.
+
+    Parameters
+    ----------
+    distances
+        the distance from each step to the detector surface. Can be either a
+        `awkward` array, or a LGDO `VectorOfVectors` . The computation
+        is performed for each element and the first dimension is preserved, a
+        new dimension is added vectorising over the FCCD or DLF.
+    edep
+        the energy for each step.
+    fccd
+        the value of the FCCD, can be a list.
+    dlf
+        the fraction of the FCCD which is fully inactive, can be a list.
+
+    Returns
+    -------
+    a :class:`VectorOfVectors` or :class:`Array` of the activeness
+    """
+    # add checks on fccd, dlf
+    fccd = np.array(fccd)
+    dlf = np.array(dlf)
+
+    if (fccd.ndim + dlf.ndim) > 1:
+        msg = "Currently only one of FCCD and dlf can be varied"
+        raise NotImplementedError(msg)
+
+    # convert fccd and or dlf to the right shape
+    if fccd.ndim == 0:
+        if dlf.ndim == 0:
+            dlf = dlf[np.newaxis]
+        fccd = np.full_like(dlf, fccd)
+
+    dl = fccd * dlf
+
+    def _convert(field):
+        # convert to ak
+        if isinstance(field, VectorOfVectors):
+            field_ak = field.view_as("ak")
+        elif not isinstance(field, ak.Array):
+            field_ak = ak.Array(field)
+        else:
+            msg = f"{field} must be an awkward array or VectorOfVectors"
+            raise TypeError(msg)
+
+        return field_ak, ak.flatten(field_ak).to_numpy()[:, np.newaxis]
+
+    distances_ak, distances_flat = _convert(distances)
+    _, edep_flat = _convert(edep)
+    runs = ak.num(distances_ak, axis=-1)
+
+    # vectorise fccd or tl
+
+    fccd_list = np.tile(fccd, (len(distances_flat), 1))
+    dl_list = np.tile(dl, (len(distances_flat), 1))
+    distances_shaped = np.tile(distances_flat, (1, len(dl)))
+
+    # compute the linear piecewise
+    results = np.full_like(fccd_list, np.nan, dtype=np.float64)
+
+    # Masks
+    mask1 = (distances_shaped > fccd_list) | np.isnan(distances_shaped)
+    mask2 = ((distances_shaped <= dl_list) | (fccd_list == dl_list)) & ~mask1
+    mask3 = ~(mask1 | mask2)  # Safe, avoids recomputing anything expensive
+
+    # Assign values
+    results[mask1] = 1.0
+    results[mask2] = 0.0
+    results[mask3] = (distances_shaped[mask3] - dl_list[mask3]) / (
+        fccd_list[mask3] - dl_list[mask3]
     )
-    return VectorOfVectors(results) if results.ndim > 1 else Array(results.to_numpy())
+
+    energy = ak.sum(ak.unflatten(results * edep_flat, runs), axis=-2)
+
+    return VectorOfVectors(energy) if energy.ndim > 1 else Array(energy.to_numpy())

reboost/shape/cluster.py

@@ -40,17 +40,17 @@ def cluster_by_step_length(
     pos_x: ak.Array | VectorOfVectors,
     pos_y: ak.Array | VectorOfVectors,
     pos_z: ak.Array | VectorOfVectors,
-    dist: ak.Array | VectorOfVectors,
-    surf_cut: float = 2,
+    dist: ak.Array | VectorOfVectors | None = None,
+    surf_cut: float | None = None,
     threshold: float = 0.1,
-    threshold_surf: float = 0.0,
+    threshold_surf: float | None = None,
 ) -> VectorOfVectors:
     """Perform clustering based on the step length.
 
     Steps are clustered based on distance, if either:
      - a step is in a new track,
      - a step moves from surface to bulk region (or visa versa),
-     - the distance between the first step and the cluster and the current is above a threshold.
+     - the distance between the current step and the first step of the current cluster is above a threshold.
 
     Then a new cluster is started. The surface region is defined as the volume
     less than surf_cut distance to the surface. This allows for a fine tuning of the
@@ -67,9 +67,9 @@ def cluster_by_step_length(
     pos_z
         z position of the step.
     dist
-        distance to the detector surface.
+        distance to the detector surface. Can be `None` in which case all steps are treated as being in the "bulk".
     surf_cut
-        Size of the surface region (in mm)
+        Size of the surface region (in mm), if `None` no selection is applied (default).
     threshold
         Distance threshold in mm to combine steps in the bulk.
     threshold_surf
@@ -107,7 +107,7 @@ def cluster_by_step_length(
         ak.flatten(ak.local_index(trackid)).to_numpy(),
         ak.flatten(trackid).to_numpy(),
         pos,
-        ak.flatten(dist).to_numpy(),
+        dist_to_surf=ak.flatten(dist).to_numpy() if dist is not None else dist,
         surf_cut=surf_cut,
         threshold=threshold,
         threshold_surf=threshold_surf,
@@ -127,10 +127,10 @@ def cluster_by_distance_numba(
     local_index: np.ndarray,
     trackid: np.ndarray,
     pos: np.ndarray,
-    dist_to_surf: np.ndarray,
-    surf_cut: float = 2,
+    dist_to_surf: np.ndarray | None,
+    surf_cut: float | None = None,
     threshold: float = 0.1,
-    threshold_surf: float = 0.0,
+    threshold_surf: float | None = None,
 ) -> np.ndarray:
     """Cluster steps by the distance between points in the same track.
 
@@ -146,9 +146,9 @@ def cluster_by_distance_numba(
     pos
         `(n,3)` size array of the positions
     dist_to_surf
-        1D array of the distance to the detector surface.
+        1D array of the distance to the detector surface. Can be `None` in which case all steps are treated as being in the bulk.
     surf_cut
-        Size of the surface region (in mm)
+        Size of the surface region (in mm), if `None` no selection is applied.
     threshold
         Distance threshold in mm to combine steps in the bulk.
     threshold_surf
@@ -172,14 +172,20 @@ def cluster_by_distance_numba(
     is_surf_prev = False
 
     for idx in range(n):
-        thr = threshold if dist_to_surf[idx] > surf_cut else threshold_surf
-
-        new_cluster = (
-            (trackid[idx] != trackid_prev)
-            or (is_surf_prev and (dist_to_surf[idx] > surf_cut))
-            or ((not is_surf_prev) and (dist_to_surf[idx] < surf_cut))
-            or (_dist(pos[idx, :], pos_prev) > thr)
-        )
+        # consider a surface and a bulk region
+        if dist_to_surf is not None:
+            thr = threshold if dist_to_surf[idx] > surf_cut else threshold_surf
+
+            new_cluster = (
+                (trackid[idx] != trackid_prev)
+                or (is_surf_prev and (dist_to_surf[idx] > surf_cut))
+                or ((not is_surf_prev) and (dist_to_surf[idx] < surf_cut))
+                or (_dist(pos[idx, :], pos_prev) > thr)
+            )
+        # basic clustering without split into surface / bulk
+        else:
+            thr = threshold
+            new_cluster = (trackid[idx] != trackid_prev) or (_dist(pos[idx, :], pos_prev) > thr)
 
         # New hit, reset cluster index
         if idx == 0 or local_index[idx] == 0:
@@ -197,7 +203,8 @@ def cluster_by_distance_numba(
 
         # Update previous values
         trackid_prev = trackid[idx]
-        is_surf_prev = dist_to_surf[idx] < surf_cut
+        if dist_to_surf is not None:
+            is_surf_prev = dist_to_surf[idx] < surf_cut
 
     return out
 

{reboost-0.2.1.dist-info → reboost-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.2.1
+Version: 0.2.2
 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

{reboost-0.2.1.dist-info → reboost-0.2.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
 reboost/__init__.py,sha256=RVNl3Qgx_hTUeBGXaWYmiTcmXUDhTfvlAGGC8bo_jP8,316
-reboost/_version.py,sha256=UoNvMtd4wCG76RwoSpNCUtaFyTwakGcZolfjXzNVSMY,511
+reboost/_version.py,sha256=OjGGK5TcHVG44Y62aAqeJH4CskkZoY9ydbHOtCDew50,511
 reboost/build_evt.py,sha256=5Q3T0LCl8xMtyRRhcs6layC1xh4vp2f26PgB1yab2zs,4798
-reboost/build_glm.py,sha256=kxQN6MYl-vfKnOHufPqf5ifEoaToqaR30iMXISxIhYQ,9253
-reboost/build_hit.py,sha256=sJR2qXup-qP1IoDLRxquuTyeI7DP_1S80QZ-w94qaZY,13293
+reboost/build_glm.py,sha256=5cuHnMogRKGaVCi4eqTrgDroLFy4s8mGp2nKcKfKQGI,9243
+reboost/build_hit.py,sha256=yAjYmBJUZvnyTuU_kpuJle_TKeSU027OIJr7No9z2Ms,13476
 reboost/build_tcm.py,sha256=N1rZwht88ZaKWmURch1VrVUbQROXfP56D0aj_JLsRhU,2951
 reboost/cli.py,sha256=HTZ05DRnDodcf_D6BJCCavx5HqhKDadJCgf-oh8HTJk,6365
-reboost/core.py,sha256=AamREubQsAqJ-y10NRx18r-PuqlQj3iTl2PzOTWXGQI,10540
+reboost/core.py,sha256=7Nclc6RUCOSJ1CWVAX0rFNJGM1LEgqvc4tD04CxEAtg,10766
 reboost/iterator.py,sha256=cqfh3c0uLP67S0YGaw05-McZQzdMb8BISULIm3PEbKA,3990
 reboost/log_utils.py,sha256=VqS_9OC5NeNU3jcowVOBB0NJ6ssYvNWnirEY-JVduEA,766
 reboost/profile.py,sha256=EOTmjmS8Rm_nYgBWNh6Rntl2XDsxdyed7yEdWtsZEeg,2598
@@ -14,7 +14,7 @@ reboost/hpge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 reboost/hpge/psd.py,sha256=vFs8Y5XVW261pB6aOvWmIDzqOaBg-gEOLhL9PbjlEKI,2113
 reboost/hpge/surface.py,sha256=SZyTmOCTipf27jYaJhtdInzGF1RZ2wKpbtf6HlOQYwM,3662
 reboost/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reboost/math/functions.py,sha256=ZgQpm87pGE0wH4Ekjm-8SbEmzfZ5MlAxS-fTw0RsNMc,1875
+reboost/math/functions.py,sha256=OymiYTcA0NXxxm-MBDw5kqyNwHoLCmuv4J48AwnSrbU,5633
 reboost/math/stats.py,sha256=iiOEi87x93kqPWeSmlRiA5Oe-R8XR-plm6Z532PhC9M,1401
 reboost/optmap/__init__.py,sha256=imvuyld-GLw8qdwqW-lXCg2feptcTyQo3wIzPvDHwmY,93
 reboost/optmap/cli.py,sha256=wBexh-zrr5ABherEyk9xigxdArvOAKiiRQwAYon9Sro,9408
@@ -25,12 +25,12 @@ reboost/optmap/mapview.py,sha256=73kpe0_SKDj9bIhEx1ybX1sBP8TyvufiLfps84A_ijA,679
 reboost/optmap/numba_pdg.py,sha256=y8cXR5PWE2Liprp4ou7vl9do76dl84vXU52ZJD9_I7A,731
 reboost/optmap/optmap.py,sha256=j4rfbQ84PYSpE-BvP4Rdt96ZjPdwy8P4e4eZz1mATys,12817
 reboost/shape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reboost/shape/cluster.py,sha256=Cj4V1maPR-q_w6rKwF_hLW3Zmsv6zHva_I5oA2mm3PY,7442
+reboost/shape/cluster.py,sha256=RIvBlhHzp88aaUZGofp5SD9bimnoiqIOddhQ84jiwoM,8135
 reboost/shape/group.py,sha256=bSmFCl_yi1hGaKudjiicDEJsiBNyAHiKYdr8ZuH4pSM,4406
 reboost/shape/reduction.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reboost-0.2.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-reboost-0.2.1.dist-info/METADATA,sha256=zSFjGcEzPVcoBtwwbVyRdbI95BooP7swkYvojFfqNjU,44219
-reboost-0.2.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-reboost-0.2.1.dist-info/entry_points.txt,sha256=DxhD6BidSWNot9BrejHJjQ7RRLmrMaBIl52T75oWTwM,93
-reboost-0.2.1.dist-info/top_level.txt,sha256=q-IBsDepaY_AbzbRmQoW8EZrITXRVawVnNrB-_zyXZs,8
-reboost-0.2.1.dist-info/RECORD,,
+reboost-0.2.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+reboost-0.2.2.dist-info/METADATA,sha256=F4NsVNDavleMAL-xEYSpR5ElKHtjQXLevD_-XAaT3y4,44219
+reboost-0.2.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+reboost-0.2.2.dist-info/entry_points.txt,sha256=DxhD6BidSWNot9BrejHJjQ7RRLmrMaBIl52T75oWTwM,93
+reboost-0.2.2.dist-info/top_level.txt,sha256=q-IBsDepaY_AbzbRmQoW8EZrITXRVawVnNrB-_zyXZs,8
+reboost-0.2.2.dist-info/RECORD,,