Change clone to copy and add private _init_copy method

gammapy/cube/new.py

@@ -215,7 +215,7 @@ def make_map_background_fov(acceptance_map, counts_map, exclusion_mask):
 
     norm_bkg = norm_factor * acceptance_map.data.T
 
-    return acceptance_map.clone(data=norm_bkg.T)
+    return acceptance_map.copy(data=norm_bkg.T)
 
 
 class MapMaker(object):

gammapy/detect/kernel.py

@@ -14,7 +14,7 @@
 ]
 
 
-# TODO: use `Map.clone` or `Map.copy` once available
+# TODO: use `Map.copy` or `Map.copy` once available
 # instead of the awkward way with `Map.from_geom` and adjusting map data after.
 class KernelBackgroundEstimator(object):
     """Estimate background and exclusion mask iteratively.
@@ -152,7 +152,7 @@ def _estimate_exclusion(self, counts, significance):
         mask = (significance.data < self.parameters['significance_threshold']) | np.isnan(significance.data)
         mask = binary_erosion(mask, structure, border_value=1)
 
-        return counts.clone(data=mask.astype('float'))
+        return counts.copy(data=mask.astype('float'))
 
     def _estimate_background(self, counts, exclusion):
         """

gammapy/detect/lima.py

@@ -55,10 +55,10 @@ def compute_lima_image(counts, background, kernel, exposure=None):
 
     # TODO: we should make coopies of the geom to make them independent objects
     images = {
-        'significance': counts.clone(data=significance_conv),
-        'counts': counts.clone(data=counts_conv),
-        'background': counts.clone(data=background_conv),
-        'excess': counts.clone(data=excess_conv),
+        'significance': counts.copy(data=significance_conv),
+        'counts': counts.copy(data=counts_conv),
+        'background': counts.copy(data=background_conv),
+        'excess': counts.copy(data=excess_conv),
     }
 
     # TODO: should we be doing this here?
@@ -113,11 +113,11 @@ def compute_lima_on_off_image(n_on, n_off, a_on, a_off, kernel, exposure=None):
     significance_conv = significance_on_off(n_on_conv, n_off.data, alpha_conv, method='lima')
 
     images = {
-        'significance': n_on.clone(data=significance_conv),
-        'n_on': n_on.clone(data=n_on_conv),
-        'background': n_on.clone(data=background_conv),
-        'excess': n_on.clone(data=excess_conv),
-        'alpha': n_on.clone(data=alpha_conv),
+        'significance': n_on.copy(data=significance_conv),
+        'n_on': n_on.copy(data=n_on_conv),
+        'background': n_on.copy(data=background_conv),
+        'excess': n_on.copy(data=excess_conv),
+        'alpha': n_on.copy(data=alpha_conv),
     }
 
     # TODO: should we be doing this here?
@@ -137,4 +137,4 @@ def _add_other_images(images, exposure, kernel, conv_opt):
     exposure_conv = convolve(exposure.data, kernel.array, **conv_opt)
     flux = images['excess'].data / exposure_conv
     # TODO: we should make coopies of the geom to make them independent objects
-    images['flux'] = images['excess'].clone(data=flux)
+    images['flux'] = images['excess'].copy(data=flux)

gammapy/maps/base.py

@@ -52,9 +52,22 @@ def __init__(self, geom, data, meta=None, unit=''):
             self._unit = Unit(unit).to_string()
 
         if meta is None:
-            self.meta = OrderedDict()
+            self._meta = OrderedDict()
         else:
-            self.meta = OrderedDict(meta)
+            self._meta = OrderedDict(meta)
+
+    def _init_copy(self, **kwargs):
+        """Init map instance by copying missing init arguments from self.
+        """
+        argnames = inspect.getargspec(self.__init__).args
+        argnames.remove('self')
+        argnames.remove('dtype')
+
+        for arg in argnames:
+            value = getattr(self, '_' + arg)
+            kwargs.setdefault(arg, copy.deepcopy(value))
+
+        return self.__class__(**kwargs)
 
     @property
     def data(self):
@@ -71,6 +84,11 @@ def unit(self):
         """Map unit (`~astropy.units.Unit`)"""
         return Unit(self._unit)
 
