ChessAnalysisPipeline 0.0.13__py3-none-any.whl → 0.0.14__py3-none-any.whl

CHAP/utils/fit.py

@@ -862,9 +862,13 @@ class Fit:
         # Third party modules
         from asteval import Interpreter
 
+        # Local modules
+        from CHAP.utils.general import is_num_pair
+
         if centers_range is None:
             centers_range = (self._x[0], self._x[-1])
-        elif not is_index_range(centers_range, ge=self._x[0], le=self._x[-1]):
+        elif (not is_num_pair(centers_range) or len(centers_range) != 2
+                or centers_range[0] >= centers_range[1]):
             raise ValueError(
                 f'Invalid parameter centers_range ({centers_range})')
         if self._model is not None:
@@ -1021,9 +1025,8 @@ class Fit:
                                         {'name': par_name, 'min': min_value})
                                 elif len(index) == 1:
                                     parameter = parameters[index[0]]
-                                    _min = parameter.get('min', None)
-                                    if _min is None or _min < min_value:
-                                        parameter['min'] = min_value
+                                    _min = parameter.get('min', min_value)
+                                    parameter['min'] = max(_min, min_value)
                                 else:
                                     raise ValueError(
                                         'Invalid parameters value in '
@@ -1045,14 +1048,47 @@ class Fit:
                                         {'name': par_name, 'min': min_value})
                                 elif len(index) == 1:
                                     parameter = parameters[index[0]]
-                                    _min = parameter.get('min', None)
-                                    if _min is None or _min < min_value:
-                                        parameter['min'] = min_value
+                                    _min = parameter.get('min', min_value)
+                                    parameter['min'] = max(_min, min_value)
                                 else:
                                     raise ValueError(
                                         'Invalid parameters value in '
                                         f'background model {name} '
                                         f'({parameters})')
+                    if name == 'gaussian':
+                        if parameters is None:
+                            parameters = {
+                                'name': 'center',
+                                'value': 0.5 * (
+                                    centers_range[0] + centers_range[1]),
+                                'min': centers_range[0],
+                                'min': centers_range[1],
+                            }
+                        else:
+                            index = [i for i, par in enumerate(parameters)
+                                     if par['name'] == 'center']
+                            if not len(index):
+                                parameters.append({
+                                    'name': 'center',
+                                    'value': 0.5 * (
+                                        centers_range[0] + centers_range[1]),
+                                    'min': centers_range[0],
+                                    'max': centers_range[1],
+                                })
+                            elif len(index) == 1:
+                                parameter = parameters[index[0]]
+                                if 'value' not in parameter:
+                                    parameter['value'] = 0.5 * (
+                                        centers_range[0]+centers_range[1])
+                                _min = parameter.get('min', centers_range[0])
+                                parameter['min'] = max(_min, centers_range[0])
+                                _max = parameter.get('max', centers_range[1])
+                                parameter['max'] = min(_max, centers_range[1])
+                            else:
+                                raise ValueError(
+                                    'Invalid parameters value in '
+                                    f'background model {name} '
+                                    f'({parameters})')
                     self.add_model(
                         name, prefix=prefix, parameters=parameters,
                         **model)
@@ -1320,14 +1356,11 @@ class Fit:
             self._reset_par_at_boundary()
 
             # Perform the fit
-            fit_kws = None
-#            if 'Dfun' in kwargs:
-#                fit_kws = {'Dfun': kwargs.pop('Dfun')}
-#            self._result = self._model.fit(
-#                self._y_norm, self._parameters, x=self._x, fit_kws=fit_kws,
-#                **kwargs)
+            fit_kws = {}
             if self._param_constraint:
                 fit_kws = {'xtol': 1.e-5, 'ftol': 1.e-5, 'gtol': 1.e-5}
