nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/generate_header.py

@@ -1,261 +0,0 @@
-import os
-import numpy as np
-from tomoscan.io import HDF5File
-from fabio.edfimage import EdfImage
-from ..io.utils import get_first_hdf5_entry
-from .utils import parse_params_values
-from .cli_configs import GenerateInfoConfig
-
-edf_header_hdf5_path = {
-    # EDF Header
-    "count_time": "/technique/scan/exposure_time",  # ms in HDF5
-    "date": "/start_time",
-    "energy": "/technique/scan/energy",
-    "flip": "/technique/detector/flipping",  # [x, y] in HDF5
-    "motors": "/instrument/positioners",
-    "optic_used": "/technique/optic/magnification",
-}
-
-info_hdf5_path = {
-    "Energy": "/technique/scan/energy",
-    "Distance": "/technique/scan/sample_detector_distance",  # mm in HDF5 and EDF
-    # ~ "Prefix": TODO
-    "Directory": "/technique/saving/path",
-    "ScanRange": "/technique/scan/scan_range",
-    "TOMO_N": "/technique/scan/tomo_n",
-    "REF_ON": "/technique/scan/ref_on",
-    "REF_N": "/technique/reference/ref_n",
-    "DARK_N": "/technique/dark/dark_n",
-    "Dim_1": "/technique/detector/size",  # array
-    "Dim_2": "/technique/detector/size",  # array
-    "Count_time": "/technique/scan/exposure_time",  # ms in HDF5, s in EDF ?
-    "Shutter_time": "/technique/scan/shutter_time",  # ms in HDF5, s in EDF ?
-    "Optic_used": "/technique/optic/magnification",
-    "PixelSize": "/technique/detector/pixel_size",  # array (microns)
-    "Date": "/start_time",
-    "Scan_Type": "/technique/scan/scan_type",
-    "SrCurrent": "/instrument/machine/current",
-    "Comment": "/technique/scan/comment",  # empty ?
-}
-
-
-def decode_bytes(content):
-    if isinstance(content, bytes):
-        return content.decode()
-    else:
-        return content
-
-
-def simulate_edf_header(fname, entry, return_dict=False):
-    edf_header = {
-        "ByteOrder": "LowByteFirst",
-    }
-    with HDF5File(fname, "r") as fid:
-        for edf_name, h5_path in edf_header_hdf5_path.items():
-            if edf_name == "motors":
-                continue
-            h5_path = entry + h5_path
-            edf_header[edf_name] = decode_bytes(fid[h5_path][()])
-        h5_motors = decode_bytes(fid[entry + edf_header_hdf5_path["motors"]])
-        edf_header["motor_mne"] = list(h5_motors.keys())
-        edf_header["motor_pos"] = [v[()] for v in h5_motors.values()]
-
-    # remove "scan_numbers" from motors
-    try:
-        idx = edf_header["motor_mne"].index("scan_numbers")
-        edf_header["motor_mne"].pop(idx)
-        edf_header["motor_pos"].pop(idx)
-    except ValueError:
-        pass
-
-    # remove invalid values from motor_pos
-    invalid_values = ["*DIS*"]
-    try:
-        for invalid_val in invalid_values:
-            idx = edf_header["motor_pos"].index(invalid_val)
-            edf_header["motor_mne"].pop(idx)
-            edf_header["motor_pos"].pop(idx)
-    except ValueError:
-        pass
-
-    # Format
-    edf_header["flip"] = "<flip x : %s,flip y : %s>" % (edf_header["flip"][0], edf_header["flip"][1])
-    edf_header["motor_mne"] = " ".join(edf_header["motor_mne"])
-    edf_header["motor_pos"] = " ".join(list(map(str, edf_header["motor_pos"])))
-    edf_header["count_time"] = edf_header["count_time"] * 1e-3  # HDF5: ms -> EDF: s
-
-    if return_dict:
-        return edf_header
-    res = ""
-    for k, v in edf_header.items():
-        res = res + "%s = %s ;\n" % (k, v)
-    return res
-
-
-def simulate_info_file(fname, entry, return_dict=False):
-    info_file_content = {}
-    with HDF5File(fname, "r") as fid:
-        for info_name, h5_path in info_hdf5_path.items():
-            h5_path = entry + h5_path
-            info_file_content[info_name] = decode_bytes(fid[h5_path][()])
-
-    info_file_content["Dim_1"] = info_file_content["Dim_1"][0]
-    info_file_content["Dim_2"] = info_file_content["Dim_2"][1]
-    info_file_content["PixelSize"] = info_file_content["PixelSize"][0]
-    info_file_content["Prefix"] = os.path.basename(fname)
-    info_file_content["Col_end"] = info_file_content["Dim_1"] - 1
-    info_file_content["Col_beg"] = 0
-    info_file_content["Row_end"] = info_file_content["Dim_2"] - 1
-    info_file_content["Row_beg"] = 0
-    for what in ["Count_time", "Shutter_time"]:
-        info_file_content[what] = info_file_content[what] * 1e-3
-
-    if return_dict:
-        return info_file_content
-    # Format
-    res = ""
-    for k, v in info_file_content.items():
-        k_s = str("%s=" % k)
-        sep = " " * (24 - len(k_s))
-        res = res + k_s + sep + str("%s\n" % v)
-    return res
-
-
-def get_hst_saturations(hist, bins, numels):
-    aMin = bins[0]
-    aMax = bins[-1]
-    hist_sum = numels * 1.0
-
-    hist_cum = np.cumsum(hist)
-    hist_cum_rev = np.cumsum(hist[::-1])
-
-    i_s1 = np.where(hist_cum > 0.00001 * hist_sum)[0][0]
-    sat1 = aMin + i_s1 * (aMax - aMin) / (hist.size - 1)
-
-    i_S1 = np.where(hist_cum > 0.002 * hist_sum)[0][0]
-    Sat1 = aMin + i_S1 * (aMax - aMin) / (hist.size - 1)
-
-    i_s2 = np.argwhere(hist_cum_rev > 0.00001 * hist_sum)[0][0]
-    sat2 = aMin + (hist.size - 1 - i_s2) * (aMax - aMin) / (hist.size - 1)
-
-    i_S2 = np.argwhere(hist_cum_rev > 0.002 * hist_sum)[0][0]
-    Sat2 = aMin + (hist.size - 1 - i_S2) * (aMax - aMin) / (hist.size - 1)
-
-    return sat1, sat2, Sat1, Sat2
-
-
-def simulate_hst_vol_header(fname, entry=None, return_dict=False):
-    with HDF5File(fname, "r") as fid:
-        try:
-            histogram_path = entry + "/histogram/results/data"
-            histogram_config_path = entry + "/histogram/configuration"
-            Nz, Ny, Nx = fid[histogram_config_path]["volume_shape"][()]
-            vol_header_content = {
-                "NUM_X": Nx,
-                "NUM_Y": Ny,
-                "NUM_Z": Nz,
-                "BYTEORDER": "LOWBYTEFIRST",
-            }
-            hist = fid[histogram_path][()]
-        except KeyError as err:
-            print("Could not load histogram from %s: %s" % (fname, err))
-            return {} if return_dict else ""
-    bins = hist[1]
-    hist = hist[0]
-    vmin = bins[0]
-    vmax = bins[-1] + (bins[-1] - bins[-2])
-    s1, s2, S1, S2 = get_hst_saturations(hist, bins, Nx * Ny * Nz)
-    vmin = bins[0]
-    vmax = bins[-1] + (bins[-1] - bins[-2])
-    vol_header_content.update(
-        {
-            "ValMin": vmin,
-            "ValMax": vmax,
-            "s1": s1,
-            "s2": s2,
-            "S1": S1,
-            "S2": S2,
-        }
-    )
-    if return_dict:
-        return vol_header_content
-    res = ""
-    for k, v in vol_header_content.items():
-        res = res + "%s =  %s\n" % (k, v)
-    return res
-
-
-def format_as_info(d):
-    res = ""
-    for k, v in d.items():
-        k_s = str("%s=" % k)
-        sep = " " * (24 - len(k_s))
-        res = res + k_s + sep + str("%s\n" % v)
-    return res
-
-
-def generate_merged_info_file_content(
-    hist_fname=None, hist_entry=None, bliss_fname=None, bliss_entry=None, first_edf_proj=None, info_file=None
-):
-    # EDF Header
-    if first_edf_proj is None:
-        edf_header = simulate_edf_header(bliss_fname, bliss_entry, return_dict=True)
-    else:
-        edf = EdfImage()
-        edf.open(first_edf_proj)
-        edf_header = edf.getHeader()
-    # .info File
-    if info_file is None:
-        info_file_content = simulate_info_file(bliss_fname, bliss_entry, return_dict=True)
-        info_file_content = format_as_info(info_file_content)
-    else:
-        with open(info_file, "r") as f:
-            info_file_content = f.read()
-    # .vol File
-    vol_file_content = simulate_hst_vol_header(hist_fname, entry=hist_entry, return_dict=True)
-    #
-    res = format_as_info(edf_header)
-    res += info_file_content
-    res += format_as_info(vol_file_content)
-    return res
-
-
-def str_or_none(s):
-    if len(s.strip()) == 0:
-        return None
-    return s
-
-
-def generate_merged_info_file():
-    args = parse_params_values(GenerateInfoConfig, parser_description="Generate a .info file")
-
-    hist_fname = str_or_none(args["hist_file"])
-    hist_entry = str_or_none(args["hist_entry"])
-    bliss_fname = str_or_none(args["bliss_file"])
-    bliss_entry = str_or_none(args["bliss_entry"])
-    first_edf_proj = str_or_none(args["edf_proj"])
-    info_file = str_or_none(args["info_file"])
-    if hist_fname is not None and hist_entry is None:
-        hist_entry = get_first_hdf5_entry(hist_fname)
-    if bliss_fname is not None and bliss_entry is None:
-        bliss_entry = get_first_hdf5_entry(bliss_fname)
-
-    if not ((bliss_fname is None) ^ (info_file is None)):
-        print("Error: please provide either --bliss_file or --info_file")
-        exit(1)
-
-    if info_file is not None and first_edf_proj is None:
-        print("Error: please provide also --edf_proj when using the EDF format")
-        exit(1)
-
-    content = generate_merged_info_file_content(
-        hist_fname=hist_fname,
-        hist_entry=hist_entry,
-        bliss_fname=bliss_fname,
-        bliss_entry=bliss_entry,
-        first_edf_proj=first_edf_proj,
-        info_file=info_file,
-    )
-    with open(args["output"], "w") as f:
-        f.write(content)
-    return 0

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/histogram.py

