Fixed m and n controversy:

        m: i'm'age
        n: i'n'put

pyramid/costfunction.py

@@ -40,6 +40,10 @@ class Costfunction(object):
     Se_inv : :class:`~numpy.ndarray` (N=2), optional
         Inverted covariance matrix of the measurement errors. The matrix has size `NxN` with N
         being the length of the targetvector y (vectorized phase map information).
+    m: int
+        Size of the image space.
+    n: int
+        Size of the input space.
 
     '''
 
@@ -53,8 +57,8 @@ class Costfunction(object):
         # Extract important information:
         self.y = data_set.phase_vec
         self.Se_inv = data_set.Se_inv
-        self.n = data_set.n * 3
-        self.m = len(self.y)
+        self.n = data_set.n
+        self.m = data_set.m
         self.LOG.debug('Created '+str(self))
 
     def __repr__(self):
@@ -161,7 +165,7 @@ class CFAdapterScipyCG(LinearOperator):
 
     @property
     def shape(self):
-        return (self.cost.data_set.m, self.cost.data_set.m)
+        return (self.cost.data_set.n, self.cost.data_set.n)
 
     @property
     def dtype(self):

pyramid/dataset.py

@@ -46,22 +46,23 @@ class DataSet(object):
         A list of all stored :class:`~.PhaseMap` objects.
     phase_vec: :class:`~numpy.ndarray` (N=1)
         The concatenaded, vectorized phase of all ;class:`~.PhaseMap` objects.
-    n: int
-        Size of the image space.
     m: int
+        Size of the image space.
+    n: int
         Size of the input space.
+
     '''
 
     LOG = logging.getLogger(__name__+'.DataSet')
 
     @property
-    def n(self):
+    def m(self):
         return np.sum([len(p.phase_vec) for p in self.phase_maps])
 
     @property
     def Se_inv(self):
         # TODO: better implementation, maybe get-method? more flexible? input in append?
-        return sp.eye(self.n)
+        return sp.eye(self.m)
 
     @property
     def phase_vec(self):
@@ -88,9 +89,9 @@ class DataSet(object):
             'Dimension has to be a tuple of length 3!'
         if mask is not None:
             assert mask.shape == dim, 'Mask dimensions must match!'
-            self.m = 3 * np.sum(self.mask)
+            self.n = 3 * np.sum(self.mask)
         else:
-            self.m = 3 * np.prod(dim)
+            self.n = 3 * np.prod(dim)
         self.a = a
         self.dim = dim
         self.b_0 = b_0

pyramid/forwardmodel.py

@@ -30,9 +30,9 @@ class ForwardModel(object):
         The grid spacing in nm.
     dim : tuple (N=3)
         Dimensions of the 3D magnetic distribution.
-    n: int
-        Size of the image space. Number of pixels of the 2-dimensional projected grid.
     m: int
+        Size of the image space. Number of pixels of the 2-dimensional projected grid.
+    n: int
         Size of the input space. Number of voxels of the 3-dimensional grid.
 
     '''
@@ -61,7 +61,7 @@ class ForwardModel(object):
         self.LOG.debug('Calling __call__')
         self.mag_data.set_vector(x, self.data_set.mask)
         # TODO: Multiprocessing
-        result = np.zeros(self.n)
+        result = np.zeros(self.m)
         hp = self.hook_points
         for i, projector in enumerate(self.data_set.projectors):
             phase_map = self.phase_mappers[projector.dim_uv](projector(self.mag_data))
@@ -90,7 +90,7 @@ class ForwardModel(object):
         '''
         self.LOG.debug('Calling jac_dot')
         self.mag_data.set_vector(vector, self.data_set.mask)
-        result = np.zeros(self.n)
+        result = np.zeros(self.m)
         hp = self.hook_points
         for i, projector in enumerate(self.data_set.projectors):
             mag_vec = self.mag_data.mag_vec
@@ -119,7 +119,7 @@ class ForwardModel(object):
         '''
         self.LOG.debug('Calling jac_T_dot')
 
-        result = np.zeros(self.m)
+        result = np.zeros(self.n)
         hp = self.hook_points
         for i, projector in enumerate(self.data_set.projectors):
             vec = vector[hp[i]:hp[i+1]]

pyramid/magdata.py

@@ -281,9 +281,9 @@ class MagData(object):
             Order is: first all `x`-, then all `y`-, then all `z`-components.
 
         '''
