reboost 0.5.5__tar.gz → 0.6.1__tar.gz

{reboost-0.5.5 → reboost-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reboost
-Version: 0.5.5
+Version: 0.6.1
 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
@@ -696,12 +696,14 @@ Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: hdf5plugin
 Requires-Dist: colorlog
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: numba
 Requires-Dist: legend-pydataobj>=1.14
 Requires-Dist: legend-pygeom-optics>=0.9.2
+Requires-Dist: legend-pygeom-tools>=0.0.11
 Requires-Dist: hist
 Requires-Dist: dbetto
 Requires-Dist: particle
@@ -721,8 +723,6 @@ Requires-Dist: pre-commit; extra == "test"
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: legend-pygeom-hpges; extra == "test"
-Requires-Dist: legend-pygeom-tools; extra == "test"
-Requires-Dist: pyg4ometry; extra == "test"
 Requires-Dist: pylegendtestdata>=0.6; extra == "test"
 Dynamic: license-file
 

{reboost-0.5.5 → reboost-0.6.1}/pyproject.toml

@@ -32,12 +32,14 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
+    "hdf5plugin",
     "colorlog",
     "numpy",
     "scipy",
     "numba",
-    "legend-pydataobj>=1.14",
-    "legend-pygeom-optics>=0.9.2",
+    "legend-pydataobj >=1.14",
+    "legend-pygeom-optics >=0.9.2",
+    "legend-pygeom-tools >=0.0.11",
     "hist",
     "dbetto",
     "particle",
@@ -74,10 +76,7 @@ test = [
     "pytest>=6.0",
     "pytest-cov",
     "legend-pygeom-hpges",
-    "legend-pygeom-tools",
-    "pyg4ometry",
     "pylegendtestdata>=0.6",
-
 ]
 
 [project.scripts]
@@ -147,6 +146,7 @@ ignore = [
   "D213",     # Multi-line docstring summary should start at the first line
   "D401",     # Summary does not need to be in imperative mood
   "D413",     # No blank line after last section in docstring
+  "PLC0415",  # we sometimes use relative imports for performance reasons
   "PLC2401",  # We like non-ASCII characters for math
 ]
 isort.required-imports = ["from __future__ import annotations"]

{reboost-0.5.5 → reboost-0.6.1}/src/reboost/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hdf5plugin
 from lgdo import lh5
 
 from ._version import version as __version__
@@ -10,4 +11,4 @@ __all__ = [
     "build_hit",
 ]
 
-lh5.settings.DEFAULT_HDF5_SETTINGS = {"shuffle": True, "compression": "lzf"}
+lh5.settings.DEFAULT_HDF5_SETTINGS = {"compression": hdf5plugin.Zstd()}

{reboost-0.5.5 → reboost-0.6.1}/src/reboost/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.5'
-__version_tuple__ = version_tuple = (0, 5, 5)
+__version__ = version = '0.6.1'
+__version_tuple__ = version_tuple = (0, 6, 1)

reboost-0.6.1/src/reboost/build_evt.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import logging
+
+import awkward as ak
+import numpy as np
+from dbetto import AttrsDict
+from lgdo import Array, Table, VectorOfVectors, lh5
+
+from . import core, math, shape, utils
+from .shape import group
+
+log = logging.getLogger(__name__)
+
+
+def build_evt(
+    tcm: VectorOfVectors,
+    hitfile: str,
+    outfile: str | None,
+    channel_groups: AttrsDict,
+    pars: AttrsDict,
+    run_part: AttrsDict,
+) -> Table | None:
+    """Build events out of a TCM.
+
+    Parameters
+    ----------
+    tcm
+        the time coincidence map.
+    hitfile
+        file with the hits.
+    outfile
+        the path to the output-file, if `None` with return
+        the events in memory.
+    channel_groups
+        a dictionary of groups of channels. For example:
+
+        .. code-block:: python
+
+            {"det1": "on", "det2": "off", "det3": "ac"}
+
+    pars
+        A dictionary of parameters. The first key should
+        be the run ID, followed by different sets of parameters
+        arranged in groups. Run numbers should be given in the
+        format `"p00-r001"`, etc.
+
+        For example:
+
+        .. code-block:: python
+
+            {"p03-r000": {"reso": {"det1": [1, 2], "det2": [0, 1]}}}
+
+    run_part
+        The run partitioning file giving the number of events
+        for each run. This should be organized as a dictionary
+        with the following format:
+
+        .. code-block:: python
+
+            {"p03-r000": 1000, "p03-r001": 2000}
+
+    Returns
+    -------
+    the event file in memory as a table if no output file is specified.
+    """
+    tcm_tables = utils.get_table_names(tcm)
+    tcm_ak = tcm.view_as("ak")
+
+    # loop over the runs
+    cum_sum = 0
+    tab = None
+
+    for idx, (run_full, n_event) in enumerate(run_part.items()):
+        period, run = run_full.split("-")
+        pars_tmp = pars[run_full]
+
+        # create an output table
+        out_tab = Table(size=n_event)
+
+        tcm_tmp = tcm_ak[cum_sum : cum_sum + n_event]
+
+        # usabilities
+
+        is_off = shape.group.get_isin_group(
+            tcm_tmp.table_key, channel_groups, tcm_tables, group="off"
+        )
+
+        # filter out off channels
+        channels = tcm_tmp.table_key[~is_off]
+        rows = tcm_tmp.row_in_table[~is_off]
+        out_tab.add_field("channel", VectorOfVectors(channels))
+        out_tab.add_field("row_in_table", VectorOfVectors(rows))
+
+        out_tab.add_field("period", Array(np.ones(len(channels)) * int(period[1:])))
+        out_tab.add_field("run", Array(np.ones(len(channels)) * int(run[1:])))
+
+        # now check for channels in ac
+        is_good = group.get_isin_group(channels, channel_groups, tcm_tables, group="on")
+
+        # get energy
+        energy_true = core.read_data_at_channel_as_ak(
+            channels, rows, hitfile, "energy", "hit", tcm_tables
+        )
+
+        energy = math.stats.apply_energy_resolution(
+            energy_true,
+            channels,
+            tcm_tables,
+            pars_tmp.reso,
+            lambda energy, sig0, sig1: np.sqrt(energy * sig1**2 + sig0**2),
+        )
+
+        out_tab.add_field("is_good", VectorOfVectors(is_good[energy > 25]))
+
+        out_tab.add_field("energy", VectorOfVectors(energy[energy > 25]))
+        out_tab.add_field("multiplicity", Array(ak.sum(energy > 25, axis=-1).to_numpy()))
+
+        # write table
+        wo_mode = "of" if idx == 0 else "append"
+
+        # add attrs
+        out_tab.attrs["tables"] = tcm.attrs["tables"]
+
+        if outfile is not None:
+            lh5.write(out_tab, "evt", outfile, wo_mode=wo_mode)
+        else:
+            tab = (
+                ak.concatenate((tab, out_tab.view_as("ak")))
+                if tab is not None
+                else out_tab.view_as("ak")
+            )
+
+    return Table(tab)

{reboost-0.5.5 → reboost-0.6.1}/src/reboost/core.py

@@ -5,7 +5,9 @@ import time
 from typing import Any
 
 import awkward as ak
+import numpy as np
 from dbetto import AttrsDict
+from lgdo import lh5
 from lgdo.types import LGDO, Table
 
 from . import utils
@@ -14,6 +16,78 @@ from .profile import ProfileDict
 log = logging.getLogger(__name__)
 
 
+def read_data_at_channel_as_ak(
+    channels: ak.Array, rows: ak.Array, file: str, field: str, group: str, tab_map: dict[int, str]
+) -> ak.Array:
+    r"""Read the data from a particular field to an awkward array. This replaces the TCM like object defined by the channels and rows with the corresponding data field.
+
+    Parameters
+    ----------
+    channels
+        Array of the channel indices (uids).
+    rows
+        Array of the rows in the files to gather data from.
+    file
+        File to read the data from.
+    field
+        the field to read.
+    group
+        the group to read data from (eg. `hit` or `stp`.)
+    tab_map
+        mapping between indices and table names. Of the form:
+
+        .. code:: python
+
+            {NAME: UID}
+
+        For example:
+
+        .. code:: python
+
+            {"det001": 1, "det002": 2}
+
+    Returns
+    -------
+    an array with the data, of the same same as the channels and rows.
+    """
+    # initialise the output
+    data_flat = None
+    tcm_rows_full = None
+
+    # save the unflattening
+    reorder = ak.num(rows)
+
+    for tab_name, key in tab_map.items():
+        # get the rows to read
+
+        idx = ak.flatten(rows[channels == key]).to_numpy()
+        arg_idx = np.argsort(idx)
+
+        # get the rows in the flattened data we want to append to
+        tcm_rows = np.where(ak.flatten(channels == key))[0]
+
+        # read the data with sorted idx
+        data_ch = lh5.read(f"{group}/{tab_name}/{field}", file, idx=idx[arg_idx]).view_as("ak")
+
+        # sort back to order for tcm
+        data_ch = data_ch[np.argsort(arg_idx)]
+
+        # append to output
+        data_flat = ak.concatenate((data_flat, data_ch)) if data_flat is not None else data_ch
+        tcm_rows_full = (
+            np.concatenate((tcm_rows_full, tcm_rows)) if tcm_rows_full is not None else tcm_rows
+        )
+
+    if len(data_flat) != len(tcm_rows_full):
+        msg = "every index in the tcm should have been read"
+        raise ValueError(msg)
+
+    # sort the final data
+    data_flat = data_flat[np.argsort(tcm_rows_full)]
+
+    return ak.unflatten(data_flat, reorder)
+
+
 def evaluate_output_column(
     hit_table: Table,
     expression: str,

reboost-0.6.1/src/reboost/math/stats.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import logging
+from typing import Callable
+
+import awkward as ak
+import numpy as np
+from lgdo import Array
+from numpy.typing import ArrayLike
+
+log = logging.getLogger(__name__)
+
+
+def get_resolution(
+    energies: ak.Array, channels: ak.Array, tcm_tables: dict, reso_pars: dict, reso_func: Callable
+) -> ak.Array:
+    """Get the resolution for each energy.
+
+    Parameters
+    ----------
+    energies
+        the energies to smear
+    channels
+        the channel index for each energy
+    tcm_tables
+        the mapping from indices to channel names.
+    reso_pars
+        the pars for each channel.
+    reso_func
+        the function to compute the resolution.
+    """
+    n_pars = len(reso_pars[next(iter(reso_pars))])
+
+    pars_shaped = []
+
+    for _ in range(n_pars):
+        pars_shaped.append(np.zeros(len(ak.flatten(channels))))
+
+    num = ak.num(channels, axis=-1)
+
+    for key, value in tcm_tables.items():
+        for i in range(n_pars):
+            pars_shaped[i][ak.flatten(channels) == value] = reso_pars[key][i]
+
+    ch_reso = reso_func(ak.flatten(energies), *pars_shaped)
+    return ak.unflatten(ch_reso, num)
+
+
+def apply_energy_resolution(
+    energies: ak.Array, channels: ak.Array, tcm_tables: dict, reso_pars: dict, reso_func: Callable
+):
+    """Apply the energy resolution sampling to an array with many channels.
+
+    Parameters
+    ----------
+    energies
+        the energies to smear
+    channels
+        the channel index for each energy
+    tcm_tables
+        the mapping from indices to channel names.
+    reso_pars
+        the pars for each channel.
+    reso_func
+        the function to compute the resolution.
+    """
+    num = ak.num(channels, axis=-1)
+
+    ch_reso = get_resolution(energies, channels, tcm_tables, reso_pars, reso_func)
+    energies_flat_smear = gaussian_sample(ak.flatten(energies), ak.flatten(ch_reso))
+
+    return ak.unflatten(energies_flat_smear, num)
+
+
+def gaussian_sample(mu: ArrayLike, sigma: ArrayLike | float, *, seed: int | None = None) -> Array:
+    r"""Generate samples from a gaussian.
+
+    Based on:
+
+    .. math::
+
+        y_i \sim \mathcal{N}(\mu_i,\sigma_i)
+
+    where $y_i$ is the output, $x_i$ the input (mu) and $\sigma$ is the standard
+    deviation for each point.
+
+    Parameters
+    ----------
+    mu
+        the mean positions to sample from, should be a flat (ArrayLike) object.
+    sigma
+        the standard deviation for each input value, can also be a single float.
+    seed
+        the random seed.
+
+    Returns
+    -------
+    sampled values.
+    """
+    # convert inputs
+
+    if isinstance(mu, Array):
+        mu = mu.view_as("np")
+    elif isinstance(mu, ak.Array):
+        mu = mu.to_numpy()
+    elif not isinstance(mu, np.ndarray):
+        mu = np.array(mu)
+
+    # similar for sigma
+    if isinstance(sigma, Array):
+        sigma = sigma.view_as("np")
+    elif isinstance(sigma, ak.Array):
+        sigma = sigma.to_numpy()
+    elif not isinstance(sigma, (float, int, np.ndarray)):
+        sigma = np.array(sigma)
+
+    rng = np.random.default_rng(seed=seed)  # Create a random number generator
+
+    return Array(rng.normal(loc=mu, scale=sigma))

{reboost-0.5.5 → reboost-0.6.1}/src/reboost/optmap/cli.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import argparse
-import json
 import logging
-from pathlib import Path
+
+import dbetto
 
 from ..log_utils import setup_log
 from ..utils import _check_input_file, _check_output_file
@@ -35,14 +35,18 @@ def optical_cli() -> None:
 
     subparsers = parser.add_subparsers(dest="command", required=True)
 
-    # STEP 1: build evt file from hit tier
-    evt_parser = subparsers.add_parser("evt", help="build evt file from remage hit file")
-    evt_parser.add_argument(
+    # 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 that contains a list of detector ids that are part of the input file",
-        required=True,
+        help="file with detector ids of all optical channels.",
     )
-    evt_parser.add_argument("input", help="input hit LH5 file", metavar="INPUT_HIT")
+    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
@@ -55,7 +59,20 @@ def optical_cli() -> None:
     )
     map_parser.add_argument(
         "--detectors",
-        help="file that contains a list of detector ids that will be produced as additional output maps.",
+        help=(
+            "file that contains a list of detector ids that will be produced as additional output maps."
+            + "By default, all channels will be included."
+        ),
+    )
+    map_parser_det_group = map_parser.add_mutually_exclusive_group(required=True)
+    map_parser_det_group.add_argument(
+        "--geom",
+        help="GDML geometry file",
+    )
+    map_parser_det_group.add_argument(
+        "--evt",
+        action="store_true",
+        help="the input file is already an optmap-evt file.",
     )
     map_parser.add_argument(
         "--n-procs",
@@ -69,7 +86,9 @@ def optical_cli() -> None:
         action="store_true",
         help="""Check map statistics after creation. default: %(default)s""",
     )
-    map_parser.add_argument("input", help="input evt LH5 file", metavar="INPUT_EVT", nargs="+")
+    map_parser.add_argument(
+        "input", help="input stp or optmap-evt LH5 file", metavar="INPUT_EVT", nargs="+"
+    )
     map_parser.add_argument("output", help="output map LH5 file", metavar="OUTPUT_MAP")
 
     # STEP 2b: view maps
@@ -171,7 +190,7 @@ def optical_cli() -> None:
     convolve_parser.add_argument(
         "--dist-mode",
         action="store",
-        default="multinomial+no-fano",
+        default="poisson+no-fano",
     )
     convolve_parser.add_argument("--output", help="output hit LH5 file", metavar="OUTPUT_HIT")
 
@@ -188,15 +207,18 @@ def optical_cli() -> None:
 
     # STEP 1: build evt file from hit tier
     if args.command == "evt":
-        from .evt import build_optmap_evt
+        from .evt import build_optmap_evt, get_optical_detectors_from_geom
 
-        _check_input_file(parser, args.detectors)
         _check_input_file(parser, args.input)
         _check_output_file(parser, args.output)
 
-        # load detector ids from a JSON array
-        with Path.open(Path(args.detectors)) as detectors_f:
-            detectors = json.load(detectors_f)
+        # 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)
 
@@ -209,23 +231,23 @@ def optical_cli() -> None:
 
         # load settings for binning from config file.
         _check_input_file(parser, args.input, "settings")
-        with Path.open(Path(args.settings)) as settings_f:
-            settings = json.load(settings_f)
+        settings = dbetto.utils.load_dict(args.settings)
 
-        chfilter = ()
+        chfilter = "*"
         if args.detectors is not None:
-            # load detector ids from a JSON array
-            with Path.open(Path(args.detectors)) as detectors_f:
-                chfilter = json.load(detectors_f)
+            # load detector ids from a JSON/YAML array
+            chfilter = dbetto.utils.load_dict(args.detectors)
 
         create_optical_maps(
             args.input,
             settings,
             args.bufsize,
+            is_stp_file=(not args.evt),
             chfilter=chfilter,
             output_lh5_fn=args.output,
             check_after_create=args.check,
             n_procs=args.n_procs,
+            geom_fn=args.geom,
         )
 
     # STEP 2b: view maps
@@ -251,8 +273,7 @@ def optical_cli() -> None:
 
         # load settings for binning from config file.
         _check_input_file(parser, args.input, "settings")
-        with Path.open(Path(args.settings)) as settings_f:
-            settings = json.load(settings_f)
+        settings = dbetto.utils.load_dict(args.settings)
 
         _check_input_file(parser, args.input)
         _check_output_file(parser, args.output)

{reboost-0.5.5 → reboost-0.6.1}/src/reboost/optmap/convolve.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import re
 
 import legendoptics.scintillate as sc
 import numba
@@ -24,8 +25,8 @@ OPTMAP_SUM_CH = -2
 
 def open_optmap(optmap_fn: str):
     maps = lh5.ls(optmap_fn)
-    # TODO: rewrite logic to only accept _<number> instead of a blacklist
-    det_ntuples = [m for m in maps if m not in ("all", "_hitcounts", "_hitcounts_exp", "all_orig")]
+    # only accept _<number> (/all is read separately)
+    det_ntuples = [m for m in maps if re.match(r"_\d+$", m)]
     detids = np.array([int(m.lstrip("_")) for m in det_ntuples])
     detidx = np.arange(0, detids.shape[0])
 
@@ -53,17 +54,25 @@ def open_optmap(optmap_fn: str):
 
     # give this check some numerical slack.
     if np.any(
-        ow[OPTMAP_SUM_CH][ow[OPTMAP_ANY_CH] >= 0] - ow[OPTMAP_ANY_CH][ow[OPTMAP_ANY_CH] >= 0]
+        np.abs(
+            ow[OPTMAP_SUM_CH][ow[OPTMAP_ANY_CH] >= 0] - ow[OPTMAP_ANY_CH][ow[OPTMAP_ANY_CH] >= 0]
+        )
         < -1e-15
     ):
         msg = "optical map does not fulfill relation sum(p_i) >= p_any"
         raise ValueError(msg)
 
-    # get the exponent from the optical map file
-    optmap_multi_det_exp = lh5.read("/_hitcounts_exp", optmap_fn).value
-    assert isinstance(optmap_multi_det_exp, float)
+    try:
+        # check the exponent from the optical map file
+        optmap_multi_det_exp = lh5.read("/_hitcounts_exp", optmap_fn).value
+        assert isinstance(optmap_multi_det_exp, float)
+        if np.isfinite(optmap_multi_det_exp):
+            msg = f"found finite _hitcounts_exp {optmap_multi_det_exp} which is not supported any more"
+            raise RuntimeError(msg)
+    except KeyError:  # the _hitcounts_exp might not be always present.
+        pass
 
-    return detids, detidx, optmap_edges, ow, optmap_multi_det_exp
+    return detids, detidx, optmap_edges, ow
 
 
 def iterate_stepwise_depositions(
@@ -71,7 +80,7 @@ def iterate_stepwise_depositions(
     optmap_for_convolve,
     scint_mat_params: sc.ComputedScintParams,
     rng: np.random.Generator = None,
-    dist: str = "multinomial",
+    dist: str = "poisson",
     mode: str = "no-fano",
 ):
     # those np functions are not supported by numba, but needed for efficient array access below.
@@ -144,7 +153,6 @@ def _iterate_stepwise_depositions(
     detidx,
     optmap_edges,
     optmap_weights,
-    optmap_multi_det_exp,
     scint_mat_params: sc.ComputedScintParams,
     dist: str,
     mode: str,
@@ -223,8 +231,6 @@ def _iterate_stepwise_depositions(
                 # we detect this energy deposition; we should at least get one photon out here!
 
                 detsel_size = 1
-                if np.isfinite(optmap_multi_det_exp):
-                    detsel_size = rng.geometric(1 - np.exp(-optmap_multi_det_exp))
 
                 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.
@@ -238,7 +244,7 @@ def _iterate_stepwise_depositions(
                         detp[d] = 0.0
                 det_no_stats += had_det_no_stats
 
-                # should be equivalent to rng.choice(detidx, size=(detsel_size, p=detp)
+                # 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")
                 ]
@@ -339,7 +345,7 @@ def convolve(
     material: str,
     output_file: str | None = None,
     buffer_len: int = int(1e6),
-    dist_mode: str = "multinomial+no-fano",
+    dist_mode: str = "poisson+no-fano",
 ):
     if material not in ["lar", "pen"]:
         msg = f"unknown material {material} for scintillation"
@@ -356,13 +362,18 @@ def convolve(
             (1 * pint.get_application_registry().ns),  # dummy!
         )
 
-    log.info("opening map %s", map_file)
-    optmap_for_convolve = open_optmap(map_file)
-
     # special handling of distributions and flags.
     dist, mode = dist_mode.split("+")
-    assert dist in ("multinomial", "poisson")
-    assert mode in ("", "no-fano")
+    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)