@@ -1,197 +0,0 @@
-from os import path
-import posixpath
-from silx.io.url import DataUrl
-from silx.io.dictdump import h5todict
-from ..utils import check_supported
-from ..io.utils import get_first_hdf5_entry, get_h5_value
-from ..io.writer import NXProcessWriter
-from ..processing.histogram import PartialHistogram, VolumeHistogram, hist_as_2Darray
-from ..processing.histogram_cuda import CudaVolumeHistogram
-from ..resources.logger import Logger, LoggerOrPrint
-from .utils import parse_params_values
-from .cli_configs import HistogramConfig
-
-
-class VolumesHistogram:
-    """
-    A class for extracting or computing histograms of one or several volumes.
-    """
-
-    available_backends = {
-        "numpy": VolumeHistogram,
-        "cuda": CudaVolumeHistogram,
-    }
-
-    def __init__(
-        self, fnames, output_file, chunk_size_slices=100, chunk_size_GB=None, nbins=1e6, logger=None, backend="cuda"
-    ):
-        """
-        Initialize a VolumesHistogram object.
-
-        Parameters
-        -----------
-        fnames: list of str
-            List of paths to HDF5 files.
-            To specify an entry for each file name, use the "?" separator:
-            /path/to/file.h5?entry0001
-        output_file: str
-            Path to the output file
-        write_histogram_if_computed: bool, optional
-            Whether to write histograms that are computed to a file.
-            Some volumes might be missing their histogram. In this case, the histogram
-            is computed, and the result is written to a dedicated file in the same
-            directory as 'output_file'.
-            Default is True.
-        """
-        self._get_files_and_entries(fnames)
-        self.chunk_size_slices = chunk_size_slices
-        self.chunk_size_GB = chunk_size_GB
-        self.nbins = nbins
-        self.logger = LoggerOrPrint(logger)
-        self.output_file = output_file
-        self._get_histogrammer_backend(backend)
-
-    def _get_files_and_entries(self, fnames):
-        res_fnames = []
-        res_entries = []
-        for fname in fnames:
-            if "?" not in fname:
-                entry = None
-            else:
-                fname, entry = fname.split("?")
-                if entry == "":
-                    entry = None
-            res_fnames.append(fname)
-            res_entries.append(entry)
-        self.fnames = res_fnames
-        self.entries = res_entries
-
-    def _get_histogrammer_backend(self, backend):
-        check_supported(backend, self.available_backends.keys(), "histogram backend")
-        self.VolumeHistogramClass = self.available_backends[backend]
-
-    def _get_config_onevolume(self, fname, entry, data_shape):
-        return {
-            "chunk_size_slices": self.chunk_size_slices,
-            "chunk_size_GB": self.chunk_size_GB,
-            "bins": self.nbins,
-            "filename": fname,
-            "entry": entry,
-            "volume_shape": data_shape,
-        }
-
-    def _get_config(self):
-        conf = self._get_config_onevolume("", "", None)
-        conf.pop("filename")
-        conf.pop("entry")
-        conf["filenames"] = self.fnames
-        conf["entries"] = [entry if entry is not None else "None" for entry in self.entries]
-        return conf
-
-    def _write_histogram_onevolume(self, fname, entry, histogram, data_shape):
-        output_file = (
-            path.join(path.dirname(self.output_file), path.splitext(path.basename(fname))[0])
-            + "_histogram"
-            + path.splitext(fname)[1]
-        )
-        self.logger.info("Writing histogram of %s into %s" % (fname, output_file))
-        writer = NXProcessWriter(output_file, entry, filemode="w", overwrite=True)
-        writer.write(
-            hist_as_2Darray(histogram), "histogram", config=self._get_config_onevolume(fname, entry, data_shape)
-        )
-
-    def get_histogram_single_volume(self, fname, entry, write_histogram_if_computed=True, return_config=False):
-        entry = entry or get_first_hdf5_entry(fname)
-        hist_path = posixpath.join(entry, "histogram", "results", "data")
-        hist_cfg_path = posixpath.join(entry, "histogram", "configuration")
-        rec_path = posixpath.join(entry, "reconstruction", "results", "data")
-        rec_url = DataUrl(file_path=fname, data_path=rec_path)
-        hist = get_h5_value(fname, hist_path)
-        config = None
-        if hist is None:
-            self.logger.info("No histogram found in %s, computing it" % fname)
-            vol_histogrammer = self.VolumeHistogramClass(
-                rec_url,
-                chunk_size_slices=self.chunk_size_slices,
-                chunk_size_GB=self.chunk_size_GB,
-                nbins=self.nbins,
-                logger=self.logger,
-            )
-            hist = vol_histogrammer.compute_volume_histogram()
-            if write_histogram_if_computed:
-                self._write_histogram_onevolume(fname, entry, hist, vol_histogrammer.data_shape)
-            else:
-                if return_config:
-                    raise ValueError(
-                        "return_config must be set to True to get configuration for non-existing histograms"
-                    )
-            hist = hist_as_2Darray(hist)
-        config = h5todict(path.splitext(fname)[0] + "_histogram" + path.splitext(fname)[1], path=hist_cfg_path)
-        if return_config:
-            return hist, config
-        else:
-            return hist
-
-    def get_histogram(self, return_config=False):
-        histograms = []
-        configs = []
-        for fname, entry in zip(self.fnames, self.entries):
-            self.logger.info("Getting histogram for %s" % fname)
-            hist, conf = self.get_histogram_single_volume(fname, entry, return_config=True)
-            histograms.append(hist)
-            configs.append(conf)
-        self.logger.info("Merging histograms")
-        histogrammer = PartialHistogram(method="fixed_bins_number", num_bins=self.nbins)
-        hist = histogrammer.merge_histograms(histograms, dont_truncate_bins=True)
-        if return_config:
-            return hist, configs
-        else:
-            return hist
-
-    def merge_histograms_configurations(self, configs):
-        if configs is None or len(configs) == 0:
-            return
-        res_config = {"volume_shape": list(configs[0]["volume_shape"])}
-        res_config["volume_shape"][0] = 0
-        for conf in configs:
-            nz, ny, nx = conf["volume_shape"]
-            res_config["volume_shape"][0] += nz
-        res_config["volume_shape"] = tuple(res_config["volume_shape"])
-        return res_config
-
-    def write_histogram(self, hist, config=None):
-        self.logger.info("Writing final histogram to %s" % (self.output_file))
-        config = config or {}
-        base_config = self._get_config()
-        base_config.pop("volume_shape")
-        config.update(base_config)
-        writer = NXProcessWriter(self.output_file, "entry0000", filemode="w", overwrite=True)
-        writer.write(hist_as_2Darray(hist), "histogram", config=config)
-
-
-def histogram_cli():
-    args = parse_params_values(HistogramConfig, parser_description="Extract/compute histogram of volume(s).")
-    logger = Logger("nabu_histogram", level=args["loglevel"], logfile="nabu_histogram.log")
-    output = args["output_file"].split("?")[0]
-    if path.exists(output):
-        logger.fatal("Output file %s already exists, not overwriting it" % output)
-        exit(1)
-    chunk_size_gb = float(args["chunk_size_GB"])
-    if chunk_size_gb <= 0:
-        chunk_size_gb = None
-    histogramer = VolumesHistogram(
-        args["h5_file"],
-        output,
-        chunk_size_slices=int(args["chunk_size_slices"]),
-        chunk_size_GB=chunk_size_gb,
-        nbins=int(args["bins"]),
-        logger=logger,
-    )
-    hist, configs = histogramer.get_histogram(return_config=True)
-    config = histogramer.merge_histograms_configurations(configs)
-    histogramer.write_histogram(hist, config=config)
-    return 0
-
-
-if __name__ == "__main__":
-    histogram_cli()

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/multicor.py