-        return np.reshape([self.magnitude[2][mask],
+        return np.reshape([self.magnitude[0][mask],
                            self.magnitude[1][mask],
-                           self.magnitude[0][mask]], -1)
+                           self.magnitude[2][mask]], -1)
 
     def set_vector(self, vector, mask=None):
         '''Set the magnetic components of the masked pixels to the values specified by `vector`.
@@ -304,9 +304,9 @@ class MagData(object):
         assert np.size(vector) % 3 == 0, 'Vector has to contain all 3 components for every pixel!'
         count = np.size(vector)/3
         if mask is not None:
-            self.magnitude[2][mask] = vector[:count]  # x-component
+            self.magnitude[0][mask] = vector[:count]  # x-component
             self.magnitude[1][mask] = vector[count:2*count]  # y-component
-            self.magnitude[0][mask] = vector[2*count:]  # z-component
+            self.magnitude[2][mask] = vector[2*count:]  # z-component
         else:
             self.mag_vec = vector
 

pyramid/phasemapper.py

@@ -75,9 +75,9 @@ class PhaseMapperRDFC(PhaseMapper):
     geometry : {'disc', 'slab'}, optional
         Elementary geometry which is used for the phase contribution of one pixel.
         Default is 'disc'.
-    n: int
-        Size of the image space.
     m: int
+        Size of the image space.
+    n: int
         Size of the input space.
 
     '''
@@ -87,8 +87,8 @@ class PhaseMapperRDFC(PhaseMapper):
     def __init__(self, kernel):
         self.LOG.debug('Calling __init__')
         self.kernel = kernel
-        self.n = np.prod(kernel.dim_uv)
-        self.m = 2 * self.n
+        self.m = np.prod(kernel.dim_uv)
+        self.n = 2 * self.m
         self.LOG.debug('Created '+str(self))
 
     def __repr__(self):
@@ -135,8 +135,8 @@ class PhaseMapperRDFC(PhaseMapper):
 
         '''
         self.LOG.debug('Calling jac_dot')
-        assert len(vector) == self.m, \
-            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.m)
+        assert len(vector) == self.n, \
+            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.n)
         u_mag, v_mag = np.reshape(vector, (2,)+self.kernel.dim_uv)
         return self._convolve(u_mag, v_mag)
 
@@ -157,10 +157,10 @@ class PhaseMapperRDFC(PhaseMapper):
 
         '''
         self.LOG.debug('Calling jac_T_dot')
-        assert len(vector) == self.n, \
-            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.n)
+        assert len(vector) == self.m, \
+            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.m)
         # TODO: directly? ask Jörn again!
-        result = np.zeros(self.m)
+        result = np.zeros(self.n)
         nc.jac_T_dot_real_convolve(self.kernel.dim_uv[0], self.kernel.dim_uv[1],
                                    self.kernel.u, self.kernel.v, vector, result)
         return result
@@ -204,8 +204,8 @@ class PhaseMapperRDRC(PhaseMapper):
         self.kernel = kernel
         self.threshold = threshold
         self.numcore = numcore
-        self.n = np.prod(kernel.dim_uv)
-        self.m = 2 * self.n
+        self.m = np.prod(kernel.dim_uv)
+        self.n = 2 * self.m
         self.LOG.debug('Created '+str(self))
 
     def __repr__(self):