+#            if 'Dfun' in kwargs:
+#                fit_kws['Dfun'] = kwargs.pop('Dfun')
             if self._mask is None:
                 self._result = self._model.fit(
                     self._y_norm, self._parameters, x=self._x, fit_kws=fit_kws,
@@ -1866,6 +1899,7 @@ class Fit:
             self._result.residual *= self._norm[1]
 
     def _reset_par_at_boundary(self):
+        fraction = 0.02
         for name, par in self._parameters.items():
             if par.vary:
                 value = par.value
@@ -1874,26 +1908,26 @@ class Fit:
                 if np.isinf(_min):
                     if not np.isinf(_max):
                         if self._parameter_norms.get(name, False):
-                            upp = _max-0.1*self._y_range
+                            upp = _max - fraction*self._y_range
                         elif _max == 0.0:
-                            upp = _max-0.1
+                            upp = _max - fraction
                         else:
-                            upp = _max-0.1*abs(_max)
+                            upp = _max - fraction*abs(_max)
                         if value >= upp:
                             par.set(value=upp)
                 else:
                     if np.isinf(_max):
                         if self._parameter_norms.get(name, False):
-                            low = _min + 0.1*self._y_range
+                            low = _min + fraction*self._y_range
                         elif _min == 0.0:
-                            low = _min+0.1
+                            low = _min + fraction
                         else:
-                            low = _min + 0.1*abs(_min)
+                            low = _min + fraction*abs(_min)
                         if value <= low:
                             par.set(value=low)
                     else:
-                        low = 0.9*_min + 0.1*_max
-                        upp = 0.1*_min + 0.9*_max
+                        low = (1.0-fraction)*_min + fraction*_max
+                        upp = fraction*_min + (1.0-fraction)*_max
                         if value <= low:
                             par.set(value=low)
                         if value >= upp:
@@ -1917,6 +1951,7 @@ class FitMap(Fit):
         self._max_nfev = None
         self._memfolder = None
         self._new_parameters = None
+        self._num_func_eval = None
         self._out_of_bounds = None
         self._plot = False
         self._print_report = False
@@ -1932,6 +1967,7 @@ class FitMap(Fit):
         #     map dimensions
         if isinstance(ymap, (tuple, list, np.ndarray)):
             self._x = np.asarray(x)
+            ymap = np.asarray(ymap)
         elif HAVE_XARRAY and isinstance(ymap, xr.DataArray):
             if x is not None:
                 logger.warning('Ignoring superfluous input x ({x})')
@@ -2149,7 +2185,8 @@ class FitMap(Fit):
     @property
     def max_nfev(self):
         """
-        Return the maximum number of function evaluations for each fit.
+        Return if the maximum number of function evaluations is reached
+        for each fit.
         """
         return self._max_nfev
 
@@ -2158,7 +2195,7 @@ class FitMap(Fit):
         """
         Return the number of function evaluations for each best fit.
         """
-        logger.warning('Undefined property num_func_eval')
+        return self._num_func_eval
 
     @property
     def out_of_bounds(self):
@@ -2466,6 +2503,7 @@ class FitMap(Fit):
         if self._result is not None:
             self._out_of_bounds = None
             self._max_nfev = None
+            self._num_func_eval = None
             self._redchi = None
             self._success = None
             self._best_fit = None
@@ -2508,6 +2546,7 @@ class FitMap(Fit):
         if num_proc == 1:
             self._out_of_bounds_flat = np.zeros(self._map_dim, dtype=bool)
             self._max_nfev_flat = np.zeros(self._map_dim, dtype=bool)
+            self._num_func_eval_flat = np.zeros(self._map_dim, dtype=np.intc)
             self._redchi_flat = np.zeros(self._map_dim, dtype=np.float64)
             self._success_flat = np.zeros(self._map_dim, dtype=bool)
             self._best_fit_flat = np.zeros(
@@ -2537,6 +2576,11 @@ class FitMap(Fit):
             filename_memmap = path.join(self._memfolder, 'max_nfev_memmap')
             self._max_nfev_flat = np.memmap(
                 filename_memmap, dtype=bool, shape=(self._map_dim), mode='w+')
+            filename_memmap = path.join(
+                self._memfolder, 'num_func_eval_memmap')
+            self._num_func_eval_flat = np.memmap(
+                filename_memmap, dtype=np.intc, shape=(self._map_dim),
+                mode='w+')
             filename_memmap = path.join(self._memfolder, 'redchi_memmap')
             self._redchi_flat = np.memmap(
                 filename_memmap, dtype=np.float64, shape=(self._map_dim),
@@ -2598,29 +2642,32 @@ class FitMap(Fit):
             except AttributeError:
                 pass
 
-        if num_proc == 1:
-            # Perform the remaining fits serially
-            for n in range(1, self._map_dim):
-                self._fit(n, current_best_values, **kwargs)
-        else:
-            # Perform the remaining fits in parallel
-            num_fit = self._map_dim-1
-            if num_proc > num_fit:
-                logger.warning(
-                    f'The requested number of processors ({num_proc}) exceeds '
-                    f'the number of fits, num_proc reduced to {num_fit}')
-                num_proc = num_fit
-                num_fit_per_proc = 1
+        if self._map_dim > 1:
+            if num_proc == 1:
+                # Perform the remaining fits serially
+                for n in range(1, self._map_dim):
+                    self._fit(n, current_best_values, **kwargs)
             else:
-                num_fit_per_proc = round((num_fit)/num_proc)
-                if num_proc*num_fit_per_proc < num_fit:
-                    num_fit_per_proc += 1
-            num_fit_batch = min(num_fit_per_proc, 40)
-            with Parallel(n_jobs=num_proc) as parallel:
-                parallel(
-                    delayed(self._fit_parallel)
-                        (current_best_values, num_fit_batch, n_start, **kwargs)
-                    for n_start in range(1, self._map_dim, num_fit_batch))
+                # Perform the remaining fits in parallel
+                num_fit = self._map_dim-1
+                if num_proc > num_fit:
+                    logger.warning(
+                        f'The requested number of processors ({num_proc}) '
+                        'exceeds the number of fits, num_proc reduced to '
+                        f'{num_fit}')
+                    num_proc = num_fit
+                    num_fit_per_proc = 1
+                else:
+                    num_fit_per_proc = round((num_fit)/num_proc)
+                    if num_proc*num_fit_per_proc < num_fit:
+                        num_fit_per_proc += 1
+                num_fit_batch = min(num_fit_per_proc, 40)
+                with Parallel(n_jobs=num_proc) as parallel:
+                    parallel(
+                        delayed(self._fit_parallel)
+                            (current_best_values, num_fit_batch, n_start,
+                             **kwargs)
+                        for n_start in range(1, self._map_dim, num_fit_batch))
 
         # Renormalize the initial parameters for external use
         if self._norm is not None and self._normalized:
@@ -2649,6 +2696,8 @@ class FitMap(Fit):
             self._out_of_bounds_flat, self._map_shape))
         self._max_nfev = np.copy(np.reshape(
             self._max_nfev_flat, self._map_shape))
+        self._num_func_eval = np.copy(np.reshape(
+            self._num_func_eval_flat, self._map_shape))
         self._redchi = np.copy(np.reshape(self._redchi_flat, self._map_shape))
         self._success = np.copy(np.reshape(
             self._success_flat, self._map_shape))
@@ -2662,6 +2711,8 @@ class FitMap(Fit):
             self._out_of_bounds = np.transpose(
                 self._out_of_bounds, self._inv_transpose)
             self._max_nfev = np.transpose(self._max_nfev, self._inv_transpose)
+            self._num_func_eval = np.transpose(
+                self._num_func_eval, self._inv_transpose)
             self._redchi = np.transpose(self._redchi, self._inv_transpose)
             self._success = np.transpose(self._success, self._inv_transpose)
             self._best_fit = np.transpose(
@@ -2673,6 +2724,7 @@ class FitMap(Fit):
                 self._best_errors, [0] + [i+1 for i in self._inv_transpose])
         del self._out_of_bounds_flat
         del self._max_nfev_flat
+        del self._num_func_eval_flat
         del self._redchi_flat
         del self._success_flat
         del self._best_fit_flat
@@ -2761,6 +2813,7 @@ class FitMap(Fit):
 
         if result.redchi >= self._redchi_cutoff:
             result.success = False
+        self._num_func_eval_flat[n] = result.nfev
         if result.nfev == result.max_nfev:
             if result.redchi < self._redchi_cutoff:
                 result.success = True

CHAP/utils/general.py

@@ -26,8 +26,6 @@ from sys import float_info
 import numpy as np
 try:
     import matplotlib.pyplot as plt
-    from matplotlib.widgets import AxesWidget, RadioButtons
-    from matplotlib import cbook
 except ImportError:
     pass
 
@@ -655,8 +653,8 @@ def _input_int_or_num(
 
 
 def input_int_list(
-        s=None, ge=None, le=None, split_on_dash=True, remove_duplicates=True,
-        sort=True, raise_error=False, log=True):
+        s=None, num_max=None, ge=None, le=None, split_on_dash=True,
+        remove_duplicates=True, sort=True, raise_error=False, log=True):
     """
     Prompt the user to input a list of interger and split the entered
     string on any combination of commas, whitespaces, or dashes (when
@@ -669,13 +667,13 @@ def input_int_list(
     return None upon an illegal input
     """
     return _input_int_or_num_list(
-        'int', s, ge, le, split_on_dash, remove_duplicates, sort, raise_error,
-        log)
+        'int', s, num_max, ge, le, split_on_dash, remove_duplicates, sort,
+        raise_error, log)
 
 
 def input_num_list(
-        s=None, ge=None, le=None, remove_duplicates=True, sort=True,
-        raise_error=False, log=True):
+        s=None, num_max=None, ge=None, le=None, remove_duplicates=True,
+        sort=True, raise_error=False, log=True):
     """
     Prompt the user to input a list of numbers and split the entered
     string on any combination of commas or whitespaces.
@@ -687,11 +685,12 @@ def input_num_list(
     return None upon an illegal input
     """
     return _input_int_or_num_list(
-        'num', s, ge, le, False, remove_duplicates, sort, raise_error, log)
+        'num', s, num_max, ge, le, False, remove_duplicates, sort, raise_error,
+        log)
 
 
 def _input_int_or_num_list(
-        type_str, s=None, ge=None, le=None, split_on_dash=True,
+        type_str, s=None, num_max=None, ge=None, le=None, split_on_dash=True,
         remove_duplicates=True, sort=True, raise_error=False, log=True):
     # RV do we want a limit on max dimension?
     if type_str == 'int':