@@ -1,90 +0,0 @@
-from os import remove
-import numpy as np
-from .. import version
-from .reconstruct import get_reconstructor
-from .cli_configs import MultiCorConfig
-from .utils import parse_params_values
-from ..utils import view_as_images_stack
-
-
-def get_user_cors(cors):
-    """
-    From a user-provided str describing the centers of rotation, build a list.
-    """
-    cors = cors.strip("[()]")
-    cors = cors.split(",")
-    cors = [c.strip() for c in cors]
-    cors_list = []
-    for c in cors:
-        if ":" in c:
-            if c.count(":") != 2:
-                raise ValueError("Malformed range format for '%s': expected format start:stop:step" % c)
-            start, stop, step = c.split(":")
-            c_list = np.arange(float(start), float(stop), float(step)).tolist()
-        else:
-            c_list = [float(c)]
-        cors_list.extend(c_list)
-    return cors_list
-
-
-def main():
-    args = parse_params_values(
-        MultiCorConfig,
-        parser_description=f"Perform a tomographic reconstruction of a single slice using multiple centers of rotation",
-        program_version="nabu " + version,
-    )
-
-    reconstructor = get_reconstructor(
-        args,
-        # Put a dummy CoR to avoid crash in both full-FoV and extended-FoV.
-        # It will be overwritten later by the user-defined CoRs
-        overwrite_options={"reconstruction/rotation_axis_position": 10.0},
-    )
-
-    if reconstructor.delta_z > 1:
-        raise ValueError("Only slice reconstruction can be used (have delta_z = %d)" % reconstructor.delta_z)
-
-    reconstructor.reconstruct()  # warm-up, spawn pipeline
-
-    pipeline = reconstructor.pipeline
-    file_prefix = pipeline.processing_options["save"]["file_prefix"]
-    #####
-    # Remove the first reconstructed file (not used here)
-    last_file = list(pipeline.writer.writer.browse_data_files())[-1]
-    try:
-        remove(last_file)
-    except:
-        pass
-    ######
-
-    cors = get_user_cors(args["cor"])
-
-    all_recs = []
-
-    for cor in cors:
-        # Re-configure with new CoR
-        pipeline.processing_options["reconstruction"]["rotation_axis_position"] = cor
-        pipeline.processing_options["save"]["file_prefix"] = file_prefix + "_%.03f" % cor
-        pipeline.reconstruction.reset_rot_center(cor)
-        pipeline._init_writer(create_subfolder=False, single_output_file_initialized=False)
-
-        # Get sinogram into contiguous array
-        # TODO Can't do memcpy2D ?! It used to work in cuda 11.
-        # For now: transfer to host... not optimal
-        sino = pipeline._d_radios[:, pipeline._d_radios.shape[1] // 2, :].get()  # pylint: disable=E1136
-
-        # Run reconstruction
-        rec = pipeline.reconstruction.fbp(sino)
-        # if return_all_recs:
-        # all_recs.append(rec)
-        rec_3D = view_as_images_stack(rec)  # writer wants 3D data
-
-        # Write
-        pipeline.writer.write_data(rec_3D)
-        reconstructor.logger.info("Wrote %s" % pipeline.writer.fname)
-
-    return 0
-
-
-if __name__ == "__main__":
-    main()

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/nx_z_splitter.py

@@ -1,125 +0,0 @@
-import warnings
-from shutil import copy as copy_file
-from os import path
-from h5py import VirtualSource, VirtualLayout
-from tomoscan.io import HDF5File
-from ..resources.logger import Logger, LoggerOrPrint
-from ..io.utils import get_first_hdf5_entry
-from .cli_configs import ZSplitConfig
-from .utils import parse_params_values
-
-warnings.warn(
-    "This command-line utility is intended as a temporary solution. Please do not rely too much on it.", Warning
-)
-
-
-def _get_z_translations(fname, entry):
-    z_path = path.join(entry, "sample", "z_translation")
-    with HDF5File(fname, "r") as fid:
-        z_transl = fid[z_path][:]
-    return z_transl
-
-
-class NXZSplitter:
-    def __init__(self, fname, output_dir, n_stages=None, entry=None, logger=None, use_virtual_dataset=False):
-        self.fname = fname
-        self._ext = path.splitext(fname)[-1]
-        self.output_dir = output_dir
-        self.n_stages = n_stages
-        if entry is None:
-            entry = get_first_hdf5_entry(fname)
-        self.entry = entry
-        self.logger = LoggerOrPrint(logger)
-        self.use_virtual_dataset = use_virtual_dataset
-
-    def _patch_nx_file(self, fname, mask):
-        orig_fname = self.fname
-        detector_path = path.join(self.entry, "instrument", "detector")
-        sample_path = path.join(self.entry, "sample")
-        with HDF5File(fname, "a") as fid:
-
-            def patch_nx_entry(name):
-                newval = fid[name][mask]
-                del fid[name]
-                fid[name] = newval
-
-            detector_entries = [
-                path.join(detector_path, what) for what in ["count_time", "image_key", "image_key_control"]
-            ]
-            sample_entries = [
-                path.join(sample_path, what)
-                for what in ["rotation_angle", "x_translation", "y_translation", "z_translation"]
-            ]
-            for what in detector_entries + sample_entries:
-                self.logger.debug("Patching %s" % what)
-                patch_nx_entry(what)
-            # Patch "data" using a virtual dataset
-            self.logger.debug("Patching data")
-            data_path = path.join(detector_path, "data")
-            if self.use_virtual_dataset:
-                data_shape = fid[data_path].shape
-                data_dtype = fid[data_path].dtype
-                new_data_shape = (int(mask.sum()),) + data_shape[1:]
-                vlayout = VirtualLayout(shape=new_data_shape, dtype=data_dtype)
-                vsource = VirtualSource(orig_fname, name=data_path, shape=data_shape, dtype=data_dtype)
-                vlayout[:] = vsource[mask, :, :]
-                del fid[data_path]
-                fid[detector_path].create_virtual_dataset("data", vlayout)
-
-        if not (self.use_virtual_dataset):
-            data_path = path.join(self.entry, "instrument", "detector", "data")
-            with HDF5File(orig_fname, "r") as fid:
-                data_arr = fid[data_path][mask, :, :]  # Actually load data. Heavy !
-            with HDF5File(fname, "a") as fid:
-                del fid[data_path]
-                fid[data_path] = data_arr
-
-    def z_split(self):
-        """
-        Split a HDF5-NX file according to different z_translation.
-        """
-        z_transl = _get_z_translations(self.fname, self.entry)
-        different_z = set(z_transl)
-        n_z = len(different_z)
-        self.logger.info("Detected %d different z values: %s" % (n_z, str(different_z)))
-        if n_z <= 1:
-            raise ValueError("Detected only %d z-value. Stopping." % n_z)
-        if self.n_stages is not None and self.n_stages != n_z:
-            raise ValueError("Expected %d different stages, but I detected %d" % (self.n_stages, n_z))
-        masks = [(z_transl == z) for z in different_z]
-        for i_z, mask in enumerate(masks):
-            fname_curr_z = path.join(
-                self.output_dir, path.splitext(path.basename(self.fname))[0] + str("_%06d" % i_z) + self._ext
-            )
-            self.logger.info("Creating %s" % fname_curr_z)
-            copy_file(self.fname, fname_curr_z)
-            self._patch_nx_file(fname_curr_z, mask)
-
-
-def zsplit():
-    # Parse arguments
-    args = parse_params_values(
-        ZSplitConfig, parser_description="Split a HDF5-Nexus file according to z translation (z-series)"
-    )
-    # Sanitize arguments
-    fname = args["input_file"]
-    output_dir = args["output_directory"]
-    loglevel = args["loglevel"].upper()
-    entry = args["entry"]
-    if len(entry) == 0:
-        entry = None
-    n_stages = args["n_stages"]
-    if n_stages < 0:
-        n_stages = None
-    use_virtual_dataset = bool(args["use_virtual_dataset"])
-    # Instantiate and execute
-    logger = Logger("NX_z-splitter", level=loglevel, logfile="nxzsplit.log")
-    nx_splitter = NXZSplitter(
-        fname, output_dir, n_stages=n_stages, entry=entry, logger=logger, use_virtual_dataset=use_virtual_dataset
-    )
-    nx_splitter.z_split()
-    return 0
-
-
-if __name__ == "__main__":
-    zsplit()