@@ -266,15 +266,15 @@ class PhaseMapperRDRC(PhaseMapper):
 
         '''
         self.LOG.debug('Calling jac_dot')
-        assert len(vector) == self.m, \
-            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.m)
+        assert len(vector) == self.n, \
+            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.n)
         v_dim, u_dim = self.kernel.dim_uv
-        result = np.zeros(self.n)
+        result = np.zeros(self.m)
         if self.numcore:
             nc.jac_dot_real_convolve(v_dim, u_dim, self.kernel.u, self.kernel.v, vector, result)
         else:
             # Iterate over all contributing pixels (numbered consecutively)
-            for s in range(self.n):  # column-wise (two columns at a time, u- and v-component)
+            for s in range(self.m):  # column-wise (two columns at a time, u- and v-component)
                 i = s % u_dim  # u-coordinate of current contributing pixel
                 j = int(s/u_dim)  # v-coordinate of current ccontributing pixel
                 u_min = (u_dim-1) - i  # u_dim-1: center of the kernel
@@ -282,7 +282,7 @@ class PhaseMapperRDRC(PhaseMapper):
                 v_min = (v_dim-1) - j  # v_dim-1: center of the kernel
                 v_max = (2*v_dim-1) - j  # = v_min + v_dim
                 result += vector[s] * self.kernel.u[v_min:v_max, u_min:u_max].reshape(-1)
-                result -= vector[s+self.n] * self.kernel.v[v_min:v_max, u_min:u_max].reshape(-1)
+                result -= vector[s+self.m] * self.kernel.v[v_min:v_max, u_min:u_max].reshape(-1)
         return result
 
     def jac_T_dot(self, vector):
@@ -302,15 +302,15 @@ class PhaseMapperRDRC(PhaseMapper):
 
         '''
         self.LOG.debug('Calling jac_T_dot')
-        assert len(vector) == self.n, \
-            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.n)
+        assert len(vector) == self.m, \
+            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.m)
         v_dim, u_dim = self.dim_uv
-        result = np.zeros(self.m)
+        result = np.zeros(self.n)
         if self.numcore:
             nc.jac_T_dot_real_convolve(v_dim, u_dim, self.kernel.u, self.kernel.v, vector, result)
         else:
             # Iterate over all contributing pixels (numbered consecutively):
-            for s in range(self.n):  # row-wise (two rows at a time, u- and v-component)
+            for s in range(self.m):  # row-wise (two rows at a time, u- and v-component)
                 i = s % u_dim  # u-coordinate of current contributing pixel
                 j = int(s/u_dim)  # v-coordinate of current contributing pixel
                 u_min = (u_dim-1) - i  # u_dim-1: center of the kernel
@@ -318,7 +318,7 @@ class PhaseMapperRDRC(PhaseMapper):
                 v_min = (v_dim-1) - j  # v_dim-1: center of the kernel
                 v_max = (2*v_dim-1) - j  # = v_min + v_dim
                 result[s] = np.sum(vector*self.u[v_min:v_max, u_min:u_max].reshape(-1))
-                result[s+self.n] = np.sum(vector*-self.v[v_min:v_max, u_min:u_max].reshape(-1))
+                result[s+self.m] = np.sum(vector*-self.v[v_min:v_max, u_min:u_max].reshape(-1))
         return result
 
 
@@ -356,8 +356,8 @@ class PhaseMapperFDFC(PhaseMapper):
         self.dim_uv = dim_uv
         self.b_0 = b_0
         self.padding = padding
-        self.n = np.prod(dim_uv)
-        self.m = 2 * self.n
+        self.m = np.prod(dim_uv)
+        self.n = 2 * self.m
         self.LOG.debug('Created '+str(self))
 
     def __repr__(self):
@@ -416,8 +416,8 @@ class PhaseMapperFDFC(PhaseMapper):
 
         '''
         self.LOG.debug('Calling jac_dot')
-        assert len(vector) == self.m, \
-            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.m)
+        assert len(vector) == self.n, \
+            'vector size not compatible! vector: {}, size: {}'.format(len(vector), self.n)
         mag_proj = MagData(self.a, np.zeros((3, 1)+self.dim_uv))
         magnitude_proj = self.jac_dot(vector).reshape((2, )+self.dim_uv)
         mag_proj.magnitude[1:3, 0, ...] = magnitude_proj

pyramid/projector.py

@@ -45,9 +45,9 @@ class Projector(object):
     coeff : list (N=2)
         List containing the six weighting coefficients describing the influence of the 3 components
         of a 3-dimensional vector field on the 2 projected components.
-    n: int
-        Size of the image space.
     m: int
+        Size of the image space.
+    n: int
         Size of the input space.
 
     '''
@@ -63,8 +63,8 @@ class Projector(object):
         self.weight = weight
         self.coeff = coeff
         self.size_2d, self.size_3d = weight.shape
-        self.m = 3 * np.prod(dim)
-        self.n = 2 * np.prod(dim_uv)
+        self.n = 3 * np.prod(dim)
+        self.m = 2 * np.prod(dim_uv)
         self.LOG.debug('Created '+str(self))
 
     def __repr__(self):