Add arithmetics (sum, mean), sort, and time_point_thresh_nopol

src/dspeed/processors/__init__.py

@@ -64,6 +64,9 @@
 # Mapping from function to name of module in which it is defined
 # To add a new function to processors, it must be added here!
 _modules = {
+    "mean": "arithmetic",
+    "mean_below_threshold": "arithmetic",
+    "sum": "arithmetic",
     "bl_subtract": "bl_subtract",
     "convolve_damped_oscillator": "convolutions",
     "convolve_exp": "convolutions",
@@ -131,13 +134,15 @@
     "saturation": "saturation",
     "soft_pileup_corr": "soft_pileup_corr",
     "soft_pileup_corr_bl": "soft_pileup_corr",
+    "sort": "sort",
     "svm_predict": "svm",
     "tf_model": "tf_model",
     "time_over_threshold": "time_over_threshold",
     "bi_level_zero_crossing_time_points": "time_point_thresh",
     "interpolated_time_point_thresh": "time_point_thresh",
     "multi_time_point_thresh": "time_point_thresh",
     "time_point_thresh": "time_point_thresh",
+    "time_point_thresh_nopol": "time_point_thresh",
     "asym_trap_filter": "trap_filters",
     "trap_filter": "trap_filters",
     "trap_norm": "trap_filters",

src/dspeed/processors/arithmetic.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import numpy as np
+from numba import guvectorize
+
+from ..utils import numba_defaults_kwargs as nb_kwargs
+
+
+@guvectorize(
+    [
+        "void(float32[:], float32[:])",
+        "void(float64[:], float64[:])",
+    ],
+    "(n)->()",
+    **nb_kwargs,
+)
+def sum(w_in: np.ndarray, result: float) -> None:
+    """Sum the waveform values from index a to b.
+
+    Parameters
+    ----------
+    w_in
+        the input waveform
+    result
+        the sum of all values in w_in.
+
+    YAML Configuration Example
+    --------------------------
+
+    .. code-block:: yaml
+
+        wf_sum:
+          function: sum
+          module: dspeed.processors
+          args:
+            - waveform
+            - wf_sum
+          unit:
+            - ADC
+    """
+    result[0] = np.nan
+
+    if np.isnan(w_in).any():
+        return
+
+    start = 0
+    end = len(w_in) - 1
+
+    if start < 0:
+        start = 0
+    if end > len(w_in) - 1:
+        end = len(w_in) - 1
+    if start > end:
+        return
+
+    total = 0.0
+    for i in range(start, end + 1):
+        total += w_in[i]
+
+    result[0] = total
+
+
+@guvectorize(
+    [
+        "void(float32[:], float32[:])",
+        "void(float64[:], float64[:])",
+    ],
+    "(n)->()",
+    **nb_kwargs,
+)
+def mean(w_in: np.ndarray, result: float) -> None:
+    """Calculate the mean of waveform values.
+
+    Parameters
+    ----------
+    w_in
+        the input waveform.
+    result
+        the mean of all values in w_in.
+
+    YAML Configuration Example
+    --------------------------
+
+    .. code-block:: yaml
+
+        wf_mean:
+          function: mean
+          module: dspeed.processors
+          args:
+            - waveform
+            - wf_mean
+          unit:
+            - ADC
+    """
+    result[0] = np.nan
+
+    if np.isnan(w_in).any():
+        return
+
+    start = 0
+    end = len(w_in) - 1
+
+    if start < 0:
+        start = 0
+    if end > len(w_in) - 1:
+        end = len(w_in) - 1
+    if start > end:
+        return
+
+    total = 0.0
+    for i in range(start, end + 1):
+        total += w_in[i]
+
+    result[0] = total / (end - start + 1)
+
+
+@guvectorize(
+    [
+        "void(float32[:], float32, float32[:])",
+        "void(float64[:], float64, float64[:])",
+    ],
+    "(n),()->()",
+    **nb_kwargs,
+)
+def mean_below_threshold(w_in: np.ndarray, threshold: float, result: float) -> None:
+    """Calculate the mean of waveform values that are below a threshold.
+
+    Parameters
+    ----------
+    w_in
+        the input waveform.
+    threshold
+        the threshold value. Only waveform values below this threshold
+        are included in the mean calculation.
+    result
+        the mean of all values in w_in that are below the threshold.
+        Returns NaN if no values are below the threshold.
+
+    YAML Configuration Example
+    --------------------------
+
+    .. code-block:: yaml
+
+        wf_mean_below_threshold:
+          function: mean_below_threshold
+          module: dspeed.processors
+          args:
+            - waveform
+            - 100
+            - wf_mean_below_threshold
+          unit:
+            - ADC
+    """
+    result[0] = np.nan
+
+    if np.isnan(w_in).any() or np.isnan(threshold):
+        return
+
+    total = 0.0
+    count = 0
+
+    for i in range(len(w_in)):
+        if w_in[i] < threshold:
+            total += w_in[i]
+            count += 1
+
+    if count == 0:
+        return
+
+    result[0] = total / count

src/dspeed/processors/sort.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import numpy as np
+from numba import guvectorize
+
+from ..utils import numba_defaults_kwargs as nb_kwargs
+
+
+@guvectorize(
+    ["void(float32[:], float32[:])", "void(float64[:], float64[:])"],
+    "(n)->(n)",
+    **nb_kwargs,
+)
+def sort(w_in: np.ndarray, w_out: np.ndarray) -> None:
+    """Return a sorted array using :func:`numpy.sort`.
+
+    Parameters
+    ----------
+    w_in
+        the input waveform.
+    w_out
+        the output sorted waveform.
+
+    YAML Configuration Example
+    --------------------------
+
+    .. code-block:: yaml
+
+        wf_sorted:
+          function: sort
+          module: dspeed.processors
+          args:
+            - waveform
+            - wf_sorted
+    """
+    w_out[:] = np.nan
+
+    if np.isnan(w_in).any():
+        return
+
+    w_out[:] = np.sort(w_in)

src/dspeed/processors/time_point_thresh.py

@@ -18,8 +18,11 @@
 def time_point_thresh(
     w_in: np.ndarray, a_threshold: float, t_start: int, walk_forward: int, t_out: float
 ) -> None:
-    """Find the index where the waveform value crosses the threshold, walking
-    either forward or backward from the starting index.
+    """Find the index where the waveform value crosses above the threshold, walking
+    either forward or backward from the starting index. Find only crossings where the
+    waveform is rising through the threshold when moving forward in time (polarity check).
+    Return the waveform index just before the threshold crossing (i.e. below the threshold
+    when searching forward and above the threshold when searching backward).
 
     Parameters
     ----------
@@ -81,6 +84,82 @@ def time_point_thresh(
                 return
 
 
+@guvectorize(
+    [
+        "void(float32[:], float32, float32, float32, float32[:])",
+        "void(float64[:], float64, float64, float64, float64[:])",
+    ],
+    "(n),(),(),()->()",
+    **nb_kwargs,
+)
+def time_point_thresh_nopol(
+    w_in: np.ndarray, a_threshold: float, t_start: int, walk_forward: int, t_out: float
+) -> None:
+    """Find the index where the waveform value crosses below a threshold, walking
+    either forward or backward from the starting index, without polarity check.
+    I.e., find the first crossing in the specified direction, regardless of whether the waveform is rising or falling.
+    Return the waveform index just above the threshold crossing.
+
+    Parameters
+    ----------
+    w_in
+        the input waveform.
+    a_threshold
+        the threshold value.
+    t_start
+        the starting index.
+    walk_forward
+        the backward (``0``) or forward (``1``) search direction.
+    t_out
+        the index where the waveform value crosses the threshold.
+
+    YAML Configuration Example
+    --------------------------
+
+    .. code-block:: yaml
+
+        tp_0:
+          function: time_point_thresh
+          module: dspeed.processors
+          args:
+            - wf_atrap
+            - bl_std
+            - tp_start
+            - 0
+            - tp_0
+          unit: ns
+    """
+    t_out[0] = np.nan
+
+    if (
+        np.isnan(w_in).any()
+        or np.isnan(a_threshold)
+        or np.isnan(t_start)
+        or np.isnan(walk_forward)
+    ):
+        return
+
+    if np.floor(t_start) != t_start:
+        raise DSPFatal("The starting index must be an integer")
+
+    if np.floor(walk_forward) != walk_forward:
+        raise DSPFatal("The search direction must be an integer")
+
+    if int(t_start) < 0 or int(t_start) >= len(w_in):
+        raise DSPFatal("The starting index is out of range")
+
+    if int(walk_forward) == 1:
+        for i in range(int(t_start), len(w_in) - 2, 1):
+            if w_in[i + 1] <= a_threshold:
+                t_out[0] = i
+                return
+    else:
+        for i in range(int(t_start), 0, -1):
+            if w_in[i - 1] < a_threshold:
+                t_out[0] = i
+                return
+
+
 @guvectorize(
     [
         "void(float32[:], float32, float32, int64, char, float32[:])",