Maps documentation.

SimPEG/Maps.py

@@ -43,59 +43,82 @@ class IdentityMap(object):
 
     __metaclass__ = Utils.SimPEGMetaClass
 
-    counter = None   #: A SimPEG.Utils.Counter object
     mesh = None      #: A SimPEG Mesh
 
     def __init__(self, mesh):
         self.mesh = mesh
 
+    @property
+    def nP(self):
+        """
+            :rtype: int
+            :return: number of parameters in the model
+        """
+        return self.mesh.nC
+
+    @property
+    def shape(self):
+        """
+            The default shape is (mesh.nC, nP).
+
+            :rtype: (int,int)
+            :return: shape of the operator as a tuple
+        """
+        return (self.mesh.nC, self.nP)
+
     def transform(self, m):
         """
+            Changes the model into the physical property.
+
+            .. note::
+
+                This can be called by the __mul__ property against a numpy.ndarray.
+
             :param numpy.array m: model
             :rtype: numpy.array
             :return: transformed model
 
-            The *transform* changes the model into the physical property.
-
         """
         return m
 
     def transformInverse(self, D):
         """
+            Changes the physical property into the model.
+
+            .. note::
+
+                The *transformInverse* may not be easy to create in general.
+
             :param numpy.array D: physical property
             :rtype: numpy.array
             :return: model
 
-            The *transformInverse* changes the physical property into the model.
-
-            .. note:: The *transformInverse* may not be easy to create in general.
-
         """
         raise NotImplementedError('The transformInverse is not implemented.')
 
     def transformDeriv(self, m):
         """
+            The derivative of the transformation.
+
             :param numpy.array m: model
             :rtype: scipy.csr_matrix
             :return: derivative of transformed model
 
-            The *transform* changes the model into the physical property.
-            The *transformDeriv* provides the derivative of the *transform*.
         """
         return sp.identity(m.size)
 
-    @property
-    def nP(self):
-        """Number of parameters in the model."""
-        return self.mesh.nC
-
-    def example(self):
-        return np.random.rand(self.nP)
-
     def test(self, m=None, **kwargs):
+        """Test the derivative of the mapping.
+
+            :param numpy.array m: model
+            :param kwargs: key word arguments of :meth:`SimPEG.Tests.checkDerivative`
+            :rtype: bool
+            :return: passed the test?
+
+        """
         print 'Testing the %s Class!' % self.__class__.__name__
         if m is None:
-            m = self.example()
+            m = np.random.rand(self.nP)
         if 'plotIt' not in kwargs:
             kwargs['plotIt'] = False
         return checkDerivative(lambda m : [self.transform(m), self.transformDeriv(m)], m, **kwargs)
@@ -419,7 +442,7 @@ class ComboMap(IdentityMap):
             return self.transform(val)
 
 class ComplexMap(IdentityMap):
-    """docstring for ComplexMap
+    """ComplexMap
 
         default nP is nC in the mesh times 2 [real, imag]
 
@@ -434,6 +457,10 @@ class ComplexMap(IdentityMap):
     def nP(self):
         return self._nP
 
+    @property
+    def shape(self):
+        return (self.nP/2,self.nP)
+
     def transform(self, m):
         nC = self.mesh.nC
         return m[:nC] + m[nC:]*1j

SimPEG/Tests/TestUtils.py

@@ -202,7 +202,7 @@ def Rosenbrock(x, return_g=True, return_H=True):
         out += (H,)
     return out if len(out) > 1 else out[0]
 
-def checkDerivative(fctn, x0, num=7, plotIt=True, dx=None, expectedOrder=2, tolerance=0.85, eps=1e-10):
+def checkDerivative(fctn, x0, num=7, plotIt=True, dx=None, expectedOrder=2, tolerance=0.85, eps=1e-10, ax=None):
     """
         Basic derivative check
 
@@ -231,7 +231,7 @@ def checkDerivative(fctn, x0, num=7, plotIt=True, dx=None, expectedOrder=2, tole
     """
 
     print "%s checkDerivative %s" % ('='*20, '='*20)
-    print "iter    h         |f0-ft|   |f0-ft-h*J0*dx|  Order\n%s" % ('-'*57)
+    print "iter    h         |ft-f0|   |ft-f0-h*J0*dx|  Order\n%s" % ('-'*57)
 
     f0, J0 = fctn(x0)
 
@@ -282,14 +282,16 @@ def checkDerivative(fctn, x0, num=7, plotIt=True, dx=None, expectedOrder=2, tole
 
 
     if plotIt:
-        plt.figure()
-        plt.clf()
-        plt.loglog(h, E0, 'b')
-        plt.loglog(h, E1, 'g--')
-        plt.title('checkDerivative')
-        plt.xlabel('h')
-        plt.ylabel('error of Taylor approximation')
-        plt.legend(['0th order', '1st order'], loc='upper left')
+        ax = ax or plt.subplot(111)
+        ax.loglog(h, E0, 'b')
+        ax.loglog(h, E1, 'g--')
+        ax.set_title('Check Derivative - %s' % ('PASSED :)' if passTest else 'FAILED :('))
+        ax.set_xlabel('h')
+        ax.set_ylabel('Error')
+        leg = ax.legend(['$\mathcal{O}(h)$', '$\mathcal{O}(h^2)$'], loc='best',
+            title="$f(x + h\Delta x) - f(x) - h g(x) \Delta x - \mathcal{O}(h^2) = 0$",
+            frameon=False)
+        plt.setp(leg.get_title(),fontsize=15)
         plt.show()
 
     return passTest
@@ -328,6 +330,6 @@ if __name__ == '__main__':
     def simpleFail(x):
         return np.sin(x), -sdiag(np.cos(x))
 
-    checkDerivative(simplePass, np.random.randn(5), plotIt=False)
+    checkDerivative(simplePass, np.random.randn(5), plotIt=True)
     checkDerivative(simpleFunction, np.random.randn(5), plotIt=False)
     checkDerivative(simpleFail, np.random.randn(5), plotIt=False)