nabu 2024.1.0rc3__py3-none-any.whl → 2024.1.1__py3-none-any.whl

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

@@ -0,0 +1,261 @@
+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/nabu/app/histogram.py

@@ -0,0 +1,197 @@
+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/nabu/app/multicor.py

@@ -0,0 +1,90 @@
+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/nabu/app/nx_z_splitter.py

@@ -0,0 +1,125 @@
+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()