+    @property
+    def meta(self):
+        """Map meta (`~OrderedDict`)"""
+        return self._meta
+
     @data.setter
     def data(self, val):
         if val.shape != self.data.shape:
@@ -897,8 +915,8 @@ def set_by_idx(self, idx, vals):
         """
         pass
 
-    def clone(self, **kwargs):
-        """Clone map instance and overwrite given attributes.
+    def copy(self, **kwargs):
+        """Copy map instance and overwrite given attributes, except for geometry.
 
         Parameters
         ----------
@@ -907,26 +925,12 @@ def clone(self, **kwargs):
 
         Returns
         --------
-        clone : `Map`
-            Cloned Map.
+        copy : `Map`
+            Copied Map.
         """
-        init_args = inspect.getargspec(self.__init__).args
-        init_args.remove('self')
-        init_args.remove('dtype')
-
-        if 'geom' in kwargs and 'data' not in kwargs:
-            raise ValueError("Can't clone and overwrite geometry if the data is not overwritten too.")
-
-        for attr in init_args:
-            if attr not in kwargs:
-                value = getattr(self, attr)
-                if attr == 'data' and 'dtype' in kwargs:
-                    value = value.astype(kwargs['dtype'], copy=True)
-                else:
-                    value = copy.deepcopy(value)
-
-                kwargs[attr] = value
-        return self.__class__(**kwargs)
+        if 'geom' in kwargs:
+            raise ValueError("Can't copy and change geometry of the map.")
+        return self._init_copy(**kwargs)
 
 
     def __repr__(self):

gammapy/maps/geom.py

@@ -2,6 +2,7 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 import abc
 import copy
+import inspect
 import re
 from collections import OrderedDict
 import numpy as np
@@ -1219,9 +1220,7 @@ def slice_by_idx(self, slices):
                 axes.append(ax_sliced)
                 # in the case where isinstance(ax_slice, int) the axes is dropped
 
-        kwargs = self._copy_init_kwargs
-        kwargs['axes'] = axes
-        return self.__class__(**kwargs)
+        return self._init_copy(axes=axes)
 
     @abc.abstractmethod
     def to_image(self):
@@ -1418,3 +1417,15 @@ def get_axis_by_type(self, type):
             if axis.type == type:
                 return axis
         raise ValueError("Cannot find type {}".format(type))
+
+    def _init_copy(self, **kwargs):
+        """Init map instance by copying missing init arguments from self.
+        """
+        argnames = inspect.getargspec(self.__init__).args
+        argnames.remove('self')
+
+        for arg in argnames:
+            value = getattr(self, '_' + arg)
+            kwargs.setdefault(arg, copy.deepcopy(value))
+
+        return self.__class__(**kwargs)

gammapy/maps/hpx.py

