pygama 2.3.8a2__tar.gz → 2.3.8a3__tar.gz

{pygama-2.3.8a2/src/pygama.egg-info → pygama-2.3.8a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygama
-Version: 2.3.8a2
+Version: 2.3.8a3
 Summary: Python package for data processing and analysis
 Author: The LEGEND collaboration
 Maintainer: The LEGEND collaboration

{pygama-2.3.8a2 → pygama-2.3.8a3}/src/pygama/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.3.8a2'
-__version_tuple__ = version_tuple = (2, 3, 8, 'a2')
+__version__ = version = '2.3.8a3'
+__version_tuple__ = version_tuple = (2, 3, 8, 'a3')
 
-__commit_id__ = commit_id = 'g13d41716a'
+__commit_id__ = commit_id = 'g5a070cc53'

{pygama-2.3.8a2 → pygama-2.3.8a3}/src/pygama/evt/build_evt.py

@@ -308,6 +308,9 @@ def build_evt_cols(
                 if "lgdo_attrs" in v:
                     obj.attrs |= v["lgdo_attrs"]
 
+                if "description" in v:
+                    obj.attrs["description"] = v["description"]
+
             # else we build the event entry
             else:
                 if "channels" not in v:
@@ -357,6 +360,9 @@ def build_evt_cols(
                 if "lgdo_attrs" in v:
                     obj.attrs |= v["lgdo_attrs"]
 
+                if "description" in v:
+                    obj.attrs["description"] = v["description"]
+
             # cast to type, if required
             # hijack the poor LGDO
             if "dtype" in v:

{pygama-2.3.8a2 → pygama-2.3.8a3}/src/pygama/hit/build_hit.py

@@ -156,6 +156,9 @@ def build_hit(
                 if "lgdo_attrs" in info:
                     outcol.attrs |= info["lgdo_attrs"]
 
+                if "description" in info:
+                    outcol.attrs["description"] = info["description"]
+
                 log.debug("made new column %r=%r", outname, outcol)
                 outtbl_obj.add_column(outname, outcol)
 

{pygama-2.3.8a2 → pygama-2.3.8a3}/src/pygama/pargen/AoE_cal.py

@@ -18,6 +18,7 @@ import pandas as pd
 from iminuit import Minuit, cost
 from matplotlib.colors import LogNorm
 from scipy.stats import chi2
+from sklearn.covariance import MinCovDet
 
 import pygama.math.binned_fitting as pgf
 import pygama.math.histogram as pgh
@@ -743,6 +744,290 @@ def interpolate_consecutive(tstamps, means, times, aoe_param, output_name):
     return out_dict
 
 
+def bimodal_dt_fit(
+    data: pd.DataFrame,
+    aoe_param: str,
+    dt_param: str,
+    fit_selection: str,
+    cal_energy_param: str,
+    pdf,
+    debug_mode: bool = False,
+    display: int = 0,
+    **_kwargs,
+) -> tuple[float, dict]:
+    """
+    Calculates the correction needed to align the two drift time regions for ICPC detectors.
+    This is done by fitting the two drift time peaks in the drift time spectrum and then
+    fitting the A/E peaks in each of these regions. A simple linear correction is then applied
+    to align these regions.
+
+    Parameters
+    ----------
+    data
+        DataFrame containing the data.
+    aoe_param
+        Name of the A/E parameter to use as starting point.
+    dt_param
+        Name of the drift time parameter.
+    fit_selection
+        Selection string for the fit.
+    cal_energy_param
+        Name of the calibrated energy parameter.
+    pdf
+        PDF to use for the A/E fit.
+    debug_mode
+        If True, re-raises exceptions instead of logging them.
+    display
+        Plot verbosity level.
+
+    Returns
+    -------
+    alpha
+        Linear correction coefficient.
+    dt_res_dict
+        Dictionary containing intermediate fit results.
+    """
+    log.info("Starting A/E drift time correction (bimodal_dt_fit mode)")
+    dt_res_dict = {}
+    alpha = 0
+    try:
+        dep_events = data.query(
+            f"{fit_selection}&{cal_energy_param}>1582&{cal_energy_param}<1602&{cal_energy_param}=={cal_energy_param}&{aoe_param}=={aoe_param}"
+        )
+
+        hist, bins, var = pgh.get_hist(
+            dep_events[aoe_param],
+            bins=500,
+        )
+        bin_cs = (bins[1:] + bins[:-1]) / 2
+        mu = bin_cs[np.argmax(hist)]
+        aoe_range = [mu * 0.9, mu * 1.1]
+
+        dt_range = [
+            np.nanpercentile(dep_events[dt_param], 1),
+            np.nanpercentile(dep_events[dt_param], 99),
+        ]
+
+        dt_res_dict["final_selection"] = (
+            f"{aoe_param}>{aoe_range[0]}&{aoe_param}<{aoe_range[1]}&{dt_param}>{dt_range[0]}&{dt_param}<{dt_range[1]}&{dt_param}=={dt_param}"
+        )
+
+        final_df = dep_events.query(dt_res_dict["final_selection"])
+
+        hist, bins, var = pgh.get_hist(
+            final_df[dt_param],
+            dx=32,
+            range=(
+                np.nanmin(final_df[dt_param]),
+                np.nanmax(final_df[dt_param]),
+            ),
+        )
+
+        bcs = pgh.get_bin_centers(bins)
+        mus = bcs[pgc.get_i_local_maxima(hist / (np.sqrt(var) + 10**-99), 2)]
+        pk_pars, _pk_covs = pgc.hpge_fit_energy_peak_tops(
+            hist,
+            bins,
+            var=var,
+            peak_locs=mus,
+            n_to_fit=5,
+        )
+
+        mus = pk_pars[:, 0]
+        sigmas = pk_pars[:, 1]
+        amps = pk_pars[:, 2]
+
+        if len(mus) > 2:
+            ids = np.array(
+                sorted([np.argmax(amps), np.argmax(amps[amps != np.argmax(amps)])])
+            )
+        else:
+            ids = np.full(len(mus), True, dtype=bool)
+        mus = mus[ids]
+        sigmas = sigmas[ids]
+        amps = amps[ids]
+
+        dt_res_dict["dt_fit"] = {"mus": mus, "sigmas": sigmas, "amps": amps}
+
+        if len(mus) < 2:
+            log.info("Only 1 drift time peak found, no correction needed")
+
+        else:
+            aoe_grp1 = dt_res_dict["aoe_grp1"] = (
+                f"{dt_param}>{mus[0] - 2 * sigmas[0]} & {dt_param}<{mus[0] + 2 * sigmas[0]}"
+            )
+            aoe_grp2 = dt_res_dict["aoe_grp2"] = (
+                f"{dt_param}>{mus[1] - 2 * sigmas[1]} & {dt_param}<{mus[1] + 2 * sigmas[1]}"
+            )
+
+            aoe_pars, aoe_errs, _, _ = unbinned_aoe_fit(
+                final_df.query(aoe_grp1)[aoe_param], pdf=pdf, display=display
+            )
+            dt_res_dict["aoe_fit1"] = {
+                "pars": aoe_pars.to_dict(),
+                "errs": aoe_errs.to_dict(),
+            }
+
+            aoe_pars2, aoe_errs2, _, _ = unbinned_aoe_fit(
+                final_df.query(aoe_grp2)[aoe_param], pdf=pdf, display=display
+            )
+            dt_res_dict["aoe_fit2"] = {
+                "pars": aoe_pars2.to_dict(),
+                "errs": aoe_errs2.to_dict(),
+            }
+
+            try:
+                alpha = (aoe_pars2["mu"] - aoe_pars["mu"]) / (
+                    (mus[0] * aoe_pars["mu"]) - (mus[1] * aoe_pars2["mu"])
+                )
+            except ZeroDivisionError:
+                alpha = 0
+
+            dt_res_dict["alpha"] = alpha
+            log.info("dtcorr successful alpha: %s", alpha)
+
+    except BaseException as e:
+        if isinstance(e, KeyboardInterrupt) or debug_mode:
+            raise e
+        log.error("Drift time correction (bimodal_dt_fit) failed")
+
+    return alpha, dt_res_dict
+
+
+def mcdrift(
+    data: pd.DataFrame,
+    aoe_param: str,
+    dt_param: str,
+    fit_selection: str,
+    cal_energy_param: str,
+    debug_mode: bool = False,
+    **_kwargs,
+) -> tuple[float, dict]:
+    """
+    Calculates the drift time correction for the A/E parameter using the
+    Minimum Covariance Determinant (MCD) method and PCA on the (AoE, dt_eff) distribution.
+
+    Parameters
+    ----------
+    data
+        DataFrame containing the data.
+    aoe_param
+        Name of the A/E parameter to use as starting point.
+    dt_param
+        Name of the drift time parameter.
+    fit_selection
+        Selection string for the fit.
+    cal_energy_param
+        Name of the calibrated energy parameter.
+    debug_mode
+        If True, re-raises exceptions instead of logging them.
+
+    Returns
+    -------
+    alpha
+        Linear correction coefficient.
+    dt_res_dict
+        Dictionary containing intermediate fit results.
+    """
+    log.info("Starting A/E drift time correction (MCD mode)")
+
+    try:
+        CC_events = data.query(
+            f"{fit_selection}&{cal_energy_param}=={cal_energy_param}&{aoe_param}=={aoe_param}&{dt_param}=={dt_param}"
+        )
+    except Exception as e:
+        if debug_mode:
+            raise e
+        log.error("MCD drift: event selection query failed: %s", e)
+        return 0, {}
+
+    peaks = np.array([1080, 1094, 1459, 1512, 1552, 1620, 1650, 1670, 1830, 2105])
+    CC_selection = (CC_events[cal_energy_param] >= 1000) & (
+        CC_events[cal_energy_param] <= 2400
+    )
+    for peak in peaks:
+        CC_selection &= ~(
+            (CC_events[cal_energy_param] >= peak - 5)
+            & (CC_events[cal_energy_param] <= peak + 5)
+        )
+    CC_events = CC_events[CC_selection]
+
+    if len(CC_events) == 0:
+        log.error("MCD drift: no CC events found after selection")
+        return 0, {}
+
+    aoe_vals = CC_events[aoe_param].to_numpy()
+    dt_vals = CC_events[dt_param].to_numpy() / 1000.0  # convert to us for stability
+    mcd_data = np.column_stack([aoe_vals, dt_vals])
+
+    # --- find AoE range ---
+    classifier = mcd_data[:, 0]
+    xrange = (0.9, 1.1)
+    bin_width_x = (
+        0.5
+        * (np.nanpercentile(classifier, 75) - np.nanpercentile(classifier, 25))
+        * len(classifier) ** (-1 / 3)
+    )
+    if bin_width_x <= 0:
+        log.error("MCD drift: degenerate AoE distribution, bin width <= 0")
+        return 0, {}
+
+    xbins = int((xrange[1] - xrange[0]) / bin_width_x)
+    counts, bin_edges = np.histogram(classifier, bins=xbins, range=xrange, density=True)
+    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+    peak_position = bin_centers[np.argmax(counts)]
+    half_max = np.max(counts) / 2.0
+    indices_above_half = np.where(counts >= half_max)[0]
+
+    if len(indices_above_half) < 2:
+        log.error("MCD drift: could not determine FWHM of AoE peak")
+        return 0, {}
+
+    bw = bin_centers[1] - bin_centers[0]
+    fwhm = bin_centers[indices_above_half[-1]] - bin_centers[indices_above_half[0]] + bw
+    x_low = peak_position - 2 * fwhm
+    x_high = peak_position + 3 * fwhm
+
+    # --- MCD fit ---
+    in_x = (mcd_data[:, 0] >= x_low) & (mcd_data[:, 0] <= x_high)
+    in_y = (mcd_data[:, 1] >= 0) & (
+        mcd_data[:, 1] <= np.quantile(mcd_data[:, 1], 0.999)
+    )
+    subset = mcd_data[in_x & in_y]
+
+    if len(subset) < 2:
+        log.error("MCD drift: insufficient events in AoE range for MCD fit")
+        return 0, {}
+
+    try:
+        mcd = MinCovDet().fit(subset)
+    except Exception as e:
+        if debug_mode:
+            raise e
+        log.error("MCD drift: MCD fit failed: %s", e)
+        return 0, {}
+
+    # --- PCA slope ---
+    _, eigvecs = np.linalg.eigh(mcd.covariance_)
+    principal = eigvecs[:, -1]
+    if abs(principal[0]) > abs(principal[1]):
+        log.warning(
+            "Principal eigenvector not aligned with drift time axis (|v_aoe|=%.4f > |v_dt|=%.4f), "
+            "switching to minor eigenvector",
+            abs(principal[0]),
+            abs(principal[1]),
+        )
+        principal = eigvecs[:, -2]
+
+    if abs(principal[1]) < 1e-10:
+        log.error("MCD drift: eigenvector has near-zero dt component")
+        return 0, {}
+
+    alpha = -principal[0] / principal[1] / 1000.0
+    log.info("dtcorr (MCD) successful alpha: %s", alpha)
+    return alpha, {"alpha": alpha}
+
+
 class CalAoE:
     """
     Class for calibrating the A/E,
@@ -1149,15 +1434,17 @@ class CalAoE:
     def drift_time_correction(
         self,
         data: pd.DataFrame,
-        aoe_param,
-        out_param="AoE_DTcorr",
+        aoe_param: str = "AoE_Timecorr",
+        out_param: str = "AoE_DTcorr",
+        mode: str = "mcdrift",
         display: int = 0,
     ):
         """
-        Calculates the correction needed to align the two drift time regions for ICPC detectors.
-        This is done by fitting the two drift time peaks in the drift time spectrum and then
-        fitting the A/E peaks in each of these regions. A simple linear correction is then applied
-        to align these regions.
+        Apply a linear drift-time correction to the A/E distribution.
+
+        Estimates a linear correction coefficient to align the A/E values
+        across drift time and writes the corrected parameter to the DataFrame
+        and calibration dictionary.
 
         Parameters
         ----------
@@ -1165,119 +1452,46 @@ class CalAoE:
         data
             DataFrame containing the data.
         aoe_param
-            Name of the A/E parameter to use as starting point.
+            Name of the A/E parameter to use as the starting point for correction.
         out_param
-            Name of the output parameter for the drift-time-corrected A/E in the dataframe and to
-            be added to the calibration dictionary.
+            Name of the output parameter for the drift-time-corrected A/E,
+            stored in the DataFrame and added to the calibration dictionary.
+        mode
+            Mode used to estimate the correction coefficient. Options:
+            - ``"mcdrift"``  : Minimum Covariance Determinant (MCD) based estimation
+            (improved stability for low statistic and no evident structure)
+            - ``"bimodal_dt_fit"``  : Fit the position of two drift time peaks
+            (heavily relying on DEP events and clear structure).
         display
             Plot verbosity level.
 
         """
         log.info("Starting A/E drift time correction")
-        self.dt_res_dict = {}
-        try:
-            dep_events = data.query(
-                f"{self.fit_selection}&{self.cal_energy_param}>1582&{self.cal_energy_param}<1602&{self.cal_energy_param}=={self.cal_energy_param}&{aoe_param}=={aoe_param}"
-            )
 
-            hist, bins, var = pgh.get_hist(
-                dep_events[aoe_param],
-                bins=500,
-            )
-            bin_cs = (bins[1:] + bins[:-1]) / 2
-            mu = bin_cs[np.argmax(hist)]
-            aoe_range = [mu * 0.9, mu * 1.1]
-
-            dt_range = [
-                np.nanpercentile(dep_events[self.dt_param], 1),
-                np.nanpercentile(dep_events[self.dt_param], 99),
-            ]
-
-            self.dt_res_dict["final_selection"] = (
-                f"{aoe_param}>{aoe_range[0]}&{aoe_param}<{aoe_range[1]}&{self.dt_param}>{dt_range[0]}&{self.dt_param}<{dt_range[1]}&{self.dt_param}=={self.dt_param}"
-            )
-
-            final_df = dep_events.query(self.dt_res_dict["final_selection"])
-
-            hist, bins, var = pgh.get_hist(
-                final_df[self.dt_param],
-                dx=32,
-                range=(
-                    np.nanmin(final_df[self.dt_param]),
-                    np.nanmax(final_df[self.dt_param]),
-                ),
-            )
-
-            bcs = pgh.get_bin_centers(bins)
-            mus = bcs[pgc.get_i_local_maxima(hist / (np.sqrt(var) + 10**-99), 2)]
-            pk_pars, _pk_covs = pgc.hpge_fit_energy_peak_tops(
-                hist,
-                bins,
-                var=var,
-                peak_locs=mus,
-                n_to_fit=5,
-            )
-
-            mus = pk_pars[:, 0]
-            sigmas = pk_pars[:, 1]
-            amps = pk_pars[:, 2]
-
-            if len(mus) > 2:
-                ids = np.array(
-                    sorted([np.argmax(amps), np.argmax(amps[amps != np.argmax(amps)])])
-                )
-            else:
-                ids = np.full(len(mus), True, dtype=bool)
-            mus = mus[ids]
-            sigmas = sigmas[ids]
-            amps = amps[ids]
-
-            self.dt_res_dict["dt_fit"] = {"mus": mus, "sigmas": sigmas, "amps": amps}
-
-            if len(mus) < 2:
-                log.info("Only 1 drift time peak found, no correction needed")
-                self.alpha = 0
-
-            else:
-                aoe_grp1 = self.dt_res_dict["aoe_grp1"] = (
-                    f"{self.dt_param}>{mus[0] - 2 * sigmas[0]} & {self.dt_param}<{mus[0] + 2 * sigmas[0]}"
-                )
-                aoe_grp2 = self.dt_res_dict["aoe_grp2"] = (
-                    f"{self.dt_param}>{mus[1] - 2 * sigmas[1]} & {self.dt_param}<{mus[1] + 2 * sigmas[1]}"
-                )
-
-                aoe_pars, aoe_errs, _, _ = unbinned_aoe_fit(
-                    final_df.query(aoe_grp1)[aoe_param], pdf=self.pdf, display=display
-                )
-
-                self.dt_res_dict["aoe_fit1"] = {
-                    "pars": aoe_pars.to_dict(),
-                    "errs": aoe_errs.to_dict(),
-                }
-
-                aoe_pars2, aoe_errs2, _, _ = unbinned_aoe_fit(
-                    final_df.query(aoe_grp2)[aoe_param], pdf=self.pdf, display=display
-                )
-
-                self.dt_res_dict["aoe_fit2"] = {
-                    "pars": aoe_pars2.to_dict(),
-                    "errs": aoe_errs2.to_dict(),
-                }
-
-                try:
-                    self.alpha = (aoe_pars2["mu"] - aoe_pars["mu"]) / (
-                        (mus[0] * aoe_pars["mu"]) - (mus[1] * aoe_pars2["mu"])
-                    )
-                except ZeroDivisionError:
-                    self.alpha = 0
-                self.dt_res_dict["alpha"] = self.alpha
-                log.info("dtcorr successful alpha:%s", self.alpha)
+        _modes = {
+            "mcdrift": mcdrift,
+            "bimodal_dt_fit": bimodal_dt_fit,
+        }
 
-        except BaseException as e:
-            if isinstance(e, KeyboardInterrupt) or self.debug_mode:
-                raise (e)
-            log.error("Drift time correction failed")
+        if mode not in _modes:
             self.alpha = 0
+            log.error(
+                "Unknown mode '%s' for drift time correction. Valid options are: %s",
+                mode,
+                list(_modes),
+            )
+            return
+
+        self.alpha, self.dt_res_dict = _modes[mode](
+            data,
+            aoe_param,
+            dt_param=self.dt_param,
+            fit_selection=self.fit_selection,
+            cal_energy_param=self.cal_energy_param,
+            pdf=self.pdf,
+            debug_mode=self.debug_mode,
+            display=display,
+        )
 
         data[out_param] = data[aoe_param] * (1 + self.alpha * data[self.dt_param])
         self.update_cal_dicts(
@@ -1923,6 +2137,7 @@ class CalAoE:
         sf_nsamples: int = 11,
         sf_cut_range: tuple = (-5, 5),
         timecorr_mode: str = "full",
+        dtcorr_mode: str = "mcdrift",
         override_dict: dict | None = None,
     ):
         """
@@ -1950,6 +2165,8 @@ class CalAoE:
             Range of A/E cut values to use for the survival fraction sweep.
         timecorr_mode
             Mode to use for the time correction; see :meth:`time_correction` for details.
+        dtcorr_mode
+            Mode to use for the drift time correction; see :meth:`drift_time_correction` for details.
         override_dict
             Optional dictionary of pre-computed calibration entries that bypass one or more
             fit steps. Each key should map to a sub-dict with ``"expression"`` (a string
@@ -1993,7 +2210,9 @@ class CalAoE:
         if self.dt_corr is True:
             aoe_param = "AoE_DTcorr"
             if override_dict is None or "AoE_DTcorr" not in override_dict:
-                self.drift_time_correction(df, "AoE_Timecorr", out_param=aoe_param)
+                self.drift_time_correction(
+                    df, "AoE_Timecorr", out_param=aoe_param, mode=dtcorr_mode
+                )
             else:
                 self.update_cal_dicts({"AoE_DTcorr": override_dict["AoE_DTcorr"]})
                 df["AoE_DTcorr"] = ne.evaluate(

{pygama-2.3.8a2 → pygama-2.3.8a3}/src/pygama/pargen/dplms_ge_dict.py

@@ -14,7 +14,6 @@ from lgdo import Table
 from scipy.signal import convolve, convolve2d
 from scipy.stats import chi2
 
-from pygama.pargen.data_cleaning import generate_cuts
 from pygama.pargen.dsp_optimize import run_one_dsp
 from pygama.pargen.energy_optimisation import fom_fwhm_with_alpha_fit
 
@@ -39,7 +38,8 @@ def dplms_ge_dict(
     Parameters
     ----------
     raw_fft
-        table with fft raw data
+        Table with FFT raw data already baseline-selected upstream. All events in
+        this table are used to estimate the noise matrix.
     raw_cal
         table with cal raw data
     dsp_config
@@ -57,33 +57,18 @@ def dplms_ge_dict(
     """
 
     t0 = time.time()
-    log.info("Selecting baselines")
+    log.info("Using baseline-selected FFT events")
 
     dsp_fft = run_one_dsp(raw_fft, dsp_config, db_dict=par_dsp)
 
-    cut_dict = generate_cuts(dsp_fft, cut_dict=dplms_dict["bls_cut_pars"])
-    log.debug("Cuts are %s", cut_dict)
-    idxs = np.full(len(dsp_fft), True, dtype=bool)
-    for outname, info in cut_dict.items():
-        outcol = dsp_fft.eval(info["expression"], info.get("parameters", None))
-        dsp_fft.add_column(outname, outcol)
-    for cut in cut_dict:
-        idxs = dsp_fft[cut].nda & idxs
-    log.debug("Applied Cuts")
-
     bl_field = dplms_dict["bl_field"]
-    log.info("... %s baselines after cuts", len(dsp_fft[bl_field].values.nda[idxs, :]))
+    log.info("... %s baselines", len(dsp_fft[bl_field].values.nda))
 
-    bls = dsp_fft[bl_field].values.nda[idxs, : dplms_dict["bsize"]]
-    bls_par = {}
-    bls_cut_pars = list(dplms_dict["bls_cut_pars"])
-    for par in bls_cut_pars:
-        bls_par[par] = dsp_fft[dplms_dict["bls_cut_pars"][par]["cut_parameter"]].nda
+    bls = dsp_fft[bl_field].values.nda[:, : dplms_dict["bsize"]]
     t1 = time.time()
     log.info(
-        "total events %s, %s baseline selected in %.2f s",
+        "using %s baseline-selected events for noise estimation in %.2f s",
         len(raw_fft),
-        len(bls),
         t1 - t0,
     )
     log.info(
@@ -304,27 +289,7 @@ def dplms_ge_dict(
                 ax.plot(wf)
         ax.legend(loc="upper right")
         plot_dict["bls"] = fig
-        fig, ax = plt.subplots(nrows=2, ncols=3, figsize=(16, 9), facecolor="white")
-        for ii, par in enumerate(bls_cut_pars):
-            if "parameters" in cut_dict[par]:
-                if "a" in cut_dict[par]["parameters"]:
-                    llo = cut_dict[par]["parameters"]["a"]
-                else:
-                    llo = np.nan
-                if "b" in cut_dict[par]["parameters"]:
-                    lup = cut_dict[par]["parameters"]["b"]
-                else:
-                    lup = np.nan
-            mean = (lup + llo) / 2
-            plo, pup = mean - 2 * (mean - llo), mean + 2 * (lup - mean)
-            hh, bb = np.histogram(bls_par[par], bins=np.linspace(plo, pup, 200))
-            ax.flat[ii].plot(bb[1:], hh, ds="steps", label=f"cut on {par}")
-            ax.flat[ii].axvline(lup, color="k", linestyle=":", label="selection")
-            ax.flat[ii].axvline(llo, color="k", linestyle=":")
-            ax.flat[ii].set_xlabel(par)
-            ax.flat[ii].set_yscale("log")
-            ax.flat[ii].legend(loc="upper right")
-        plot_dict["bl_sel"] = fig
+        plt.close()
 
         wf_idxs = np.random.choice(len(wfs), dplms_dict["n_plot"])  # noqa: NPY002
         wfs = wfs[wf_idxs]
@@ -343,6 +308,7 @@ def dplms_ge_dict(
         axin.set_xlim(wsize / 2 - dplms_dict["zoom"], wsize / 2 + dplms_dict["zoom"])
         axin.set_yticklabels("")
         plot_dict["wfs"] = fig
+        plt.close()
 
         peak_pos = dsp_cal["peak_pos"].nda
         risetime = dsp_cal["tp_90"].nda - dsp_cal["tp_10"].nda
@@ -392,6 +358,7 @@ def dplms_ge_dict(
         ax.flat[0].set_yscale("log")
         ax.flat[0].legend(loc="upper right")
         plot_dict["wf_sel"] = fig
+        plt.close()
 
         fig, ax = plt.subplots(figsize=(12, 6.75), facecolor="white")
         ax.plot(x, "r-", label="filter")
@@ -405,6 +372,8 @@ def dplms_ge_dict(
         )
         axin.set_yticklabels("")
         ax.indicate_inset_zoom(axin)
+        plot_dict["filter"] = fig
+        plt.close()
 
         return out_dict, plot_dict
     return out_dict

{pygama-2.3.8a2 → pygama-2.3.8a3/src/pygama.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygama
-Version: 2.3.8a2
+Version: 2.3.8a3
 Summary: Python package for data processing and analysis
 Author: The LEGEND collaboration
 Maintainer: The LEGEND collaboration