Merge branch 'master' of https://bitbucket.org/rcockett/simpeg into richards

Conflicts:
	SimPEG/inverse/Optimize.py
	SimPEG/regularization/Regularization.py

SimPEG/utils/ModelBuilder.py

@@ -1,4 +1,6 @@
 import numpy as np
+import scipy.ndimage as ndi
+import scipy.sparse as sp
 
 
 def getIndecesBlock(p0,p1,ccMesh):
@@ -130,6 +132,68 @@ def scalarConductivity(ccMesh,pFunction):
 
     return sigma
 
+
+
+def randomModel(shape, seed=None, anisotropy=None, its=100, bounds=[0,1]):
+    """
+        Create a random model by convolving a kernal with a
+        uniformly distributed model.
+
+        :param int,tuple shape: shape of the model.
+        :param int seed: pick which model to produce, prints the seed if you don't choose.
+        :param numpy.ndarray,list anisotropy: this is the (3 x n) blurring kernal that is used.
+        :param int its: number of smoothing iterations
+        :param list bounds: bounds on the model, len(list) == 2
+        :rtype: numpy.ndarray
+        :return: M, the model
+
+
+        .. plot::
+
+            import matplotlib.pyplot as plt
+            import SimPEG.utils.ModelBuilder as MB
+            plt.colorbar(plt.imshow(MB.randomModel((50,50),bounds=[-4,0])))
+            plt.title('A very cool, yet completely random model.')
+            plt.show()
+
+
+    """
+
+    if seed is None:
+        seed = np.random.randint(1e3)
+        print 'Using a seed of: ', seed
+
+    if type(shape) in [int, long, float]:
+        shape = (shape,) # make it a tuple for consistency
+
+    np.random.seed(seed)
+    mr = np.random.rand(*shape)
+    if anisotropy is None:
+        if len(shape) is 1:
+            smth = np.array([1,10.,1],dtype=float)
+        elif len(shape) is 2:
+            smth = np.array([[1,2,1],[7,10,7],[1,2,1]],dtype=float)
+        elif len(shape) is 3:
+            kernal = np.array([1,4,1], dtype=float).reshape((1,3))
+            smth = np.array(sp.kron(sp.kron(kernal,kernal.T).todense()[:],kernal).todense()).reshape((3,3,3))
+    else:
+        assert len(anisotropy.shape) is len(shape), 'Anisotropy must be the same shape.'
+        smth = np.array(anisotropy,dtype=float)
+
+    smth = smth/smth.sum() # normalize
+    mi = mr
+    for i in range(its):
+        mi = ndi.convolve(mi, smth)
+
+    # scale the model to live between the bounds.
+    mi = (mi - mi.min())/(mi.max()-mi.min()) # scaled between 0 and 1
+    mi = mi*(bounds[1]-bounds[0])+bounds[0]
+
+
+    return mi
+
+
+
 if __name__ == '__main__':
 
     from SimPEG.mesh import TensorMesh

SimPEG/utils/__init__.py

@@ -60,3 +60,114 @@ def printStoppers(obj, stoppers, pad='', stop='STOP!', done='DONE!'):
         r = stopper['right'](obj)
         print pad + stopper['str'] % (l<=r,l,r)
     print pad + "%s%s%s" % ('-'*25,done,'-'*25)
+
+
+import time
+import numpy as np
+
+
+class Counter(object):
+    """
+        Counter allows anything that calls it to record iterations and
+        timings in a simple way.
+
+        Also has plotting functions that allow quick recalls of data.
+
+        If you want to use this, import *count* or *timeIt* and use them as decorators on class methods.
+
+        .. ::
+
+            class MyClass(object):
+                def __init__(self, url):
+                    self.counter = Counter()
+
+                @count
+                def MyMethod(self):
+                    pass
+
+                @timeIt
+                def MySecondMethod(self):
+                    pass
+
+            c = MyClass('blah')
+            for i in range(100): c.MyMethod()
+            for i in range(300): c.MySecondMethod()
+            c.counter.summary()
+
+    """
+    def __init__(self):
+        self._countList = {}
+        self._timeList = {}
+
+    def count(self, prop):
+        """
+            Increases the count of the property.
+        """
+        assert type(prop) is str, 'The property must be a string.'
+        if prop not in self._countList:
+            self._countList[prop] = 0
+        self._countList[prop] += 1
+
+    def countTic(self, prop):
+        """
+            Times a property call, this is the init call.
+        """
+        assert type(prop) is str, 'The property must be a string.'
+        if prop not in self._timeList:
+            self._timeList[prop] = []
+        self._timeList[prop].append(-time.time())
+
+    def countToc(self, prop):
+        """
+            Times a property call, this is the end call.
+        """
+        assert type(prop) is str, 'The property must be a string.'
+        assert prop in self._timeList, 'The property must already be in the dictionary.'
+        self._timeList[prop][-1] += time.time()
+
+    def summary(self):
+        """
+            Provides a text summary of the current counters and timers.
+        """
+        print 'Counters:'
+        for prop in sorted(self._countList):
+            print "  {0:<40}: {1:8d}".format(prop,self._countList[prop])
+        print '\nTimes:'+' '*40+'mean      sum'
+        for prop in sorted(self._timeList):
+            l = len(self._timeList[prop])
+            a = np.array(self._timeList[prop])
+            print "  {0:<40}: {1:4.2e}, {2:4.2e}, {3:4d}x".format(prop,a.mean(),a.sum(),l)
+
+def count(f):
+    def wrapper(self,*args,**kwargs):
+        counter = getattr(self,'counter',None)
+        if type(counter) is Counter: counter.count(self.__class__.__name__+'.'+f.__name__)
+        out = f(self,*args,**kwargs)
+        return out
+    return wrapper
+
+def timeIt(f):
+    def wrapper(self,*args,**kwargs):
+        counter = getattr(self,'counter',None)
+        if type(counter) is Counter: counter.countTic(self.__class__.__name__+'.'+f.__name__)
+        out = f(self,*args,**kwargs)
+        if type(counter) is Counter: counter.countToc(self.__class__.__name__+'.'+f.__name__)
+        return out
+    return wrapper
+if __name__ == '__main__':
+    class MyClass(object):
+        def __init__(self, url):
+            self.counter = Counter()
+
+        @count
+        def MyMethod(self):
+            pass
+
+        @timeIt
+        def MySecondMethod(self):
+            pass
+
+    c = MyClass('blah')
+    for i in range(100): c.MyMethod()
+    for i in range(300): c.MySecondMethod()
+    c.counter.summary()