@@ -586,6 +586,7 @@ def __init__(self, nside, nest=True, coordsys='CEL', region=None,
         self._coordsys = coordsys
         self._maxpix = 12 * self._nside * self._nside
         self._maxpix = self._maxpix * np.ones(self._shape, dtype=int)
+        self._sparse = sparse
 
         self._ipix = None
         self._rmap = None

gammapy/maps/hpxnd.py

@@ -207,7 +207,7 @@ def sum_over_axes(self):
         geom = self.geom.to_image()
         axis = tuple(range(self.data.ndim - 1))
         data = np.nansum(self.data, axis=axis)
-        return self.clone(geom=geom, data=data)
+        return self._init_copy(geom=geom, data=data)
 
     def _reproject_wcs(self, geom, order=1, mode='interp'):
 
@@ -250,7 +250,7 @@ def _reproject_hpx(self, geom, order=1, mode='interp'):
 
     def pad(self, pad_width, mode='constant', cval=0.0, order=1):
         geom = self.geom.pad(pad_width)
-        map_out = self.clone(geom=geom, data=None)
+        map_out = self._init_copy(geom=geom, data=None)
         map_out.coadd(self)
         coords = geom.get_coord(flat=True)
         m = self.geom.contains(coords)
@@ -271,7 +271,7 @@ def pad(self, pad_width, mode='constant', cval=0.0, order=1):
 
     def crop(self, crop_width):
         geom = self.geom.crop(crop_width)
-        map_out = self.clone(geom=geom, data=None)
+        map_out = self._init_copy(geom=geom, data=None)
         map_out.coadd(self)
         return map_out
 
@@ -283,16 +283,14 @@ def upsample(self, factor, preserve_counts=True):
         if preserve_counts:
             data /= factor ** 2
 
-        return self.clone(geom=geom, data=data)
+        return self._init_copy(geom=geom, data=data)
 
     def downsample(self, factor, preserve_counts=True):
         geom = self.geom.downsample(factor)
         coords = self.geom.get_coord()
         vals = self.get_by_coord(coords)
 
-        # if we provide data=None the data is not cloned by rather created from
-        # the altered geometry
-        map_out = self.clone(geom=geom, data=None)
+        map_out = self._init_copy(geom=geom, data=None)
         map_out.fill_by_coord(coords, vals)
 
         if not preserve_counts:
@@ -452,7 +450,7 @@ def _make_cols(self, header, conv):
     def to_swapped(self):
         import healpy as hp
         hpx_out = self.geom.to_swapped()
-        map_out = self.clone(geom=hpx_out, data=None)
+        map_out = self._init_copy(geom=hpx_out, data=None)
         idx = self.geom.get_idx(flat=True)
         vals = self.get_by_idx(idx)
         if self.geom.nside.size > 1:
@@ -475,7 +473,7 @@ def to_ud_graded(self, nside, preserve_counts=False):
         import healpy as hp
         order = nside_to_order(nside)
         new_hpx = self.geom.to_ud_graded(order)
-        map_out = self.clone(geom=new_hpx, data=None)
+        map_out = self._init_copy(geom=new_hpx, data=None)
 
         if np.all(order <= self.geom.order):
             # Downsample

gammapy/maps/tests/test_base.py

@@ -45,24 +45,24 @@ def test_map_create(binsz, width, map_type, skydir, axes, unit):
 
 @pytest.mark.parametrize(('binsz', 'width', 'map_type', 'skydir', 'axes', 'unit'),
                          mapbase_args_with_axes)
-def test_map_clone(binsz, width, map_type, skydir, axes, unit):
+def test_map_copy(binsz, width, map_type, skydir, axes, unit):
     m = Map.create(binsz=binsz, width=width, map_type=map_type,
                    skydir=skydir, axes=axes, unit=unit)
 
-    m_clone = m.clone()
-    assert repr(m) == repr(m_clone)
+    m_copy = m.copy()
+    assert repr(m) == repr(m_copy)
 
-    m_clone = m.clone(unit='cm-2 s-1')
-    assert m_clone.unit == 'cm-2 s-1'
+    m_copy = m.copy(unit='cm-2 s-1')
+    assert m_copy.unit == 'cm-2 s-1'
+    assert m_copy.unit is not m.unit
 
-    m_clone = m.clone(meta=OrderedDict([('is_clone', True)]))
-    assert m_clone.meta['is_clone']
+    m_copy = m.copy(meta=OrderedDict([('is_copy', True)]))
+    assert m_copy.meta['is_copy']
+    assert m_copy.meta is not m.meta
 
-    m_clone = m.clone(dtype=np.int)
-    assert m_clone.data.dtype == np.int
-
-    m_clone = m.clone(data=42 * np.ones(m.data.shape))
-    assert m_clone.data[(0,) * m_clone.data.ndim] == 42
+    m_copy = m.copy(data=42 * np.ones(m.data.shape))
+    assert m_copy.data[(0,) * m_copy.data.ndim] == 42
+    assert m_copy.data is not m.data
 
 
 def test_map_from_geom():

gammapy/maps/wcs.py

@@ -106,14 +106,6 @@ def __init__(self, wcs, npix, cdelt=None, crpix=None, axes=None, conv='gadf'):
                                                   self._center_pix[1],
                                                   self.wcs)
 
-    @property
-    def _copy_init_kwargs(self):
-        """Get kwargs to init an instance with the same parameters."""
-        kwargs = {}
-        for arg in ['wcs', 'npix', 'cdelt', 'crpix', 'axes', 'conv']:
-            kwargs[arg] = getattr(self, '_' + arg)
-        return kwargs
-
     @property
     def wcs(self):
         """WCS projection object."""