@@ -707,6 +706,9 @@ def _input_int_or_num_list(
     else:
         illegal_value(type_str, 'type_str', '_input_int_or_num_list')
         return None
+    if (num_max is not None
+            and not is_int(num_max, gt=0, raise_error=raise_error, log=log)):
+        return None
     v_range = f'{range_string_ge_gt_le_lt(ge=ge, le=le)}'
     if v_range:
         v_range = f' (each value in {v_range})'
@@ -721,14 +723,17 @@ def _input_int_or_num_list(
     except:
         print('Unexpected error')
         raise
-    if (not isinstance(_list, list) or any(
-            not _is_int_or_num(v, type_str, ge=ge, le=le) for v in _list)):
+    if (not isinstance(_list, list)
+            or (num_max is not None and len(_list) > num_max)
+            or any(
+                not _is_int_or_num(v, type_str, ge=ge, le=le) for v in _list)):
+        num = '' if num_max is None else f'up to {num_max} '
         if split_on_dash:
-            print('Invalid input: enter a valid set of dash/comma/whitespace '
-                  'separated integers e.g. 1 3,5-8 , 12')
+            print(f'Invalid input: enter a valid set of {num}dash/comma/'
+                  'whitespace separated numbers e.g. 1 3,5-8 , 12')
         else:
-            print('Invalid input: enter a valid set of comma/whitespace '
-                  'separated integers e.g. 1 3,5 8 , 12')
+            print(f'Invalid input: enter a valid set of {num}comma/whitespace '
+                  'separated numbers e.g. 1 3,5 8 , 12')
         _list = _input_int_or_num_list(
             type_str, s, ge, le, split_on_dash, remove_duplicates, sort,
             raise_error, log)
@@ -1105,18 +1110,6 @@ def select_mask_1d(
                        for v in preselected_index_ranges)):
             raise ValueError('Invalid parameter preselected_index_ranges '
                              f'({preselected_index_ranges})')
-        if (min_num_index_ranges is not None
-                and len(preselected_index_ranges) < min_num_index_ranges):
-            raise ValueError(
-                'Invalid parameter preselected_index_ranges '
-                f'({preselected_index_ranges}), number of selected index '
-                f'ranges must be >= {min_num_index_ranges}')
-        if (max_num_index_ranges is not None
-                and len(preselected_index_ranges) > max_num_index_ranges):
-            raise ValueError(
-                'Invalid parameter preselected_index_ranges '
-                f'({preselected_index_ranges}), number of selected index '
-                f'ranges must be <= {max_num_index_ranges}')
 
     spans = []
     fig_title = []
@@ -1191,8 +1184,6 @@ def select_mask_1d(
         plt.subplots_adjust(bottom=0.0)
 
     selected_index_ranges = get_selected_index_ranges()
-    if not selected_index_ranges:
-        selected_index_ranges = None
 
     # Update the mask with the currently selected index ranges
     selected_mask = update_mask(len(x)*[False], selected_index_ranges)
@@ -1290,37 +1281,46 @@ def select_roi_2d(
             fig_title.pop()
         fig_title.append(plt.figtext(*title_pos, title, **title_props))
 
-    def change_error_text(error):
-        if error_texts:
-            error_texts[0].remove()
-            error_texts.pop()
-        error_texts.append(plt.figtext(*error_pos, error, **error_props))
+    def change_subfig_title(error):
+        if subfig_title:
+            subfig_title[0].remove()
+            subfig_title.pop()
+        subfig_title.append(plt.figtext(*error_pos, error, **error_props))
+
+    def clear_selection():
+        rects[0].set_visible(False)
+        rects.pop()
+        rects.append(
+            RectangleSelector(
+                ax, on_rect_select, props=rect_props,
+                useblit=True, interactive=interactive, drag_from_anywhere=True,
+                ignore_event_outside=False))
 
     def on_rect_select(eclick, erelease):
         """Callback function for the RectangleSelector widget."""
-        change_error_text(
-            f'Selected ROI: {tuple(int(v) for v in rects[0].extents)}')
+        if (not int(rects[0].extents[1]) - int(rects[0].extents[0]) 
+                or not int(rects[0].extents[3]) - int(rects[0].extents[2])):
+            clear_selection()
+            change_subfig_title(
+                f'Selected ROI too small, try again')
+        else:
+            change_subfig_title(
+                f'Selected ROI: {tuple(int(v) for v in rects[0].extents)}')
         plt.draw()
 
     def reset(event):
         """Callback function for the "Reset" button."""
-        if error_texts:
-            error_texts[0].remove()
-            error_texts.pop()
-        rects[0].set_visible(False)
-        rects.pop()
-        rects.append(
-            RectangleSelector(
-                ax, on_rect_select, props=rect_props, useblit=True,
-                interactive=interactive, drag_from_anywhere=True,
-                ignore_event_outside=False))
+        if subfig_title:
+            subfig_title[0].remove()
+            subfig_title.pop()
+        clear_selection()
         plt.draw()
 
     def confirm(event):
         """Callback function for the "Confirm" button."""
-        if error_texts:
-            error_texts[0].remove()
-            error_texts.pop()
+        if subfig_title:
+            subfig_title[0].remove()
+            subfig_title.pop()
         roi = tuple(int(v) for v in rects[0].extents)
         if roi[1]-roi[0] < 1 or roi[3]-roi[2] < 1:
             roi = None
@@ -1328,7 +1328,7 @@ def select_roi_2d(
         plt.close()
 
     fig_title = []
-    error_texts = []
+    subfig_title = []
 
     # Check inputs
     a = np.asarray(a)
@@ -1377,7 +1377,7 @@ def select_roi_2d(
 
         change_fig_title(title)
         if preselected_roi is not None:
-            change_error_text(
+            change_subfig_title(
                 f'Preselected ROI: {tuple(int(v) for v in preselected_roi)}')
         fig.subplots_adjust(bottom=0.2)
 
@@ -1436,7 +1436,7 @@ def select_image_indices(
     :param preselected_indices: Preselected image indices,
         defaults to `None`.
     :type preselected_indices: tuple(int), list(int), optional
-    :param axis_index_offset: Offset in axes index range and
+    :param axis_index_offset: Offset in axis index range and
         preselected indices, defaults to `0`.
     :type axis_index_offset: int, optional
     :param min_range: The minimal range spanned by the selected 
@@ -1535,7 +1535,7 @@ def select_image_indices(
         try:
             index = int(expression)
             if (index < axis_index_offset
-                    or index >= axis_index_offset+a.shape[axis]):
+                    or index > axis_index_offset+a.shape[axis]):
                 raise ValueError
         except ValueError:
             change_error_text(
@@ -1872,3 +1872,126 @@ def quick_plot(
         if save_fig:
             plt.savefig(path)
         plt.show(block=block)
+
+
+def nxcopy(
+        nxobject, exclude_nxpaths=None, nxpath_prefix=None,
+        nxpathabs_prefix=None, nxpath_copy_abspath=None):
+    """
+    Function that returns a copy of a nexus object, optionally exluding
+    certain child items.
+
+    :param nxobject: The input nexus object to "copy".
+    :type nxobject: nexusformat.nexus.NXobject
+    :param exlude_nxpaths: A list of relative paths to child nexus
+        objects that should be excluded from the returned "copy",
+        defaults to `[]`.
+    :type exclude_nxpaths: str, list[str], optional
+    :param nxpath_prefix: For use in recursive calls from inside this
+        function only.
+    :type nxpath_prefix: str
+    :param nxpathabs_prefix: For use in recursive calls from inside this
+        function only.
+    :type nxpathabs_prefix: str
+    :param nxpath_copy_abspath: For use in recursive calls from inside this
+        function only.
+    :type nxpath_copy_abspath: str
+    :return: Copy of the input `nxobject` with some children optionally
+        exluded.
+    :rtype: nexusformat.nexus.NXobject
+    """
+    # Third party modules
+    from nexusformat.nexus import (
+        NXentry,
+        NXfield,
+        NXgroup,
+        NXlink,
+        NXlinkgroup,
+        NXroot,
+    )
+
+
+    if isinstance(nxobject, NXlinkgroup):
+        # The top level nxobject is a linked group
+        # Create a group with the same name as the top level's target
+        nxobject_copy = nxobject[nxobject.nxtarget].__class__(
+            name=nxobject.nxname)
+    elif isinstance(nxobject, (NXlink, NXfield)):
+        # The top level nxobject is a (linked) field: return a copy
+        nxobject_copy = NXfield(
+            value=nxobject.nxdata, name=nxobject.nxname,
+            attrs=nxobject.attrs)
+        return nxobject_copy
+    else:
+        # Create a group with the same type/name as the nxobject
+        nxobject_copy = nxobject.__class__(name=nxobject.nxname)
+
+    # Copy attributes
+    if isinstance(nxobject, NXroot):
+        if 'default' in nxobject.attrs:
+            nxobject_copy.attrs['default'] = nxobject.default
+    else:
+        for k, v in nxobject.attrs.items():
+            nxobject_copy.attrs[k] = v
+
+    # Setup paths
+    if exclude_nxpaths is None:
+        exclude_nxpaths = []
+    elif isinstance(exclude_nxpaths, str):
+        exclude_nxpaths = [exclude_nxpaths]
+    for exclude_nxpath in exclude_nxpaths:
+        if exclude_nxpath[0] == '/':
+            raise ValueError(
+                f'Invalid parameter in exclude_nxpaths ({exclude_nxpaths}), '
+                'excluded paths should be relative')
+    if nxpath_prefix is None:
+        nxpath_prefix = ''
+    if nxpathabs_prefix is None:
+        if isinstance(nxobject, NXentry):
+            nxpathabs_prefix = nxobject.nxpath
+        else:
+            nxpathabs_prefix = nxobject.nxpath.removesuffix(nxobject.nxname)
+    if nxpath_copy_abspath is None:
+        nxpath_copy_abspath = ''
+
+    # Loop over all nxobject's children
+    for k, v in nxobject.items():
+        nxpath = os_path.join(nxpath_prefix, k)
+        nxpathabs = os_path.join(nxpathabs_prefix, nxpath)
+        if nxpath in exclude_nxpaths:
+            if 'default' in nxobject_copy.attrs and nxobject_copy.default == k:
+                nxobject_copy.attrs.pop('default')
+            continue
+        if isinstance(v, NXlinkgroup):
+            if nxpathabs == v.nxpath and not any(
+                    v.nxtarget.startswith(os_path.join(nxpathabs_prefix, p))
+                    for p in exclude_nxpaths):
+                nxobject_copy[k] = NXlink(v.nxtarget)
+            else:
+                nxobject_copy[k] = nxcopy(
+                    v, exclude_nxpaths=exclude_nxpaths,
+                    nxpath_prefix=nxpath, nxpathabs_prefix=nxpathabs_prefix,
+                    nxpath_copy_abspath=os_path.join(nxpath_copy_abspath, k))
+        elif isinstance(v, NXlink):
+            if nxpathabs == v.nxpath and not any(
+                    v.nxtarget.startswith(os_path.join(nxpathabs_prefix, p))
+                    for p in exclude_nxpaths):
+                nxobject_copy[k] = v
+            else:
+                nxobject_copy[k] = v.nxdata
+                for kk, vv in v.attrs.items():
+                    nxobject_copy[k].attrs[kk] = vv
+                nxobject_copy[k].attrs.pop('target', None)
+        elif isinstance(v, NXgroup):
+            nxobject_copy[k] = nxcopy(
+                v, exclude_nxpaths=exclude_nxpaths,
+                nxpath_prefix=nxpath, nxpathabs_prefix=nxpathabs_prefix,
+                nxpath_copy_abspath=os_path.join(nxpath_copy_abspath, k))
+        else:
+            nxobject_copy[k] = v.nxdata
+            for kk, vv in v.attrs.items():
+                nxobject_copy[k].attrs[kk] = vv
+            if nxpathabs != os_path.join(nxpath_copy_abspath, k):
+                nxobject_copy[k].attrs.pop('target', None)
+
+    return nxobject_copy