Merge branch 'master' into parallel

Change name "dispatcher" to "problem".

.bumpversion.cfg

@@ -1,4 +1,4 @@
 [bumpversion]
-current_version = 0.1.10
+current_version = 0.1.3
 files = setup.py SimPEG/__init__.py docs/conf.py
 

.gitignore

@@ -38,4 +38,5 @@ nosetests.xml
 *.sublime-project
 *.sublime-workspace
 docs/_build/
+*_cython.c
 Makefile

.travis.yml

@@ -2,29 +2,6 @@ language: python
 python:
   - 2.7
 
-sudo: false
-
-addons:
-  apt:
-    packages:
-    - gcc
-    - gfortran
-    - libopenmpi-dev
-    - libmumps-seq-dev
-    - libblas-dev
-    - liblapack-dev
-
-env:
-    - TEST_DIR="tests/mesh tests/base tests/utils"
-    - TEST_DIR=tests/em/fdem/inverse/derivs
-    - TEST_DIR=tests/em/tdem
-    - TEST_DIR=tests/dcip
-    - TEST_DIR=tests/flow
-    - TEST_DIR=tests/mt
-    - TEST_DIR=tests/examples
-    - TEST_DIR=tests/em/fdem/inverse/adjoint
-    - TEST_DIR=tests/em/fdem/forward
-
 # Setup anaconda
 before_install:
   - if [ ${TRAVIS_PYTHON_VERSION:0:1} == "2" ]; then wget http://repo.continuum.io/miniconda/Miniconda-3.8.3-Linux-x86_64.sh -O miniconda.sh; else wget http://repo.continuum.io/miniconda/Miniconda3-3.8.3-Linux-x86_64.sh -O miniconda.sh; fi
@@ -32,21 +9,20 @@ before_install:
   - ./miniconda.sh -b
   - export PATH=/home/travis/anaconda/bin:/home/travis/miniconda/bin:$PATH
   - conda update --yes conda
+  # The next couple lines fix a crash with multiprocessing on Travis and are not specific to using Miniconda
+  - sudo rm -rf /dev/shm
+  - sudo ln -s /run/shm /dev/shm
 
 # Install packages
 install:
-  - conda install --yes pip python=$TRAVIS_PYTHON_VERSION numpy scipy matplotlib cython ipython nose vtk
+  - conda install --yes pip python=$TRAVIS_PYTHON_VERSION numpy scipy matplotlib cython ipython networkx pyzmq
   - pip install nose-cov python-coveralls
-
-  - git clone https://github.com/rowanc1/pymatsolver.git
-  - cd pymatsolver; python setup.py install; cd ..
-
+  # - pip install -r requirements.txt
   - python setup.py install
-  - python setup.py build_ext --inplace
 
 # Run test
 script:
-  - nosetests $TEST_DIR --with-cov --cov SimPEG --cov-config .coveragerc -v -s
+  - nosetests --with-cov --cov SimPEG --cov-config .coveragerc -v -s
 
 # Calculate coverage
 after_success:
@@ -56,5 +32,3 @@ notifications:
   email:
     - rowanc1@gmail.com
     - lindseyheagy@gmail.com
-    - gkrosen@gmail.com
-    - sgkang09@gmail.com

AUTHORS.rst

@@ -1,13 +1,9 @@
+- Luz Angelica Caudillo-Mata, (`@lacmajedrez <https://github.com/lacmajedrez/>`_)
 - Rowan Cockett, (`@rowanc1 <https://github.com/rowanc1/>`_)
+- Eldad Haber, (`@ehaber99 <https://github.com/ehaber99/>`_)
 - Lindsey Heagy, (`@lheagy <https://github.com/lheagy/>`_)
 - Seogi Kang, (`@sgkang <https://github.com/sgkang/>`_)
-- Brendan Smithyman, (`@bsmithyman <https://github.com/bsmithyman/>`_)
-- Gudni Rosenkjaer, (`@grosenkj <https://github.com/grosenkj/>`_)
-- Dom Fournier, (`@fourndo <https://github.com/fourndo/>`_)
 - Dave Marchant, (`@dwfmarchant <https://github.com/dwfmarchant/>`_)
+- Gudni Rosenkjaer, (`@grosenkj <https://github.com/grosenkj/>`_)
 - Lars Ruthotto, (`@lruthotto <https://github.com/lruthotto/>`_)
 - Mike Wathen, (`@mrwathen <https://github.com/mrwathen/>`_)
-- Luz Angelica Caudillo-Mata, (`@lacmajedrez <https://github.com/lacmajedrez/>`_)
-- Eldad Haber, (`@ehaber99 <https://github.com/ehaber99/>`_)
-- Doug Oldenburg, (`@dougoldenburg <https://github.com/dougoldenburg/>`_)
-- Adam Pidlisecky, (`@aPid1 <https://github.com/aPid1/>`_)

CITATION.rst

@@ -1,21 +0,0 @@
-Citing SimPEG
--------------
-
-There is a `paper about SimPEG <http://dx.doi.org/10.1016/j.cageo.2015.09.015>`_, if you use this code, please help our scientific visibility by citing our work!
-
-
-    Cockett, R., Kang, S., Heagy, L. J., Pidlisecky, A., & Oldenburg, D. W. (2015). SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications. Computers & Geosciences.
-
-
-BibTex:
-
-.. code::
-
-    @article{cockett2015simpeg,
-      title={SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications},
-      author={Cockett, Rowan and Kang, Seogi and Heagy, Lindsey J and Pidlisecky, Adam and Oldenburg, Douglas W},
-      journal={Computers \& Geosciences},
-      year={2015},
-      publisher={Elsevier}
-    }
-

GCEtools/PETScIO.py

@@ -0,0 +1,470 @@
+#!/usr/bin/python
+"""
+Input and output functions.
+"""
+
+
+import os as _os
+import errno as _errno
+import sys as _sys
+import numpy as _np
+
+from petsc4py import PETSc as _PETSc
+import fileinput as _fl
+
+def vecToArray(obj):
+    """ Converts a PETSc vector to a numpy array, available on *all* MPI nodes.
+
+        Args:
+            obj (petsc4py.PETSc.Vec): input vector.
+
+        Returns:
+            numpy.array :
+        """
+    # scatter vector 'obj' to all processes
+    comm = obj.getComm()
+    scatter, obj0 = _PETSc.Scatter.toAll(obj)
+    scatter.scatter(obj, obj0, False, _PETSc.Scatter.Mode.FORWARD)
+
+    return _np.asarray(obj0)
+
+    # deallocate
+    comm.barrier()
+    scatter.destroy()
+    obj0.destroy()
+
+
+def vecToArray0(obj):
+    """ Converts a PETSc vector to a numpy array available on MPI node 0.
+
+        Args:
+            obj (petsc4py.PETSc.Vec): input vector.
+
+        Returns:
+            numpy.array :
+        """
+    # scatter vector 'obj' to process 0
+    comm = obj.getComm()
+    rank = comm.getRank()
+    scatter, obj0 = _PETSc.Scatter.toZero(obj)
+    scatter.scatter(obj, obj0, False, _PETSc.Scatter.Mode.FORWARD)
+
+    if rank == 0:   return _np.asarray(obj0)
+
+    # deallocate
+    comm.barrier()
+    scatter.destroy()
+    obj0.destroy()
+
+
+def arrayToVec(vecArray):
+    """ Converts a (global) array to a PETSc vector over :attr:`petsc4py.PETSc.COMM_WORLD`.
+
+        Args:
+            vecArray (array or numpy.array): input vector.
+
+        Returns:
+            petsc4py.PETSc.Vec() :
+        """
+    vec = _PETSc.Vec().create(comm=_PETSc.COMM_WORLD)
+    vec.setSizes(len(vecArray))
+    vec.setUp()
+    (Istart,Iend) = vec.getOwnershipRange()
+    return vec.createWithArray(vecArray[Istart:Iend],
+            comm=_PETSc.COMM_WORLD)
+    vec.destroy()
+
+
+def arrayToMat(matArray):
+    """ Converts a (global) 2D array to a PETSc matrix over :attr:`petsc4py.PETSc.COMM_WORLD`.
+
+        Args:
+            matArray (array or numpy.array): input square array.
+
+        :rtype: petsc4py.PETSc.Mat()
+
+        .. important::
+            Requires `SciPy <http://www.scipy.org>`_.
+
+        """
+    try:
+        import scipy.sparse as sparse
+    except:
+        print '\nERROR: loading matrices from txt files requires Scipy!'
+        return
+
+    matSparse =matArray
+
+    mat = _PETSc.Mat().createAIJ(size=matSparse.shape,comm=_PETSc.COMM_WORLD)
+    (Istart,Iend) = mat.getOwnershipRange()
+
+    ai = matSparse.indptr[Istart:Iend+1] - matSparse.indptr[Istart]
+    aj = matSparse.indices[matSparse.indptr[Istart]:matSparse.indptr[Iend]]
+    av = matSparse.data[matSparse.indptr[Istart]:matSparse.indptr[Iend]]
+
+    mat.setValuesCSR(ai,aj,av)
+    mat.assemble()
+
+    return mat
+    mat.destroy()
+
+def matToSparse(mat):
+    """ Converts a PETSc matrix to a (global) sparse matrix.
+
+        Args:
+            mat (petsc4py.PETSc.Mat): input PETSc matrix.
+
+        :rtype: scipy.sparse.csr_matrix
+
+        .. important::
+            Requires `SciPy <http://www.scipy.org>`_.
+
+        """
+    import scipy.sparse as sparse
+
+    data = mat.getValuesCSR()
+
+    (Istart,Iend) = mat.getOwnershipRange()
+    columns = mat.getSize()[0]
+    sparseSubMat = sparse.csr_matrix(data[::-1],shape=(Iend-Istart,columns))
+
+    comm = _PETSc.COMM_WORLD
+
+    sparseSubMat = comm.tompi4py().allgather(sparseSubMat)
+
+    return sparse.vstack(sparseSubMat)
+
+def adjToH(adj,d=[0],amp=[0.]):
+    """ Creates a 1 particle PETSc-type Hamiltonian matrix from a PETSc adjacency matrix.
+
+        Args:
+            adj (petsc4py.PETSc.Mat): input PETSc-type adjacency matrix.
+
+            d (array of ints): an array containing *integers* indicating the nodes
+                        where diagonal defects are to be placed (e.g. ``d=[0,1,4]``).
+
+            amp (array of floats):   an array containing *floats* indicating the diagonal defect
+                        amplitudes corresponding to each element in ``d`` (e.g. ``amp=[0.5,-1,4.2]``).
+
+        Returns:
+             : 1 particle Hamiltonian matrix
+        :rtype: petsc4py.PETSc.Mat()
+
+        Warning:
+            * The size of ``a`` and ``d`` must be identical
+
+                >>> amp = [0.5,-1.,4.2]
+                >>> len(d) == len(amp)
+                True
+
+            * Elements of ``d`` can range from :math:`[0,N-1]` where the adjacency matrix is :math:`N\\times N`.
+
+        """
+    (Istart,Iend) = adj.getOwnershipRange()
+    diagSum = []
+    for i in range(Istart,Iend):
+        diagSum.append(_np.sum(adj.getRow(i)[-1]))
+        for j,val in enumerate(d):
+            if i==val:  diagSum[i-Istart] += amp[j]
+
+    mat = _PETSc.Mat().create(comm=_PETSc.COMM_WORLD)
+    mat.setSizes(adj.getSize())
+    mat.setUp()
+
+    for i in range(Istart,Iend):
+        mat.setValue(i,i,diagSum[i-Istart])
+
+    mat.assemble()
+    mat.axpy(-1,adj)
+
+    return mat
+    mat.destroy()
+
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#---------------------- Vec I/O functions ---------------------------
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def exportVec(vec,filename,filetype):
+    """ Export a PETSc vector to a file.
+
+        Args:
+            vec (petsc4py.PETSc.Vec): input vector.
+            filename (str): path to desired output file.
+            filetype (str): the filetype of the exported vector.
+
+                            * ``'txt'`` - a column vector in text format.
+                            * ``'bin'`` - a PETSc binary vector.
+        """
+    if _os.path.isabs(filename):
+        outDir = _os.path.dirname(filename)
+    else:
+        outDir = './'+_os.path.dirname(filename)
+
+    # create output directory if it doesn't exist
+    try:
+        _os.mkdir(outDir)
+    except OSError as exception:
+        if exception.errno != _errno.EEXIST:
+            raise
+
+    if filetype == 'txt':
+        # scatter prob to process 0
+        comm = vec.getComm()
+        rank = comm.getRank()
+        scatter, vec0 = _PETSc.Scatter.toZero(vec)
+        scatter.scatter(vec, vec0, False, _PETSc.Scatter.Mode.FORWARD)
+
+        # use process 0 to write to text file
+        if rank == 0:
+            array0 = _np.asarray(vec0)
+            with open(filename,'w') as f:
+                for i in range(len(array0)):
+                    f.write('{0: .12e}\n'.format(array0[i]))
+
+        # deallocate
+        comm.barrier()
+        scatter.destroy()
+        vec0.destroy()
+
+    elif filetype == 'bin':
+        binSave = _PETSc.Viewer().createBinary(filename, 'w')
+        binSave(vec)
+        binSave.destroy()
+
+    vec.comm.barrier()
+
+def loadVec(filename,filetype):
+    """ Import a PETSc vector from a file.
+
+        Args:
+            filename (str): path to input file.
+            filetype (str): the filetype.
+
+                            * ``'txt'`` - a column vector in text format.
+                            * ``'bin'`` - a PETSc binary vector.
+        """
+    if filetype == 'txt':
+        try:
+            vecArray = _np.loadtxt(filename,dtype=_PETSc.ScalarType)
+            return arrayToVec(vecArray)
+        except:
+            print "\nERROR: input state space file " + filename\
+                + " does not exist or is in an incorrect format"
+            _sys.exit()
+
+    elif filetype == 'bin':
+        binLoad = _PETSc.Viewer().createBinary(filename, 'r')
+        try:
+            return _PETSc.Vec().load(binLoad)
+        except:
+            print "\nERROR: input state space file " + filename\
+                + " does not exist or is in an incorrect format"
+            _sys.exit()
+        binLoad.destroy()
+
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#---------------------- Mat I/O functions ---------------------------
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def exportMat(mat,filename,filetype,mattype=None):
+    """ Export a PETSc matrix to a file.
+
+        Args:
+            mat (petsc4py.PETSc.Mat): input matrix.
+            filename (str): path to desired output file.
+            filetype (str): the filetype of the exported vector.
+
+                            * ``'txt'`` - a 2D matrix array in text format.
+                            * ``'bin'`` - a PETSc binary matrix.
+            mattype (str): (``None``,``'adj'``) - if set to ``adj``, only
+                            integers ``0`` and ``1`` are written. Note
+                            that this only applied in ``txt`` mode.
+        """
+    rank = _PETSc.Comm.Get_rank(_PETSc.COMM_WORLD)
+
+    if _os.path.isabs(filename):
+        outDir = _os.path.dirname(filename)
+    else:
+        outDir = './'+_os.path.dirname(filename)
+
+    # create output directory if it doesn't exist
+    try:
+        _os.mkdir(outDir)
+    except OSError as exception:
+        if exception.errno != _errno.EEXIST:
+            raise
+
+    if filetype == 'txt':
+        txtSave = _PETSc.Viewer().createASCII(filename, 'w',
+            format=_PETSc.Viewer.Format.ASCII_DENSE, comm=_PETSc.COMM_WORLD)
+        txtSave(mat)
+        txtSave.destroy()
+
+        if rank == 0:
+            for line in _fl.FileInput(filename,inplace=1):
+                if line[2] != 't':
+                    if mattype == 'adj':
+                        line = line.replace(" i","j")
+                        line = line.replace(" -","-")
+                        line = line.replace("+-","-")
+                        line = line.replace("0000e+01+0.00000e+00j","")
+                        line = line.replace(".00000e+00+0.00000e+00j","")
+                        line = line.replace(".","")
+                        line = line.replace(" -","\t-")
+                        line = line.replace("  ","\t")
+                        line = line.replace(" ","")
+                        line = line.replace("\t"," ")
+                        print line,
+                    else:
+                        line = line.replace(" i","j")
+                        line = line.replace(" -","-")
+                        line = line.replace("+-","-")
+                        print line,
+
+    elif filetype == 'bin':
+        binSave = _PETSc.Viewer().createBinary(filename, 'w', comm=_PETSc.COMM_WORLD)
+        binSave(mat)
+        binSave.destroy()
+
+    mat.comm.barrier()
+
+def loadMat(filename,filetype,delimiter=None):
+    """ Import a PETSc matrix from a file.
+
+        Args:
+            filename (str): path to input file.
+            filetype (str): the filetype.
+
+                            * ``'txt'`` - a 2D matrix array in text format.
+                            * ``'bin'`` - a PETSc matrix vector.
+
+            delimiter (str): this is passed to `numpy.genfromtxt\
+                <http://docs.scipy.org/doc/numpy/reference/generated/numpy.genfromtxt.html>`_
+                in the case of strange delimiters in an imported ``txt`` file.
+        """
+    if filetype == 'txt':
+        try:
+            try:
+                if delimiter is None:
+                    matArray = _np.genfromtxt(filename,dtype=_PETSc.ScalarType)
+                else:
+                    matArray = _np.genfromtxt(filename,dtype=_PETSc.ScalarType,delimiter=delimiter)
+            except:
+                filefix = []
+                for line in _fl.FileInput(filename,inplace=0):
+                    if line[2] != 't':
+                        line = line.replace(" i","j")
+                        line = line.replace(" -","-")
+                        line = line.replace("+-","-")
+                        filefix.append(line)
+
+                matArray = _np.genfromtxt(filefix,dtype=_PETSc.ScalarType)
+
+            return arrayToMat(matArray)
+        except:
+            print "\nERROR: input state space file " + filename\
+                + " does not exist or is in an incorrect format"
+            _sys.exit()
+
+    elif filetype == 'bin':
+        binLoad = _PETSc.Viewer().createBinary(filename, 'r')
+        try:
+            return _PETSc.Mat().load(binLoad)
+        except:
+            print "\nERROR: input state space file " + filename\
+                + " does not exist or is in an incorrect format"
+            _sys.exit()
+        binLoad.destroy()
+
+def exportVecToMat(vec,filename,filetype):
+    """ Export a :math:`N^2` element PETSc vector as a :math:`N\\times N` matrix.
+
+        This is useful when wanting to view the full statespace of a 2 particle
+        quantum walk.
+
+        Args:
+            vec (petsc4py.PETSc.Vec): input :math:`N^2` element vector.
+            filename (str): path to desired output file.
+            filetype (str): the filetype of the exported vector.
+
+                            * ``'txt'`` - an :math:`N\\times N` 2D matrix array in text format.
+                            * ``'bin'`` - an :math:`N\\times N` PETSc binary matrix.
+        """
+    rank = _PETSc.Comm.Get_rank(_PETSc.COMM_WORLD)
+
+    if _os.path.isabs(filename):
+        outDir = _os.path.dirname(filename)
+    else:
+        outDir = './'+_os.path.dirname(filename)
+
+    # create output directory if it doesn't exist
+    try:
+        _os.mkdir(outDir)
+    except OSError as exception:
+        if exception.errno != _errno.EEXIST:
+            raise
+
+    vecArray = vecToArray(vec)
+    matArray = vecArray.reshape([_np.sqrt(vecArray.size),_np.sqrt(vecArray.size)])
+
+    if filetype == 'txt':
+        #if rank == 0:  _np.savetxt(filename,matArray)
+        txtSave = _PETSc.Viewer().createASCII(filename, 'w',
+            format=_PETSc.Viewer.Format.ASCII_DENSE, comm=_PETSc.COMM_WORLD)
+        txtSave(arrayToMat(matArray))
+        txtSave.destroy()
+
+        if rank == 0:
+            for line in _fl.FileInput(filename,inplace=1):
+                if line[2] != 't':
+                    line = line.replace(" i","j")
+                    line = line.replace(" -","-")
+                    line = line.replace("+-","-")
+                    print line,
+
+    elif filetype == 'bin':
+        binSave = _PETSc.Viewer().createBinary(filename, 'w', comm=_PETSc.COMM_WORLD)
+        binSave(arrayToMat(matArray))
+        binSave.destroy()
+    vec.comm.barrier()
+
+
+def loadMatToVec(filename,filetype):
+    """ Load a :math:`N\\times N` matrix as a :math:`N^2` element PETSc vector.
+
+        This is useful when wanting to import the full statespace of a 2 particle
+        quantum walk to use for propagation.
+
+        Args:
+            filename (str): path to the input file.
+            filetype (str): the filetype
+
+                            * ``'txt'`` - an :math:`N\\times N` 2D matrix array in text format.
+                            * ``'bin'`` - **Not yet implemented! Please use a txt \
+                                         format for this type of import**.
+        """
+    if filetype == 'txt':
+        try:
+            try:
+                matArray = _np.loadtxt(filename,dtype=_PETSc.ScalarType)
+            except:
+                filefix = []
+                for line in _fl.FileInput(filename,inplace=0):
+                    if line[2] != 't':
+                        line = line.replace(" i","j")
+                        line = line.replace(" -","-")
+                        line = line.replace("+-","-")
+                        filefix.append(line)
+
+                matArray = _np.loadtxt(filefix,dtype=_PETSc.ScalarType)
+
+            vecArray = matArray.reshape(matArray.shape[0]**2)
+            return arrayToVec(vecArray)
+        except:
+            print "\nERROR: input state space file " + filename\
+                + " does not exist or is in an incorrect format"
+            _sys.exit()
+
+    elif filetype == 'bin':
+        print '\nERROR: only works for txt storage!'
+        _sys.exit()

GCEtools/gceStartup.txt

@@ -0,0 +1,11 @@
+# Check project status
+gcutil getproject --project=<ProjectName> --cache_flag_values
+
+# Start an instance
+gcutil addinstance <instanceName>
+
+# Log in 
+gcutil ssh <instanceName>
+
+# Shut down
+gcutil deleteinstance <instanceName>

GCEtools/petscStartup.sh

@@ -0,0 +1,145 @@
+#! /bin/bash
+
+locale-gen en_US en_US.UTF-8 hu_HU hu_HU.UTF-8 > output.t
+dpkg-reconfigure locales >> output.t
+
+sudo apt-get update  >> output.t
+echo " "
+echo " "
+echo "   ============================================"
+echo "   | Installing packages form package manager |"
+echo "   ============================================"
+echo " "
+echo " "
+
+sudo apt-get -y install aptitude >> output.t
+
+packages=(gcc gfortran git libopenmpi-dev python-pip python-dev git flex bison cmake vim cython ipython python-scipy python-numpy python-nose python-pip python-matplotlib python-vtk python-h5py libmumps-ptscotch-4.10.0 libmumps-ptscotch-dev libblas-dev liblapack-dev )
+
+
+for item in ${packages[*]}
+do
+    printf "     %-30s\n" $item
+
+done
+
+for item in ${packages[*]}
+do
+    tput cuu1
+done
+
+for item in ${packages[*]}
+do
+    sudo aptitude -y install $item >> output.t
+    printf "     %-30s              %-4s\n" $item done
+done
+
+
+echo " "
+echo " "
+echo "   ====================================="
+echo "   | Installing extra Python libraries |"
+echo "   ====================================="
+echo " "
+echo " "
+
+
+pipPackages=(mpi4py pymumps)
+
+for item in ${pipPackages[*]}
+do
+    printf "     %-30s\n" $item
+done
+
+for item in ${pipPackages[*]}
+do
+    tput cuu1
+done
+
+for item in ${pipPackages[*]}
+do
+        sudo pip install $item >> output.t
+        printf "     %-30s              %-4s\n" $item done
+done
+
+Upgrade=(scipy numpy ipython)
+
+for item in ${Upgrade[*]}
+do
+    printf "     %-8s%-7s\n" $item upgrade
+
+done
+
+for item in ${Upgrade[*]}
+do
+    tput cuu1
+done
+
+for item in ${Upgrade[*]}
+do
+    sudo pip install $item --upgrade >> output.t
+    printf "     %-8s%-7s                             %-4s\n" $item upgrade done
+done
+
+
+
+echo " "
+echo " "
+echo "   ====================="
+echo "   | Installing SimPEG |"
+echo "   ====================="
+echo " "
+echo " "
+cd ~
+
+
+git clone https://github.com/simpeg/simpeg.git >> output.t
+cd simpeg/SimPEG/
+python setup.py >> output.t
+cd ~
+
+mkdir petsc
+cd petsc
+
+echo " "
+echo " "
+echo "   ===================="
+echo "   | Installing PETSc |"
+echo "   ===================="
+echo " "
+echo " "
+wget http://ftp.mcs.anl.gov/pub/petsc/release-snapshots/petsc-3.4.3.tar.gz
+
+tar -zxf petsc-3.4.3.tar.gz
+
+cd petsc-3.4.3
+
+./configure --with-debugging=no  --dowload-mpich=yes --download-blacs=yes --download-f-blas-lapack=yes --download-scalapack=yes --download-mumps=yes --download-ml=yes --download-spooles=yes --download-hypre=yes --dowload-trilinos=yes --download-metis=yes --download-parmetis=yes --download-umfpack=yes --download-ptscotch=yes  --download-superlu=yes --download-superlu_dist=yes --download-essl=yes --download-eucild=yes  --download-spai=yes  --download-mpi4py=yes --download-petsc4py=yes --download-scientificpython=yes
+
+
+echo "export PETSC_DIR=/home/${USER}/petsc/petsc-3.4.3" >> ~/.bashrc
+echo "export PETSC_ARCH=arch-linux2-c-opt" >> ~/.bashrc
+export PETSC_DIR=/home/${USER}/petsc/petsc-3.4.3
+export PETSC_ARCH=arch-linux2-c-opt
+. ~/.bashrc
+
+make PETSC_DIR=/home/${USER}/petsc/petsc-3.4.3 PETSC_ARCH=arch-linux2-c-opt all
+make PETSC_DIR=/home/${USER}/petsc/petsc-3.4.3 PETSC_ARCH=arch-linux2-c-opt test
+
+cd ~/petsc
+echo " "
+echo " "
+echo "   ======================="
+echo "   | Installing PETSc4PY |"
+echo "   ======================="
+echo " "
+echo " "
+git clone https://bitbucket.org/petsc/petsc4py.git
+cd petsc4py/
+python setup.py build >> output.t
+python setup.py install --prefix=~/petsc >> output.t
+
+echo "export PYTHONPATH=~/petsc/lib/python2.7/site-packages:/home/$USER/simpeg:${PYTHONPATH}" >> ~/.bashrc
+
+cd ~
+source ~/.bashrc

GCEtools/startup.sh

@@ -0,0 +1,22 @@
+#! /bin/bash
+sudo aptitude -y update
+sudo aptitude -y upgrade
+sudo aptitude -y install gcc gfortran git libopenmpi-dev python-pip python-dev
+sudo aptitude -y install ipython python-scipy python-numpy python-nose python-pip python-matplotlib
+sudo aptitude -y install libmumps-ptscotch-4.10.0 libmumps-ptscotch-dev
+sudo aptitude -y install libblas-dev liblapack-dev
+
+sudo pip install mpi4py
+sudo pip install pymumps
+
+sudo pip install scipy --upgrade
+sudo pip install numpy --upgrade
+sudo pip install ipython --upgrade
+
+git clone https://github.com/simpeg/simpeg.git
+cd simpeg/SimPEG/
+python setup.py
+cd ~
+
+echo export PYTHONPATH=/home/$USER/simpeg/ >> .bashrc
+source .bashrc

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2013-2016 SimPEG Developers
+Copyright (c) 2013-2015 SimPEG Developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

PROJECTS.rst

@@ -0,0 +1,36 @@
+- Electromagnetics (`simpegEM <http://simpegem.rtfd.org/>`_)
+    .. image:: https://travis-ci.org/simpeg/simpegem.svg?branch=master
+        :target: https://travis-ci.org/simpeg/simpegem
+        :alt: Master Branch
+    .. image:: https://coveralls.io/repos/simpeg/simpegem/badge.png?branch=master
+        :target: https://coveralls.io/r/simpeg/simpegem?branch=master
+- Potential Fields (`simpegPF <http://simpegpf.rtfd.org/>`_)
+    .. image:: https://travis-ci.org/simpeg/simpegpf.svg?branch=master
+        :target: https://travis-ci.org/simpeg/simpegpf
+        :alt: Master Branch
+    .. image:: https://coveralls.io/repos/simpeg/simpegpf/badge.png?branch=master
+        :target: https://coveralls.io/r/simpeg/simpegpf?branch=master
+- Ground Water Flow (`simpegFLOW <http://simpegflow.rtfd.org/>`_)
+    .. image:: https://travis-ci.org/simpeg/simpegflow.svg?branch=master
+        :target: https://travis-ci.org/simpeg/simpegflow
+        :alt: Master Branch
+    .. image:: https://coveralls.io/repos/simpeg/simpegflow/badge.png?branch=master
+        :target: https://coveralls.io/r/simpeg/simpegflow?branch=master
+- Direct Current Resistivity (`simpegDC <http://simpeg-dc.rtfd.org/>`_)
+    .. image:: https://travis-ci.org/simpeg/simpegdc.svg?branch=master
+        :target: https://travis-ci.org/simpeg/simpegdc
+        :alt: Master Branch
+    .. image:: https://coveralls.io/repos/simpeg/simpegdc/badge.png?branch=master
+        :target: https://coveralls.io/r/simpeg/simpegdc?branch=master
+- Electromagnetics 1D (`simpegEM1D <http://simpegem1d.rtfd.org/>`_)
+    .. image:: https://travis-ci.org/simpeg/simpegEM1D.svg?branch=master
+        :target: https://travis-ci.org/simpeg/simpegEM1D
+        :alt: Master Branch
+    .. image:: https://coveralls.io/repos/simpeg/simpegEM1D/badge.png?branch=master
+        :target: https://coveralls.io/r/simpeg/simpegEM1D?branch=master
+- Magnetotellurics (`simpegMT <http://simpegmt.rtfd.org/>`_)
+    .. image:: https://travis-ci.org/simpeg/simpegmt.svg?branch=master
+        :target: https://travis-ci.org/simpeg/simpegmt
+        :alt: Master Branch
+    .. image:: https://coveralls.io/repos/simpeg/simpegmt/badge.png?branch=master
+        :target: https://coveralls.io/r/simpeg/simpegmt?branch=master

README.rst

@@ -17,7 +17,7 @@ SimPEG
     :target: https://github.com/simpeg/simpeg/blob/master/LICENSE
     :alt: BSD 3 clause license.
 
-.. image:: https://api.travis-ci.org/simpeg/simpeg.svg?branch=master
+.. image:: https://img.shields.io/travis/simpeg/simpeg.svg
     :target: https://travis-ci.org/simpeg/simpeg
     :alt: Travis CI build status
 
@@ -25,10 +25,6 @@ SimPEG
     :target: https://coveralls.io/r/simpeg/simpeg?branch=master
     :alt: Coverage status
 
-.. image:: http://img.shields.io/badge/GITTER-JOIN_CHAT-brightgreen.svg?style=flat-square
-    :alt: gitter chat room at https://gitter.im/simpeg/simpeg
-    :target: https://gitter.im/simpeg/simpeg
-    
 Simulation and Parameter Estimation in Geophysics  -  A python package for simulation and gradient based parameter estimation in the context of geophysical applications.
 
 The vision is to create a package for finite volume simulation with applications to geophysical imaging and subsurface flow. To enable the understanding of the many different components, this package has the following features:
@@ -40,28 +36,6 @@ The vision is to create a package for finite volume simulation with applications
 * designed for large-scale inversions
 
 
-Citing SimPEG:
---------------
-
-There is a paper about SimPEG!
-
-
-    Cockett, R., Kang, S., Heagy, L. J., Pidlisecky, A., & Oldenburg, D. W. (2015). SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications. Computers & Geosciences.
-
-
-**BibTex:**
-
-.. code::
-
-    @article{cockett2015simpeg,
-      title={SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications},
-      author={Cockett, Rowan and Kang, Seogi and Heagy, Lindsey J and Pidlisecky, Adam and Oldenburg, Douglas W},
-      journal={Computers \& Geosciences},
-      year={2015},
-      publisher={Elsevier}
-    }
-
-
 Website:
 http://simpeg.xyz
 
@@ -83,4 +57,4 @@ https://github.com/simpeg/simpeg/issues
 
 
 Code Snippets & Tutorials:
-http://simpeg.xyz/Journal
+http://www.row1.ca/simpeg

SimPEG/DCIP/BaseDC.py

@@ -1,292 +0,0 @@
-from SimPEG import *
-
-class FieldsDC_CC(Problem.Fields):
-    knownFields = {'phi_sol':'CC'}
-    aliasFields = {
-                    'phi' : ['phi_sol','CC','_phi'],
-                    'e' : ['phi_sol','F','_e'],
-                    'j' : ['phi_sol','F','_j']
-                  }
-
-    def __init__(self,mesh,survey,**kwargs):
-        super(FieldsDC_CC, self).__init__(mesh, survey, **kwargs)
-
-    def startup(self):
-        self._cellGrad = self.survey.prob.mesh.cellGrad
-        self._Mfinv = self.survey.prob.mesh.getFaceInnerProduct(invMat=True)
-
-    def _phi(self, phi_sol, srcList):
-        phi = phi_sol
-        # for i, src in enumerate(srcList):
-        #     phi_p = src.phi_p(self.survey.prob)
-        #     if phi_p is not None:
-        #         phi[:,i] += phi_p
-        return phi
-
-    def _e(self, phi_sol, srcList):
-        e = -self._cellGrad*phi_sol
-        # for i, src in enumerate(srcList):
-        #     e_p = src.e_p(self.survey.prob)
-        #     if e_p is not None:
-        #         e[:,i] += e_p
-        return e
-
-    def _j(self, phi_sol, srcList):
-
-        j = -self._Mfinv*self.survey.prob.Msig*self._cellGrad*phi_sol
-        # for i, src in enumerate(srcList):
-        #     j_p = src.j_p(self.survey.prob)
-        #     if j_p is not None:
-        #         j[:,i] += j_p
-        return j
-
-
-
-class SrcDipole(Survey.BaseSrc):
-    """A dipole source, locA and locB are moved to the closest cell-centers"""
-
-    current = 1
-    loc  = None
-    # _rhsDict = None
-
-    def __init__(self, rxList, locA, locB, **kwargs):
-        self.loc = (locA, locB)
-        super(SrcDipole, self).__init__(rxList, **kwargs)
-
-    def eval(self, prob):
-        # Recompute rhs
-        # if getattr(self, '_rhsDict', None) is None:
-        #     self._rhsDict = {}
-        # if mesh not in self._rhsDict:
-        pts = [self.loc[0], self.loc[1]]
-        inds = Utils.closestPoints(prob.mesh, pts)
-        q = np.zeros(prob.mesh.nC)
-        q[inds] = - self.current * ( np.r_[1., -1.] / prob.mesh.vol[inds] )
-        # self._rhsDict[mesh] = q
-        # return self._rhsDict[mesh]
-        return q
-
-
-class RxDipole(Survey.BaseRx):
-    """A dipole source, locA and locB are moved to the closest cell-centers"""
-    def __init__(self, locsM, locsN, **kwargs):
-        locs = (locsM, locsN)
-        assert locsM.shape == locsN.shape, 'locs must be the same shape.'
-        super(RxDipole, self).__init__(locs, 'dipole', storeProjections=False, **kwargs)
-
-    @property
-    def nD(self):
-        """Number of data in the receiver."""
-        return self.locs[0].shape[0]
-
-    def getP(self, mesh):
-        P0 = mesh.getInterpolationMat(self.locs[0], self.projGLoc)
-        P1 = mesh.getInterpolationMat(self.locs[1], self.projGLoc)
-        return P0 - P1
-
-
-class SurveyDC(Survey.BaseSurvey):
-    """
-        **SurveyDC**
-
-        Geophysical DC resistivity data.
-
-    """
-    uncert = None
-    def __init__(self, srcList, **kwargs):
-        self.srcList = srcList
-        Survey.BaseSurvey.__init__(self, **kwargs)
-        # self._rhsDict = {}
-        self._Ps = {}
-
-    def eval(self, u):
-        """
-            Predicted data.
-
-            .. math::
-                d_\\text{pred} = Pu(m)
-        """
-        P = self.getP(self.prob.mesh)
-        return P*mkvc(u[self.srcList, 'phi_sol'])
-
-    def getP(self, mesh):
-        if mesh in self._Ps:
-            return self._Ps[mesh]
-
-        P_src = [sp.vstack([rx.getP(mesh) for rx in src.rxList]) for src in self.srcList]
-
-        self._Ps[mesh] = sp.block_diag(P_src)
-        return self._Ps[mesh]
-
-
-class ProblemDC_CC(Problem.BaseProblem):
-    """
-        **ProblemDC**
-
-        Geophysical DC resistivity problem.
-
-    """
-
-    surveyPair = SurveyDC
-    Solver     = Solver
-    fieldsPair = FieldsDC_CC
-    Ainv = None
-
-    def __init__(self, mesh, **kwargs):
-        Problem.BaseProblem.__init__(self, mesh)
-        self.mesh.setCellGradBC('neumann')
-        Utils.setKwargs(self, **kwargs)
-
-
-    deleteTheseOnModelUpdate = ['_A', '_Msig', '_dMdsig']
-
-    @property
-    def Msig(self):
-        if getattr(self, '_Msig', None) is None:
-            sigma = self.curModel.transform
-            Av = self.mesh.aveF2CC
-            self._Msig = Utils.sdiag(1/(self.mesh.dim * Av.T * (1/sigma)))
-        return self._Msig
-
-    @property
-    def dMdsig(self):
-        if getattr(self, '_dMdsig', None) is None:
-            sigma = self.curModel.transform
-            Av = self.mesh.aveF2CC
-            dMdprop = self.mesh.dim * Utils.sdiag(self.Msig.diagonal()**2) * Av.T * Utils.sdiag(1./sigma**2)
-            self._dMdsig = lambda Gu: Utils.sdiag(Gu) * dMdprop
-        return self._dMdsig
-
-    @property
-    def A(self):
-        """
-            Makes the matrix A(m) for the DC resistivity problem.
-
-            :param numpy.array m: model
-            :rtype: scipy.csc_matrix
-            :return: A(m)
-
-            .. math::
-                c(m,u) = A(m)u - q = G\\text{sdiag}(M(mT(m)))Du - q = 0
-
-            Where M() is the mass matrix and mT is the model transform.
-        """
-        if getattr(self, '_A', None) is None:
-            D = self.mesh.faceDiv
-            G = self.mesh.cellGrad
-            self._A = D*self.Msig*G
-            # Remove the null space from the matrix.
-            self._A[0,0] /= self.mesh.vol[0]
-            self._A = self._A.tocsc()
-        return self._A
-
-    def getRHS(self):
-        # if self.mesh not in self._rhsDict:
-        RHS = np.array([src.eval(self) for src in self.survey.srcList]).T
-        # self._rhsDict[mesh] = RHS
-        # return self._rhsDict[mesh]
-        return RHS
-
-    def fields(self, m):
-
-        F = self.fieldsPair(self.mesh, self.survey)
-        self.curModel = m
-        A    = self.A
-        self.Ainv = self.Solver(A, **self.solverOpts)
-        RHS    = self.getRHS()
-        Phi  = self.Ainv * RHS
-        Srcs = self.survey.srcList
-        F[Srcs, 'phi_sol'] = Phi
-
-        return F
-
-    def Jvec(self, m, v, f=None):
-        """
-            :param numpy.array m: model
-            :param numpy.array v: vector to multiply
-            :param Fields f: fields
-            :rtype: numpy.array
-            :return: Jv
-
-            .. math::
-                c(m,u) = A(m)u - q = G\\text{sdiag}(M(mT(m)))Du - q = 0
-
-                \\nabla_u (A(m)u - q) = A(m)
-
-                \\nabla_m (A(m)u - q) = G\\text{sdiag}(Du)\\nabla_m(M(mT(m)))
-
-            Where M() is the mass matrix and mT is the model transform.
-
-            .. math::
-                J = - P \left( \\nabla_u c(m, u) \\right)^{-1} \\nabla_m c(m, u)
-
-                J(v) = - P ( A(m)^{-1} ( G\\text{sdiag}(Du)\\nabla_m(M(mT(m))) v ) )
-        """
-        # Set current model; clear dependent property $\mathbf{A(m)}$
-        self.curModel = m
-        sigma = self.curModel.transform # $\sigma = \mathcal{M}(\m)$
-        if f is None:
-            # Run forward simulation if $u$ not provided
-            f = self.fields(self.curModel)
-        u = f[self.survey.srcList, 'phi_sol']
-
-        D = self.mesh.faceDiv
-        G = self.mesh.cellGrad
-        # Derivative of model transform, $\deriv{\sigma}{\m}$
-        dsigdm_x_v = self.curModel.transformDeriv * v
-
-        # Take derivative of $C(m,u)$ w.r.t. $m$
-        dCdm_x_v = np.empty_like(u)
-        # loop over fields for each source
-        for i in range(self.survey.nSrc):
-            # Derivative of inner product, $\left(\mathbf{M}_{1/\sigma}^f\right)^{-1}$
-            dAdsig         = D * self.dMdsig( G * u[:,i] )
-            dCdm_x_v[:, i] = dAdsig *  dsigdm_x_v
-
-        # Take derivative of $C(m,u)$ w.r.t. $u$
-        dA_du = self.A
-        # Solve for $\deriv{u}{m}$
-        # dCdu_inv = self.Solver(dCdu, **self.solverOpts)
-        if self.Ainv is None:
-            self.Ainv = self.Solver(dA_du, **self.solverOpts)
-
-        P     = self.survey.getP(self.mesh)
-        Jv    = - P * mkvc( self.Ainv * dCdm_x_v )
-        return Jv
-
-    def Jtvec(self, m, v, f=None):
-
-        self.curModel = m
-        sigma = self.curModel.transform # $\sigma = \mathcal{M}(\m)$
-        if f is None:
-            # Run forward simulation if $f$ not provided
-            f = self.fields(self.curModel)
-        u = f[self.survey.srcList, 'phi_sol']
-
-        shp = u.shape
-        P = self.survey.getP(self.mesh)
-        PT_x_v = (P.T*v).reshape(shp, order='F')
-
-        D = self.mesh.faceDiv
-        G = self.mesh.cellGrad
-        dA_du = self.A
-        mT_dm = self.mapping.deriv(m)
-
-        # We probably always need this due to the linesearch .. (?)
-        self.Ainv = self.Solver(dA_du.T, **self.solverOpts)
-        # if self.Ainv is None:
-        #     self.Ainv = self.Solver(dCdu, **self.solverOpts)
-
-        w = self.Ainv * PT_x_v
-
-        Jtv = 0
-        for i, ui in enumerate(u.T):  # loop over each column
-            Jtv += self.dMdsig( G * ui ).T * ( D.T * w[:,i] )
-
-        Jtv = - mT_dm.T * ( Jtv )
-        return Jtv
-
-
-
-
-

SimPEG/DCIP/BaseIP.py

@@ -1,182 +0,0 @@
-from SimPEG import *
-from BaseDC import SurveyDC, FieldsDC_CC
-
-class SurveyIP(SurveyDC):
-    """
-        **SurveyDC**
-
-        Geophysical DC resistivity data.
-
-    """
-
-    def __init__(self, srcList, **kwargs):
-        self.srcList = srcList
-        Survey.BaseSurvey.__init__(self, **kwargs)
-        self._Ps = {}
-
-    def dpred(self, m, f=None):
-        """
-            Predicted data.
-
-            .. math::
-                d_\\text{pred} = Pf(m)
-        """
-
-        return self.prob.forward(m)
-
-
-class ProblemIP(Problem.BaseProblem):
-    """
-        **ProblemIP**
-
-        Geophysical IP resistivity problem.
-
-    """
-
-    surveyPair = SurveyDC
-    Solver     = Solver
-    sigma = None
-    Ainv = None
-    u = None
-
-    def __init__(self, mesh, **kwargs):
-        Problem.BaseProblem.__init__(self, mesh)
-        self.mesh.setCellGradBC('neumann')
-        Utils.setKwargs(self, **kwargs)
-
-    # deleteTheseOnModelUpdate = ['_A', '_Msig', '_dMdsig']
-
-    @property
-    def Msig(self):
-        if getattr(self, '_Msig', None) is None:
-            # sigma = self.curModel.transform
-            sigma = self.sigma
-            Av = self.mesh.aveF2CC
-            self._Msig = Utils.sdiag(1/(self.mesh.dim * Av.T * (1/sigma)))
-        return self._Msig
-
-    @property
-    def dMdsig(self):
-        if getattr(self, '_dMdsig', None) is None:
-            # sigma = self.curModel.transform
-            sigma = self.sigma
-            Av = self.mesh.aveF2CC
-            dMdprop = self.mesh.dim * Utils.sdiag(self.Msig.diagonal()**2) * Av.T * Utils.sdiag(1./sigma**2)
-            self._dMdsig = lambda Gu: Utils.sdiag(Gu) * dMdprop
-        return self._dMdsig
-
-    @property
-    def A(self):
-        """
-            Makes the matrix A(m) for the DC resistivity problem.
-
-            :param numpy.array m: model
-            :rtype: scipy.csc_matrix
-            :return: A(m)
-
-            .. math::
-                c(m,u) = A(m)u - q = G\\text{sdiag}(M(mT(m)))Du - q = 0
-
-            Where M() is the mass matrix and mT is the model transform.
-        """
-        if getattr(self, '_A', None) is None:
-            D = self.mesh.faceDiv
-            G = self.mesh.cellGrad
-            self._A = D*self.Msig*G
-            # Remove the null space from the matrix.
-            self._A[-1,-1] /= self.mesh.vol[-1]
-            self._A = self._A.tocsc()
-        return self._A
-
-    def getRHS(self):
-        # if self.mesh not in self._rhsDict:
-        RHS = np.array([src.eval(self) for src in self.survey.srcList]).T
-        # self._rhsDict[mesh] = RHS
-        # return self._rhsDict[mesh]
-        return RHS
-
-    def fields(self, m):
-        if self.u is None:
-	        A    = self.A
-	        if self.Ainv == None:
-	        	self.Ainv = self.Solver(A, **self.solverOpts)
-	        Q    = self.getRHS()
-	        self.u  = self.Ainv * Q
-        return self.u
-
-    def forward(self, m, u=None):
-        # Set current model; clear dependent property $\mathbf{A(m)}$
-        self.curModel = m
-        # sigma = self.curModel.transform # $\sigma = \mathcal{M}(\m)$
-        sigma = self.sigma
-        if self.u is None:
-            # Run forward simulation if $u$ not provided
-            u = self.fields(sigma)
-
-        shp = (self.mesh.nC, self.survey.nSrc)
-        u = self.u.reshape(shp, order='F')
-
-        D = self.mesh.faceDiv
-        G = self.mesh.cellGrad
-        # Derivative of model transform, $\deriv{\sigma}{\m}$
-        # dsigdm_x_v = self.curModel.transformDeriv * v
-
-        dsigdm_x_v = Utils.sdiag(sigma) * self.curModel.transformDeriv *  m
-
-        # Take derivative of $C(m,u)$ w.r.t. $m$
-        dCdm_x_v = np.empty_like(u)
-        # loop over fields for each source
-        for i in range(self.survey.nSrc):
-            # Derivative of inner product, $\left(\mathbf{M}_{1/\sigma}^f\right)^{-1}$
-            dAdsig         = D * self.dMdsig( G * u[:,i] )
-            dCdm_x_v[:, i] = dAdsig *  dsigdm_x_v
-
-        # Take derivative of $C(m,u)$ w.r.t. $u$
-
-        if self.Ainv == None:
-        	self.Ainv = self.Solver(A, **self.solverOpts)
-
-        # dCdu = self.A
-        # Solve for $\deriv{u}{m}$
-        # dCdu_inv = self.Solver(dCdu, **self.solverOpts)
-        P        = self.survey.getP(self.mesh)
-        J_x_v    = - P * mkvc( self.Ainv * dCdm_x_v )
-        return -J_x_v
-
-    def Jvec(self, m, v, f=None):
-        return self.forward(v)
-
-    def Jtvec(self, m, v, f=None):
-
-        self.curModel = m
-        # sigma = self.curModel.transform # $\sigma = \mathcal{M}(\m)$
-        sigma = self.sigma
-        if self.u is None:
-            u = self.fields(sigma)
-        else:
-        	u = self.u
-        shp = (self.mesh.nC, self.survey.nSrc)
-        u = u.reshape(shp, order='F')
-        P = self.survey.getP(self.mesh)
-        PT_x_v = (P.T*v).reshape(shp, order='F')
-
-        D = self.mesh.faceDiv
-        G = self.mesh.cellGrad
-        A = self.A
-        mT_dm = Utils.sdiag(sigma)*self.mapping.deriv(m)
-        # mT_dm = self.mapping.deriv(m)
-
-        # dCdu = A.T
-        # Ainv = self.Solver(dCdu, **self.solverOpts)
-        # if self.Ainv == None:
-    	self.Ainv = self.Solver(A.T, **self.solverOpts)
-
-        w = self.Ainv * PT_x_v
-
-        Jtv = 0
-        for i, ui in enumerate(u.T):  # loop over each column
-            Jtv += self.dMdsig( G * ui ).T * ( D.T * w[:,i] )
-
-        Jtv = - mT_dm.T * ( Jtv )
-        return -Jtv
-

SimPEG/DCIP/Utils.py

@@ -1,38 +0,0 @@
-import numpy as np
-
-def WennerSrcList(nElecs, aSpacing, in2D=False, plotIt=False):
-
-    import SimPEG.DCIP as DC
-
-    elocs = np.arange(0,aSpacing*nElecs,aSpacing)
-    elocs -= (nElecs*aSpacing - aSpacing)/2
-    space = 1
-    WENNER = np.zeros((0,),dtype=int)
-    for ii in range(nElecs):
-        for jj in range(nElecs):
-            test = np.r_[jj,jj+space,jj+space*2,jj+space*3]
-            if np.any(test >= nElecs):
-                break
-            WENNER = np.r_[WENNER, test]
-        space += 1
-    WENNER = WENNER.reshape((-1,4))
-
-
-    if plotIt:
-        for i, s in enumerate('rbkg'):
-            plt.plot(elocs[WENNER[:,i]],s+'.')
-        plt.show()
-
-    # Create sources and receivers
-    i = 0
-    if in2D:
-        getLoc = lambda ii, abmn: np.r_[elocs[WENNER[ii,abmn]],0]
-    else:
-        getLoc = lambda ii, abmn: np.r_[elocs[WENNER[ii,abmn]],0, 0]
-    srcList = []
-    for i in range(WENNER.shape[0]):
-        rx = DC.RxDipole(getLoc(i,1),getLoc(i,2))
-        src = DC.SrcDipole([rx], getLoc(i,0),getLoc(i,3))
-        srcList += [src]
-
-    return srcList

SimPEG/DCIP/__init__.py

@@ -1,4 +0,0 @@
-from BaseDC import *
-from BaseIP import *
-from DCIPUtils import *
-import Utils

SimPEG/DataMisfit.py

@@ -22,11 +22,11 @@ class BaseDataMisfit(object):
         Utils.setKwargs(self,**kwargs)
 
     @Utils.timeIt
-    def eval(self, m, f=None):
-        """eval(m, f=None)
+    def eval(self, m, u=None):
+        """eval(m, u=None)
 
             :param numpy.array m: geophysical model
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: float
             :return: data misfit
 
@@ -34,11 +34,11 @@ class BaseDataMisfit(object):
         raise NotImplementedError('This method should be overwritten.')
 
     @Utils.timeIt
-    def evalDeriv(self, m, f=None):
-        """evalDeriv(m, f=None)
+    def evalDeriv(self, m, u=None):
+        """evalDeriv(m, u=None)
 
             :param numpy.array m: geophysical model
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: numpy.array
             :return: data misfit derivative
 
@@ -47,18 +47,32 @@ class BaseDataMisfit(object):
 
 
     @Utils.timeIt
-    def eval2Deriv(self, m, v, f=None):
-        """eval2Deriv(m, v, f=None)
+    def eval2Deriv(self, m, v, u=None):
+        """eval2Deriv(m, v, u=None)
 
             :param numpy.array m: geophysical model
             :param numpy.array v: vector to multiply
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: numpy.array
             :return: data misfit derivative
 
         """
         raise NotImplementedError('This method should be overwritten.')
 
+    # TODO: implement target misfit as a property, or possibly as an inversion directive.
+
+    # def target(self, forward):
+    #     """target(forward)
+
+    #         Target for data misfit. By default this is the number of data,
+    #         which satisfies the Discrepancy Principle.
+
+    #         :rtype: float
+    #         :return: data misfit target
+
+    #     """
+    #     prob, survey = self.splitForward(forward)
+    #     return survey.nD
 
 
 class l2_DataMisfit(BaseDataMisfit):
@@ -89,18 +103,10 @@ class l2_DataMisfit(BaseDataMisfit):
         """
 
         if getattr(self, '_Wd', None) is None:
-
+            print 'SimPEG.l2_DataMisfit is creating default weightings for Wd.'
             survey = self.survey
-
-            if getattr(survey,'std', None) is None:
-                print 'SimPEG.DataMisfit.l2_DataMisfit assigning default std of 5%'
-                survey.std = 0.05
-
-            if getattr(survey, 'eps', None) is None:
-                print 'SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||'
-                survey.eps = np.linalg.norm(Utils.mkvc(survey.dobs),2)*1e-5
-
-            self._Wd = Utils.sdiag(1/(abs(survey.dobs)*survey.std+survey.eps))
+            eps = np.linalg.norm(Utils.mkvc(survey.dobs),2)*1e-5
+            self._Wd = Utils.sdiag(1/(abs(survey.dobs)*survey.std+eps))
         return self._Wd
 
     @Wd.setter
@@ -108,20 +114,24 @@ class l2_DataMisfit(BaseDataMisfit):
         self._Wd = value
 
     @Utils.timeIt
-    def eval(self, m, f=None):
-        "eval(m, f=None)"
-        if f is None: f = self.prob.fields(m)
-        R = self.Wd * self.survey.residual(m, f)
+    def eval(self, m, u=None):
+        "eval(m, u=None)"
+        prob   = self.prob
+        survey = self.survey
+        R = self.Wd * survey.residual(m, u=u)
         return 0.5*np.vdot(R, R)
 
     @Utils.timeIt
-    def evalDeriv(self, m, f=None):
-        "evalDeriv(m, f=None)"
-        if f is None: f = self.prob.fields(m)
-        return self.prob.Jtvec(m, self.Wd * (self.Wd * self.survey.residual(m, f=f)), f=f)
+    def evalDeriv(self, m, u=None):
+        "evalDeriv(m, u=None)"
+        prob   = self.prob
+        survey = self.survey
+        if u is None: u = prob.fields(m)
+        return prob.Jtvec(m, self.Wd * (self.Wd * survey.residual(m, u=u)), u=u)
 
     @Utils.timeIt
-    def eval2Deriv(self, m, v, f=None):
-        "eval2Deriv(m, v, f=None)"
-        if f is None: f = self.prob.fields(m)
-        return self.prob.Jtvec_approx(m, self.Wd * (self.Wd * self.prob.Jvec_approx(m, v, f=f)), f=f)
+    def eval2Deriv(self, m, v, u=None):
+        "eval2Deriv(m, v, u=None)"
+        prob   = self.prob
+        if u is None: u = prob.fields(m)
+        return prob.Jtvec_approx(m, self.Wd * (self.Wd * prob.Jvec_approx(m, v, u=u)), u=u)

SimPEG/Directives.py

@@ -123,10 +123,10 @@ class BetaEstimate_ByEig(InversionDirective):
         if self.debug: print 'Calculating the beta0 parameter.'
 
         m = self.invProb.curModel
-        f = self.invProb.getFields(m, store=True, deleteWarmstart=False)
+        u = self.invProb.getFields(m, store=True, deleteWarmstart=False)
 
         x0 = np.random.rand(*m.shape)
-        t = x0.dot(self.dmisfit.eval2Deriv(m,x0,f=f))
+        t = x0.dot(self.dmisfit.eval2Deriv(m,x0,u=u))
         b = x0.dot(self.reg.eval2Deriv(m, v=x0))
         self.beta0 = self.beta0_ratio*(t/b)
 
@@ -149,7 +149,7 @@ class TargetMisfit(InversionDirective):
     @property
     def target(self):
         if getattr(self, '_target', None) is None:
-            self._target = self.survey.nD*0.5
+            self._target = self.survey.nD
         return self._target
     @target.setter
     def target(self, val):
@@ -206,36 +206,7 @@ class SaveOutputEveryIteration(_SaveEveryIteration):
         f.write(' %3d %1.4e %1.4e %1.4e %1.4e\n'%(self.opt.iter, self.invProb.beta, self.invProb.phi_d, self.invProb.phi_m, self.opt.f))
         f.close()
 
-class SaveOutputDictEveryIteration(_SaveEveryIteration):
-    """SaveOutputDictEveryIteration"""
 
-    def initialize(self):
-        print "SimPEG.SaveOutputDictEveryIteration will save your inversion progress as dictionary: '###-%s.npz'"%self.fileName
-
-    def endIter(self):
-        # Save the data.
-        ms = self.reg.Ws * ( self.reg.mapping * (self.invProb.curModel - self.reg.mref) )
-        phi_ms = 0.5*ms.dot(ms)
-        if self.reg.mrefInSmooth == True:
-            mref = self.reg.mref
-        else:
-            mref = 0
-        mx = self.reg.Wx * ( self.reg.mapping * (self.invProb.curModel - mref) )
-        phi_mx = 0.5 * mx.dot(mx)
-        if self.prob.mesh.dim >= 2:
-            my = self.reg.Wy * ( self.reg.mapping * (self.invProb.curModel - mref) )
-            phi_my = 0.5 * my.dot(my)
-        else:
-            phi_my = 'NaN'
-        if self.prob.mesh.dim==3:
-            mz = self.reg.Wz * ( self.reg.mapping * (self.invProb.curModel - mref) )
-            phi_mz = 0.5 * mz.dot(mz)
-        else:
-            phi_mz = 'NaN'
-
-
-        # Save the file as a npz
-        np.savez('{:03d}-{:s}'.format(self.opt.iter,self.fileName), iter=self.opt.iter, beta=self.invProb.beta, phi_d=self.invProb.phi_d, phi_m=self.invProb.phi_m, phi_ms=phi_ms, phi_mx=phi_mx, phi_my=phi_my, phi_mz=phi_mz,f=self.opt.f, m=self.invProb.curModel,dpred=self.invProb.dpred)
 
 
 # class UpdateReferenceModel(Parameter):
@@ -249,112 +220,3 @@ class SaveOutputDictEveryIteration(_SaveEveryIteration):
 #             mref = self.mref0
 #         self.m_prev = self.invProb.m_current
 #         return mref
-
-class Update_IRLS(InversionDirective):
-
-    eps_min = None
-    factor = None
-    gamma = None
-    phi_m_last = None
-    phi_d_last = None
-
-
-    def initialize(self):
-
-        # Scale the regularization for changes in norm
-        if getattr(self, 'phi_m_last', None) is not None:
-
-            self.reg.curModel = self.invProb.curModel
-            self.reg.gamma = 1.
-            phim_new = self.reg.eval(self.invProb.curModel)
-            self.gamma = self.phi_m_last / phim_new
-
-        self.reg.curModel = self.invProb.curModel
-        self.reg.gamma = self.gamma
-
-        if getattr(self, 'phi_d_last', None) is None:
-            self.phi_d_last = self.invProb.phi_d
-
-    def endIter(self):
-        # Cool the threshold parameter if required
-        if getattr(self, 'factor', None) is not None:
-            eps = self.reg.eps / self.factor
-
-            if getattr(self, 'eps_min', None) is not None:
-                self.reg.eps = np.max([self.eps_min,eps])
-            else:
-                self.reg.eps = eps
-
-        # Get phi_m at the end of current iteration
-        self.phi_m_last = self.invProb.phi_m_last
-
-         # Update the model used for the IRLS weights
-        self.reg.curModel = self.invProb.curModel
-
-        # Temporarely set gamma to 1. to get raw phi_m
-        self.reg.gamma = 1.
-
-        # Compute new model objective function value
-        phim_new = self.reg.eval(self.invProb.curModel)
-
-        # Update gamma to scale the regularization between IRLS iterations
-        self.reg.gamma = self.phi_m_last / phim_new
-
-        # Set the weighting matrix to None so that it is recomputed next time
-        # it is called in the inversion
-        self.reg._W = None
-
-class Update_lin_PreCond(InversionDirective):
-
-
-    def endIter(self):
-        # Cool the threshold parameter
-
-        if getattr(self.opt, 'approxHinv', None) is not None:
-            # Update the pre-conditioner
-            diagA = np.sum(self.prob.G**2.,axis=0) + self.invProb.beta*(self.reg.W.T*self.reg.W).diagonal() #* (self.reg.mapping * np.ones(self.reg.curModel.size))**2.
-            PC     = Utils.sdiag(diagA**-1.)
-            self.opt.approxHinv = PC
-
-
-class Update_Wj(InversionDirective):
-    """
-        Create approx-sensitivity base weighting using the probing method
-    """
-    k = None # Number of probing cycles
-    itr = None # Iteration number to update Wj, or always update if None
-
-    def endIter(self):
-
-        if self.itr is None or self.itr == self.opt.iter:
-
-            m = self.invProb.curModel
-            if self.k is None:
-                self.k = int(self.survey.nD/10)
-
-            def JtJv(v):
-
-                Jv = self.prob.Jvec(m, v)
-
-                return self.prob.Jtvec(m,Jv)
-
-            JtJdiag = Utils.diagEst(JtJv,len(m),k=self.k)
-            JtJdiag = JtJdiag / max(JtJdiag)
-
-            self.reg.wght = JtJdiag
-
-class Scale_Beta(InversionDirective):
-    """
-        Instead of a linear cooling schedule, beta is allowed to change based
-        on the ratio between the target misfit and the current data misfit. The
-        update is done only if the misfit is outside some threshold bounds.
-    """
-    tol = 0.05
-
-    def endIter(self):
-
-        # Check if misfit is within the tolerance, otherwise adjust beta
-        val = self.invProb.phi_d / (self.survey.nD*0.5)
-
-        if np.abs(1.-val) > self.tol:
-            self.invProb.beta = self.invProb.beta * self.survey.nD*0.5 / self.invProb.phi_d

SimPEG/Dispatcher.py

@@ -0,0 +1,112 @@
+### PROTOTYPE INTERFACE FOR PARALLEL DISPATCHER ###
+
+from functools import wraps
+
+def synchronize(fn):
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        self = args[0]
+        
+        pr = isinstance(getattr(self, '_dispatcher', None), ParallelDispatcher)
+        if pr:
+            print('Parallel stuff: (start) %(prob)s.%(fn)s'%{'prob': self.__class__.__name__, 'fn': fn.__name__})
+
+        result =  fn(*args, **kwargs)
+        
+        if pr:
+            print('Parallel stuff: ( end ) %(prob)s.%(fn)s'%{'prob': self.__class__.__name__, 'fn': fn.__name__})
+        
+        return result
+
+    return wrapper
+
+
+class BaseDispatcher(object):
+    
+    def __init__(self, *args, **kwargs):
+        print('INIT: Dispatcher!')
+
+    def pair(self, problem):
+        self._prob = problem
+        print('PAIR: Dispatcher setup...')
+
+class SerialDispatcher(BaseDispatcher):
+    
+    def __init__(self, *args, **kwargs):
+        BaseDispatcher.__init__(self, *args, **kwargs)
+        print('INIT: Serial dispatcher...')
+
+class ParallelDispatcher(BaseDispatcher):
+
+    remoteOnly = ['someotherattribute']
+    
+    def __init__(self, *args, **kwargs):
+        BaseDispatcher.__init__(self, *args, **kwargs)
+        print('INIT: Parallel dispatcher...')
+
+    def pair(self, problem):
+        BaseDispatcher.pair(self, problem)
+        print('PAIR: Parallel dispatcher setup...')
+
+    def interceptSetattr(self, prob, name, value):
+        print('SET: Parallel dispatcher set %(prob)s.%(name)s = %(value)r'
+            %{'prob': prob.__class__.__name__, 'name': name, 'value': value})
+
+        if name in self.remoteOnly:
+            print('Setting remote state...')
+        else:
+            raise AttributeError('Set local copy!')
+
+    def interceptGetattr(self, prob, name):
+        print('GET: Parallel dispatcher get %(prob)s.%(name)s'
+            %{'prob': prob.__class__.__name__, 'name': name})
+
+        if name in self.remoteOnly:
+            return '***Value from remote state***'
+        else:
+            raise AttributeError('Attribute %s not in parallel namespace!'%(name,))
+
+class StandinSurvey(object):
+    
+    def pair(self, problem):
+        self._prob = problem
+        
+class StandinProblem(object):
+    
+    def __init__(self):
+        print('INIT: Problem!')
+        self._dispatcher = SerialDispatcher()
+
+    def __setattr__(self, name, value):
+        d = getattr(self, '_dispatcher', None)
+
+        if isinstance(d, ParallelDispatcher):
+            try:
+                d.interceptSetattr(self, name, value)
+            except AttributeError:
+                super(self.__class__, self).__setattr__(name, value)
+            finally:
+                return
+
+        else:
+            super(self.__class__, self).__setattr__(name, value)
+
+    def __getattr__(self, name):
+        d = super(self.__class__, self).__getattribute__('_dispatcher')
+
+        if isinstance(d, ParallelDispatcher):
+            return d.interceptGetattr(self, name)
+    
+    def pair(self, survey, dispatcher=None):
+        
+        self._survey = survey
+        self._survey.pair(self)
+        
+        if dispatcher is not None:
+            self._dispatcher = dispatcher
+            print('PAIR: Problem setup...')
+            self._dispatcher.pair(self)
+    
+    @synchronize
+    def dosomething(self):
+        print('Doing something!')

SimPEG/EM/Analytics/FDEM.py

@@ -1,153 +0,0 @@
-from __future__ import division
-import numpy as np
-from scipy.constants import mu_0, pi
-from scipy.special import erf
-from SimPEG import Utils
-
-
-def hzAnalyticDipoleF(r, freq, sigma, secondary=True, mu=mu_0):
-    """
-    4.56 in Ward and Hohmann
-
-    .. plot::
-
-        import matplotlib.pyplot as plt
-        from SimPEG import EM
-        freq = np.logspace(-1, 6, 61)
-        test = EM.Analytics.FDEM.hzAnalyticDipoleF(100, freq, 0.001, secondary=False)
-        plt.loglog(freq, abs(test.real))
-        plt.loglog(freq, abs(test.imag))
-        plt.title('Response at $r$=100m')
-        plt.xlabel('Frequency')
-        plt.ylabel('Response')
-        plt.legend(('real','imag'))
-        plt.show()
-
-    """
-    r = np.abs(r)
-    k = np.sqrt(-1j*2.*np.pi*freq*mu*sigma)
-
-    m = 1
-    front = m / (2. * np.pi * (k**2) * (r**5) )
-    back = 9 - ( 9 + 9j * k * r - 4 * (k**2) * (r**2) - 1j * (k**3) * (r**3)) * np.exp(-1j*k*r)
-    hz = front*back
-
-    if secondary:
-        hp =-1/(4*np.pi*r**3)
-        hz = hz-hp
-
-    if hz.ndim == 1:
-        hz = Utils.mkvc(hz,2)
-
-    return hz
-
-def MagneticDipoleWholeSpace(XYZ, srcLoc, sig, f, moment=1., orientation='X', mu = mu_0):
-    """
-    Analytical solution for a dipole in a whole-space.
-
-    Equation 2.57 of Ward and Hohmann
-
-    TODOs:
-        - set it up to instead take a mesh & survey
-        - add E-fields
-        - handle multiple frequencies
-        - add divide by zero safety
-
-
-    .. plot::
-
-        from SimPEG import EM
-        import matplotlib.pyplot as plt
-        from scipy.constants import mu_0
-        freqs = np.logspace(-2,5,100)
-        Bx, By, Bz = EM.Analytics.FDEM.MagneticDipoleWholeSpace([0,100,0], [0,0,0], 1e-2, freqs, moment=1, orientation='Z')
-        plt.loglog(freqs, np.abs(Bz.real)/mu_0, 'b')
-        plt.loglog(freqs, np.abs(Bz.imag)/mu_0, 'r')
-        plt.legend(('real','imag'))
-        plt.show()
-
-
-    """
-
-    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
-
-    dx = XYZ[:,0]-srcLoc[0]
-    dy = XYZ[:,1]-srcLoc[1]
-    dz = XYZ[:,2]-srcLoc[2]
-
-    r  = np.sqrt( dx**2. + dy**2. + dz**2.)
-    k  = np.sqrt( -1j*2.*np.pi*f*mu*sig )
-    kr = k*r
-
-    front = moment / (4.*pi * r**3.) * np.exp(-1j*kr)
-    mid   = -kr**2. + 3.*1j*kr + 3.
-
-    if orientation.upper() == 'X':
-        Hx = front*( (dx/r)**2. * mid + (kr**2. - 1j*kr - 1.) )
-        Hy = front*( (dx*dy/r**2.) * mid )
-        Hz = front*( (dx*dz/r**2.) * mid )
-
-    elif orientation.upper() == 'Y':
-        Hx = front*( (dy*dx/r**2.) * mid )
-        Hy = front*( (dy/r)**2. * mid + (kr**2. - 1j*kr - 1.) )
-        Hz = front*( (dy*dz/r**2.) * mid )
-
-    elif orientation.upper() == 'Z':
-        Hx = front*( (dx*dz/r**2.) * mid )
-        Hy = front*( (dy*dz/r**2.) * mid )
-        Hz = front*( (dz/r)**2. * mid + (kr**2. - 1j*kr - 1.) )
-
-    Bx = mu*Hx
-    By = mu*Hy
-    Bz = mu*Hz
-
-    if Bx.ndim is 1:
-        Bx = Utils.mkvc(Bx,2)
-
-    if By.ndim is 1:
-        By = Utils.mkvc(By,2)
-
-    if Bz.ndim is 1:
-        Bz = Utils.mkvc(Bz,2)
-
-    return Bx, By, Bz
-
-
-def ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', mu=mu_0):
-    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
-
-    dx = XYZ[:,0]-srcLoc[0]
-    dy = XYZ[:,1]-srcLoc[1]
-    dz = XYZ[:,2]-srcLoc[2]
-
-    r  = np.sqrt( dx**2. + dy**2. + dz**2.)
-    k  = np.sqrt( -1j*2.*np.pi*f*mu*sig )
-    kr = k*r
-
-    front = current * length / (4. * np.pi * sig * r**3) * np.exp(-1j*k*r)
-    mid   = -k**2 * r**2 + 3*1j*k*r + 3
-
-    # Ex = front*((dx**2 / r**2)*mid + (k**2 * r**2 -1j*k*r))
-    # Ey = front*(dx*dy  / r**2)*mid
-    # Ez = front*(dx*dz  / r**2)*mid
-
-    if orientation.upper() == 'X':
-        Ex = front*((dx**2 / r**2)*mid + (k**2 * r**2 -1j*k*r-1.))
-        Ey = front*(dx*dy  / r**2)*mid
-        Ez = front*(dx*dz  / r**2)*mid
-        return Ex, Ey, Ez
-
-    elif orientation.upper() == 'Y':
-        #  x--> y, y--> z, z-->x
-        Ey = front*((dy**2 / r**2)*mid + (k**2 * r**2 -1j*k*r-1.))
-        Ez = front*(dy*dz  / r**2)*mid
-        Ex = front*(dy*dx  / r**2)*mid
-        return Ex, Ey, Ez
-
-    elif orientation.upper() == 'Z':
-        # x --> z, y --> x, z --> y
-        Ez = front*((dz**2 / r**2)*mid + (k**2 * r**2 -1j*k*r-1.))
-        Ex = front*(dz*dx  / r**2)*mid
-        Ey = front*(dz*dy  / r**2)*mid
-        return Ex, Ey, Ez
-        # return Ey, Ez, Ex

SimPEG/EM/Analytics/FDEMcasing.py

@@ -1,98 +0,0 @@
-from SimPEG import Utils, np
-from scipy.constants import mu_0, epsilon_0
-from SimPEG.EM.Utils.EMUtils import k
-
-def getKc(freq,sigma,a,b,mu=mu_0,eps=epsilon_0):
-    a = float(a)
-    b = float(b)
-    # return 1./(2*np.pi) * np.sqrt(b / a) * np.exp(-1j*k(freq,sigma,mu,eps)*(b-a))
-    return np.sqrt(b / a) * np.exp(-1j*k(freq,sigma,mu,eps)*(b-a))
-
-def _r2(xyz):
-    return np.sum(xyz**2,1)
-
-def _getCasingHertzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    Kc1 = getKc(freq,sigma[1],a,b,mu[1],eps)
-
-    nobs = obsloc.shape[0]
-    dxyz = obsloc - np.c_[np.ones(nobs)]*np.r_[srcloc]
-
-    r2 = _r2(dxyz[:,:2])
-    sqrtr2z2 = np.sqrt(r2 + dxyz[:,2]**2)
-    k2 = k(freq,sigma[2],mu[2],eps)
-
-    return Kc1 * moment / (4.*np.pi) *np.exp(-1j*k2*sqrtr2z2) / sqrtr2z2
-
-
-def _getCasingHertzMagDipoleDeriv_r(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    HertzZ = _getCasingHertzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-    nobs = obsloc.shape[0]
-    dxyz = obsloc - np.c_[np.ones(nobs)]*np.r_[srcloc]
-
-    r2 = _r2(dxyz[:,:2])
-    sqrtr2z2 = np.sqrt(r2 + dxyz[:,2]**2)
-    k2 = k(freq,sigma[2],mu[2],eps)
-
-    return -HertzZ * np.sqrt(r2) / sqrtr2z2 * (1j*k2 + 1./ sqrtr2z2)
-
-
-def _getCasingHertzMagDipoleDeriv_z(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    HertzZ = _getCasingHertzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-    nobs = obsloc.shape[0]
-    dxyz = obsloc - np.c_[np.ones(nobs)]*np.r_[srcloc]
-
-    r2z2 = _r2(dxyz)
-    sqrtr2z2 = np.sqrt(r2z2)
-    k2 = k(freq,sigma[2],mu[2],eps)
-
-    return -HertzZ*dxyz[:,2] /sqrtr2z2 * (1j*k2 + 1./sqrtr2z2)
-
-def _getCasingHertzMagDipole2Deriv_z_r(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    HertzZ = _getCasingHertzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-    dHertzZdr = _getCasingHertzMagDipoleDeriv_r(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-    nobs = obsloc.shape[0]
-    dxyz = obsloc - np.c_[np.ones(nobs)]*np.r_[srcloc]
-
-    r2 = _r2(dxyz[:,:2])
-    r = np.sqrt(r2)
-    z = dxyz[:,2]
-    sqrtr2z2 = np.sqrt(r2 + z**2)
-    k2 = k(freq,sigma[2],mu[2],eps)
-
-    return dHertzZdr*(-z/sqrtr2z2)*(1j*k2+1./sqrtr2z2) + HertzZ*(z*r/sqrtr2z2**3)*(1j*k2 + 2./sqrtr2z2)
-
-def _getCasingHertzMagDipole2Deriv_z_z(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    HertzZ = _getCasingHertzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-    dHertzZdz = _getCasingHertzMagDipoleDeriv_z(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-    nobs = obsloc.shape[0]
-    dxyz = obsloc - np.c_[np.ones(nobs)]*np.r_[srcloc]
-
-    r2 = _r2(dxyz[:,:2])
-    r = np.sqrt(r2)
-    z = dxyz[:,2]
-    sqrtr2z2 = np.sqrt(r2 + z**2)
-    k2 = k(freq,sigma[2],mu[2],eps)
-
-    return (dHertzZdz*z + HertzZ)/sqrtr2z2*(-1j*k2 - 1./sqrtr2z2) + HertzZ*z/sqrtr2z2**3*(1j*k2*z + 2.*z/sqrtr2z2)
-
-def getCasingEphiMagDipole(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    return 1j * omega(freq) * mu * _getCasingHertzMagDipoleDeriv_r(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-def getCasingHrMagDipole(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    return _getCasingHertzMagDipole2Deriv_z_r(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-def getCasingHzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    d2HertzZdz2 = _getCasingHertzMagDipole2Deriv_z_z(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-    k2 = k(freq,sigma[2],mu[2],eps)
-    HertzZ = _getCasingHertzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-    return d2HertzZdz2 + k2**2 * HertzZ
-
-def getCasingBrMagDipole(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    return mu_0 * getCasingHrMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)
-
-def getCasingBzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu=mu_0*np.ones(3),eps=epsilon_0,moment=1.):
-    return mu_0 * getCasingHzMagDipole(srcloc,obsloc,freq,sigma,a,b,mu,eps,moment)

SimPEG/EM/Analytics/TDEM.py

@@ -1,12 +0,0 @@
-import numpy as np
-from scipy.constants import mu_0, pi
-from scipy.special import erf
-
-def hzAnalyticDipoleT(r, t, sigma):
-    theta = np.sqrt((sigma*mu_0)/(4*t))
-    tr = theta*r
-    etr = erf(tr)
-    t1 = (9/(2*tr**2) - 1)*etr
-    t2 = (1/np.sqrt(pi))*(9/tr + 4*tr)*np.exp(-tr**2)
-    hz = (t1 - t2)/(4*pi*r**3)
-    return hz

SimPEG/EM/Analytics/__init__.py

@@ -1,3 +0,0 @@
-from TDEM import hzAnalyticDipoleT
-from FDEM import hzAnalyticDipoleF
-from FDEMcasing import *

SimPEG/EM/Base.py

@@ -1,209 +0,0 @@
-from SimPEG import Survey, Problem, Utils, Models, Maps, PropMaps, np, sp, Solver as SimpegSolver
-from scipy.constants import mu_0
-
-class EMPropMap(Maps.PropMap):
-    """
-        Property Map for EM Problems. The electrical conductivity (\\(\\sigma\\)) is the default inversion property, and the default value of the magnetic permeability is that of free space (\\(\\mu = 4\\pi\\times 10^{-7} \\) H/m)
-    """
-
-    sigma = Maps.Property("Electrical Conductivity", defaultInvProp = True, propertyLink=('rho',Maps.ReciprocalMap))
-    mu = Maps.Property("Inverse Magnetic Permeability", defaultVal = mu_0, propertyLink=('mui',Maps.ReciprocalMap))
-
-    rho = Maps.Property("Electrical Resistivity", propertyLink=('sigma', Maps.ReciprocalMap))
-    mui = Maps.Property("Inverse Magnetic Permeability", defaultVal = 1./mu_0, propertyLink=('mu', Maps.ReciprocalMap))
-
-
-class BaseEMProblem(Problem.BaseProblem):
-
-    def __init__(self, mesh, **kwargs):
-        Problem.BaseProblem.__init__(self, mesh, **kwargs)
-
-
-    surveyPair = Survey.BaseSurvey
-    dataPair = Survey.Data
-
-    PropMap = EMPropMap
-
-    Solver = SimpegSolver
-    solverOpts = {}
-
-    verbose = False
-
-    ####################################################
-    # Make A Symmetric
-    ####################################################
-    @property
-    def _makeASymmetric(self):
-        if getattr(self, '__makeASymmetric', None) is None:
-            self.__makeASymmetric = True
-        return self.__makeASymmetric
-
-
-    ####################################################
-    # Mass Matrices
-    ####################################################
-
-    @property
-    def deleteTheseOnModelUpdate(self):
-        toDelete = []
-        if self.mapping.sigmaMap is not None or self.mapping.rhoMap is not None:
-            toDelete += ['_MeSigma', '_MeSigmaI','_MfRho','_MfRhoI']
-        if self.mapping.muMap is not None or self.mapping.muiMap is not None:
-            toDelete += ['_MeMu', '_MeMuI','_MfMui','_MfMuiI']
-        return toDelete
-
-    @property
-    def Me(self):
-        """
-            Edge inner product matrix
-        """
-        if getattr(self, '_Me', None) is None:
-            self._Me = self.mesh.getEdgeInnerProduct()
-        return self._Me
-
-    @property
-    def Mf(self):
-        """
-            Face inner product matrix
-        """
-        if getattr(self, '_Mf', None) is None:
-            self._Mf = self.mesh.getFaceInnerProduct()
-        return self._Mf
-
-
-    # ----- Magnetic Permeability ----- #
-    @property
-    def MfMui(self):
-        """
-            Face inner product matrix for \\(\\mu^{-1}\\). Used in the E-B formulation
-        """
-        if getattr(self, '_MfMui', None) is None:
-            self._MfMui = self.mesh.getFaceInnerProduct(self.curModel.mui)
-        return self._MfMui
-
-    @property
-    def MfMuiI(self):
-        """
-            Inverse of :code:`MfMui`.
-        """
-        if getattr(self, '_MfMuiI', None) is None:
-            self._MfMuiI = self.mesh.getFaceInnerProduct(self.curModel.mui, invMat=True)
-        return self._MfMuiI
-
-    @property
-    def MeMu(self):
-        """
-            Edge inner product matrix for \\(\\mu\\). Used in the H-J formulation
-        """
-        if getattr(self, '_MeMu', None) is None:
-            self._MeMu = self.mesh.getEdgeInnerProduct(self.curModel.mu)
-        return self._MeMu
-
-    @property
-    def MeMuI(self):
-        """
-            Inverse of :code:`MeMu`
-        """
-        if getattr(self, '_MeMuI', None) is None:
-            self._MeMuI = self.mesh.getEdgeInnerProduct(self.curModel.mu, invMat=True)
-        return self._MeMuI
-
-
-    # ----- Electrical Conductivity ----- #
-    #TODO: hardcoded to sigma as the model
-    @property
-    def MeSigma(self):
-        """
-            Edge inner product matrix for \\(\\sigma\\). Used in the E-B formulation
-        """
-        if getattr(self, '_MeSigma', None) is None:
-            self._MeSigma = self.mesh.getEdgeInnerProduct(self.curModel.sigma)
-        return self._MeSigma
-
-    # TODO: This should take a vector
-    def MeSigmaDeriv(self, u):
-        """
-            Derivative of MeSigma with respect to the model
-        """
-        return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u) * self.curModel.sigmaDeriv
-
-
-    @property
-    def MeSigmaI(self):
-        """
-            Inverse of the edge inner product matrix for \\(\\sigma\\).
-        """
-        if getattr(self, '_MeSigmaI', None) is None:
-            self._MeSigmaI = self.mesh.getEdgeInnerProduct(self.curModel.sigma, invMat=True)
-        return self._MeSigmaI
-
-    # TODO: This should take a vector
-    def MeSigmaIDeriv(self, u):
-        """
-            Derivative of :code:`MeSigma` with respect to the model
-        """
-        # TODO: only works for diagonal tensors. getEdgeInnerProductDeriv, invMat=True should be implemented in SimPEG
-
-        dMeSigmaI_dI = -self.MeSigmaI**2
-        dMe_dsig = self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u)
-        dsig_dm = self.curModel.sigmaDeriv
-        return dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm))
-        # return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma, invMat=True)(u)
-
-
-    @property
-    def MfRho(self):
-        """
-            Face inner product matrix for \\(\\rho\\). Used in the H-J formulation
-        """
-        if getattr(self, '_MfRho', None) is None:
-            self._MfRho = self.mesh.getFaceInnerProduct(self.curModel.rho)
-        return self._MfRho
-
-    # TODO: This should take a vector
-    def MfRhoDeriv(self,u):
-        """
-            Derivative of :code:`MfRho` with respect to the model.
-        """
-        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u) * (-Utils.sdiag(self.curModel.rho**2) * self.curModel.sigmaDeriv)
-        # self.curModel.rhoDeriv
-
-    @property
-    def MfRhoI(self):
-        """
-            Inverse of :code:`MfRho`
-        """
-        if getattr(self, '_MfRhoI', None) is None:
-            self._MfRhoI = self.mesh.getFaceInnerProduct(self.curModel.rho, invMat=True)
-        return self._MfRhoI
-
-    # TODO: This isn't going to work yet
-    # TODO: This should take a vector
-    def MfRhoIDeriv(self,u):
-        """
-            Derivative of :code:`MfRhoI` with respect to the model.
-        """
-        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho, invMat=True)(u) * self.curModel.rhoDeriv
-
-class BaseEMSurvey(Survey.BaseSurvey):
-
-    def __init__(self, srcList, **kwargs):
-        # Sort these by frequency
-        self.srcList = srcList
-        Survey.BaseSurvey.__init__(self, **kwargs)
-
-    def eval(self, u):
-        """
-        Project fields to receiver locations
-        :param Fields u: fields object
-        :rtype: numpy.ndarray
-        :return: data
-        """
-        data = Survey.Data(self)
-        for src in self.srcList:
-            for rx in src.rxList:
-                data[src, rx] = rx.eval(src, self.mesh, u)
-        return data
-
-    def evalDeriv(self, u):
-        raise Exception('Use Receivers to project fields deriv.')

SimPEG/EM/FDEM/FDEM.py

@@ -1,689 +0,0 @@
-from SimPEG import Problem, Utils, np, sp, Solver as SimpegSolver
-from scipy.constants import mu_0
-from SurveyFDEM import Survey as SurveyFDEM
-from FieldsFDEM import Fields, Fields_e, Fields_b, Fields_h, Fields_j
-from SimPEG.EM.Base import BaseEMProblem
-from SimPEG.EM.Utils import omega
-
-
-class BaseFDEMProblem(BaseEMProblem):
-    """
-        We start by looking at Maxwell's equations in the electric
-        field \\\(\\\mathbf{e}\\\) and the magnetic flux
-        density \\\(\\\mathbf{b}\\\)
-
-        .. math ::
-
-            \mathbf{C} \mathbf{e} + i \omega \mathbf{b} = \mathbf{s_m} \\\\
-            {\mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e} \mathbf{e} = \mathbf{s_e}}
-
-        if using the E-B formulation (:code:`Problem_e`
-        or :code:`Problem_b`). Note that in this case, :math:`\mathbf{s_e}` is an integrated quantity.
-
-        If we write Maxwell's equations in terms of
-        \\\(\\\mathbf{h}\\\) and current density \\\(\\\mathbf{j}\\\)
-
-        .. math ::
-
-            \mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{j} + i \omega \mathbf{M_{\mu}^e} \mathbf{h} = \mathbf{s_m} \\\\
-            \mathbf{C} \mathbf{h} - \mathbf{j} = \mathbf{s_e}
-
-        if using the H-J formulation (:code:`Problem_j` or :code:`Problem_h`). Note that here, :math:`\mathbf{s_m}` is an integrated quantity.
-
-        The problem performs the elimination so that we are solving the system for \\\(\\\mathbf{e},\\\mathbf{b},\\\mathbf{j} \\\) or \\\(\\\mathbf{h}\\\)
-    """
-
-    surveyPair = SurveyFDEM
-    fieldsPair = Fields
-
-    def fields(self, m):
-        """
-        Solve the forward problem for the fields.
-
-        :param numpy.array m: inversion model (nP,)
-        :rtype numpy.array:
-        :return f: forward solution
-        """
-
-        self.curModel = m
-        f = self.fieldsPair(self.mesh, self.survey)
-
-        for freq in self.survey.freqs:
-            A = self.getA(freq)
-            rhs = self.getRHS(freq)
-            Ainv = self.Solver(A, **self.solverOpts)
-            u = Ainv * rhs
-            Srcs = self.survey.getSrcByFreq(freq)
-            f[Srcs, self._solutionType] = u
-            Ainv.clean()
-        return f
-
-    def Jvec(self, m, v, f=None):
-        """
-        Sensitivity times a vector.
-
-        :param numpy.array m: inversion model (nP,)
-        :param numpy.array v: vector which we take sensitivity product with (nP,)
-        :param SimPEG.EM.FDEM.Fields u: fields object
-        :rtype numpy.array:
-        :return: Jv (ndata,)
-        """
-
-        if f is None:
-           f = self.fields(m)
-
-        self.curModel = m
-
-        Jv = self.dataPair(self.survey)
-
-        for freq in self.survey.freqs:
-            A = self.getA(freq)
-            Ainv = self.Solver(A, **self.solverOpts) # create the concept of Ainv (actually a solve)
-
-            for src in self.survey.getSrcByFreq(freq):
-                u_src = f[src, self._solutionType]
-                dA_dm_v = self.getADeriv(freq, u_src, v)
-                dRHS_dm_v = self.getRHSDeriv(freq, src, v)
-                du_dm_v = Ainv * ( - dA_dm_v + dRHS_dm_v )
-
-                for rx in src.rxList:
-                    df_dmFun = getattr(f, '_%sDeriv'%rx.projField, None)
-                    df_dm_v = df_dmFun(src, du_dm_v, v, adjoint=False)
-                    Jv[src, rx] = rx.evalDeriv(src, self.mesh, f, df_dm_v)
-            Ainv.clean()
-        return Utils.mkvc(Jv)
-
-    def Jtvec(self, m, v, f=None):
-        """
-        Sensitivity transpose times a vector
-
-        :param numpy.array m: inversion model (nP,)
-        :param numpy.array v: vector which we take adjoint product with (nP,)
-        :param SimPEG.EM.FDEM.Fields u: fields object
-        :rtype numpy.array:
-        :return: Jv (ndata,)
-        """
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-
-        # Ensure v is a data object.
-        if not isinstance(v, self.dataPair):
-            v = self.dataPair(self.survey, v)
-
-        Jtv = np.zeros(m.size)
-
-        for freq in self.survey.freqs:
-            AT = self.getA(freq).T
-            ATinv = self.Solver(AT, **self.solverOpts)
-
-            for src in self.survey.getSrcByFreq(freq):
-                u_src = f[src, self._solutionType]
-
-                for rx in src.rxList:
-                    PTv = rx.evalDeriv(src, self.mesh, f, v[src, rx], adjoint=True) # wrt f, need possibility wrt m
-
-                    df_duTFun = getattr(f, '_%sDeriv'%rx.projField, None)
-                    df_duT, df_dmT = df_duTFun(src, None, PTv, adjoint=True)
-
-                    ATinvdf_duT = ATinv * df_duT
-
-                    dA_dmT = self.getADeriv(freq, u_src, ATinvdf_duT, adjoint=True)
-                    dRHS_dmT = self.getRHSDeriv(freq, src, ATinvdf_duT, adjoint=True)
-                    du_dmT = -dA_dmT + dRHS_dmT
-
-                    df_dmT = df_dmT + du_dmT
-
-                    # TODO: this should be taken care of by the reciever?
-                    real_or_imag = rx.projComp
-                    if real_or_imag is 'real':
-                        Jtv +=   np.array(df_dmT, dtype=complex).real
-                    elif real_or_imag is 'imag':
-                        Jtv += - np.array(df_dmT, dtype=complex).real
-                    else:
-                        raise Exception('Must be real or imag')
-
-            ATinv.clean()
-
-        return Utils.mkvc(Jtv)
-
-    def getSourceTerm(self, freq):
-        """
-        Evaluates the sources for a given frequency and puts them in matrix form
-
-        :param float freq: Frequency
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: s_m, s_e (nE or nF, nSrc)
-        """
-        Srcs = self.survey.getSrcByFreq(freq)
-        if self._formulation is 'EB':
-            s_m = np.zeros((self.mesh.nF,len(Srcs)), dtype=complex)
-            s_e = np.zeros((self.mesh.nE,len(Srcs)), dtype=complex)
-        elif self._formulation is 'HJ':
-            s_m = np.zeros((self.mesh.nE,len(Srcs)), dtype=complex)
-            s_e = np.zeros((self.mesh.nF,len(Srcs)), dtype=complex)
-
-        for i, src in enumerate(Srcs):
-            smi, sei = src.eval(self)
-            s_m[:,i] = s_m[:,i] + smi
-            s_e[:,i] = s_e[:,i] + sei
-
-        return s_m, s_e
-
-
-##########################################################################################
-################################ E-B Formulation #########################################
-##########################################################################################
-
-class Problem_e(BaseFDEMProblem):
-    """
-    By eliminating the magnetic flux density using
-
-        .. math ::
-
-            \mathbf{b} = \\frac{1}{i \omega}\\left(-\mathbf{C} \mathbf{e} + \mathbf{s_m}\\right)
-
-
-    we can write Maxwell's equations as a second order system in \\\(\\\mathbf{e}\\\) only:
-
-    .. math ::
-
-        \\left(\mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{C}+ i \omega \mathbf{M^e_{\sigma}} \\right)\mathbf{e} = \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f}\mathbf{s_m} -i\omega\mathbf{M^e}\mathbf{s_e}
-
-    which we solve for :math:`\mathbf{e}`.
-
-    :param SimPEG.Mesh mesh: mesh
-    """
-
-    _solutionType = 'eSolution'
-    _formulation  = 'EB'
-    fieldsPair    = Fields_e
-
-    def __init__(self, mesh, **kwargs):
-        BaseFDEMProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self, freq):
-        """
-        System matrix
-
-        .. math ::
-            \mathbf{A} = \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{C} + i \omega \mathbf{M^e_{\sigma}}
-
-        :param float freq: Frequency
-        :rtype: scipy.sparse.csr_matrix
-        :return: A
-        """
-
-        MfMui = self.MfMui
-        MeSigma = self.MeSigma
-        C = self.mesh.edgeCurl
-
-        return C.T*MfMui*C + 1j*omega(freq)*MeSigma
-
-
-    def getADeriv(self, freq, u, v, adjoint=False):
-        """
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        .. math ::
-            \\frac{\mathbf{A}(\mathbf{m}) \mathbf{v}}{d \mathbf{m}} = i \omega \\frac{d \mathbf{M^e_{\sigma}}\mathbf{v} }{d\mathbf{m}}
-
-        :param float freq: frequency
-        :param numpy.ndarray u: solution vector (nE,)
-        :param numpy.ndarray v: vector to take prodct with (nP,) or (nD,) for adjoint
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: derivative of the system matrix times a vector (nP,) or adjoint (nD,)
-        """
-
-        dsig_dm = self.curModel.sigmaDeriv
-        dMe_dsig = self.MeSigmaDeriv(u)
-
-        if adjoint:
-            return 1j * omega(freq) * ( dMe_dsig.T * v )
-
-        return 1j * omega(freq) * ( dMe_dsig * v )
-
-    def getRHS(self, freq):
-        """
-        Right hand side for the system
-
-        .. math ::
-            \mathbf{RHS} = \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f}\mathbf{s_m} -i\omega\mathbf{M_e}\mathbf{s_e}
-
-        :param float freq: Frequency
-        :rtype: numpy.ndarray
-        :return: RHS (nE, nSrc)
-        """
-
-        s_m, s_e = self.getSourceTerm(freq)
-        C = self.mesh.edgeCurl
-        MfMui = self.MfMui
-
-        return C.T * (MfMui * s_m) -1j * omega(freq) * s_e
-
-    def getRHSDeriv(self, freq, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-
-        :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: product of rhs deriv with a vector
-        """
-
-        C = self.mesh.edgeCurl
-        MfMui = self.MfMui
-        s_mDeriv, s_eDeriv = src.evalDeriv(self, adjoint=adjoint)
-
-        if adjoint:
-            dRHS = MfMui * (C * v)
-            return s_mDeriv(dRHS) - 1j * omega(freq) * s_eDeriv(v)
-
-        else:
-            return C.T * (MfMui * s_mDeriv(v)) -1j * omega(freq) * s_eDeriv(v)
-
-
-class Problem_b(BaseFDEMProblem):
-    """
-    We eliminate :math:`\mathbf{e}` using
-
-    .. math ::
-
-         \mathbf{e} = \mathbf{M^e_{\sigma}}^{-1} \\left(\mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{s_e}\\right)
-
-    and solve for :math:`\mathbf{b}` using:
-
-    .. math ::
-
-        \\left(\mathbf{C} \mathbf{M^e_{\sigma}}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f}  + i \omega \\right)\mathbf{b} = \mathbf{s_m} + \mathbf{M^e_{\sigma}}^{-1}\mathbf{M^e}\mathbf{s_e}
-
-    .. note ::
-        The inverse problem will not work with full anisotropy
-
-    :param SimPEG.Mesh mesh: mesh
-    """
-
-    _solutionType = 'bSolution'
-    _formulation  = 'EB'
-    fieldsPair    = Fields_b
-
-    def __init__(self, mesh, **kwargs):
-        BaseFDEMProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self, freq):
-        """
-        System matrix
-
-        .. math ::
-            \mathbf{A} = \mathbf{C} \mathbf{M^e_{\sigma}}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f}  + i \omega
-
-        :param float freq: Frequency
-        :rtype: scipy.sparse.csr_matrix
-        :return: A
-        """
-
-        MfMui = self.MfMui
-        MeSigmaI = self.MeSigmaI
-        C = self.mesh.edgeCurl
-        iomega = 1j * omega(freq) * sp.eye(self.mesh.nF)
-
-        A = C * (MeSigmaI * (C.T * MfMui)) + iomega
-
-        if self._makeASymmetric is True:
-            return MfMui.T*A
-        return A
-
-    def getADeriv(self, freq, u, v, adjoint=False):
-
-        """
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        .. math ::
-            \\frac{\mathbf{A}(\mathbf{m}) \mathbf{v}}{d \mathbf{m}} = \mathbf{C} \\frac{\mathbf{M^e_{\sigma}} \mathbf{v}}{d\mathbf{m}}
-
-        :param float freq: frequency
-        :param numpy.ndarray u: solution vector (nF,)
-        :param numpy.ndarray v: vector to take prodct with (nP,) or (nD,) for adjoint
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: derivative of the system matrix times a vector (nP,) or adjoint (nD,)
-        """
-
-        MfMui = self.MfMui
-        C = self.mesh.edgeCurl
-        MeSigmaIDeriv = self.MeSigmaIDeriv
-        vec = C.T * (MfMui * u)
-
-        MeSigmaIDeriv = MeSigmaIDeriv(vec)
-
-        if adjoint:
-            if self._makeASymmetric is True:
-                v = MfMui * v
-            return MeSigmaIDeriv.T * (C.T * v)
-
-        if self._makeASymmetric is True:
-            return MfMui.T * ( C * ( MeSigmaIDeriv * v ) )
-        return C * ( MeSigmaIDeriv * v )
-
-
-    def getRHS(self, freq):
-        """
-        Right hand side for the system
-
-        .. math ::
-            \mathbf{RHS} = \mathbf{s_m} + \mathbf{M^e_{\sigma}}^{-1}\mathbf{s_e}
-
-        :param float freq: Frequency
-        :rtype: numpy.ndarray
-        :return: RHS (nE, nSrc)
-        """
-
-        s_m, s_e = self.getSourceTerm(freq)
-        C = self.mesh.edgeCurl
-        MeSigmaI = self.MeSigmaI
-
-        RHS = s_m + C * ( MeSigmaI * s_e )
-
-        if self._makeASymmetric is True:
-            MfMui = self.MfMui
-            return MfMui.T * RHS
-
-        return RHS
-
-    def getRHSDeriv(self, freq, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-
-        :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: product of rhs deriv with a vector
-        """
-
-        C = self.mesh.edgeCurl
-        s_m, s_e = src.eval(self)
-        MfMui = self.MfMui
-
-        if self._makeASymmetric and adjoint:
-            v = self.MfMui * v
-
-        MeSigmaIDeriv = self.MeSigmaIDeriv(s_e)
-        s_mDeriv, s_eDeriv = src.evalDeriv(self, adjoint=adjoint)
-
-        if not adjoint:
-            RHSderiv = C * (MeSigmaIDeriv * v)
-            SrcDeriv = s_mDeriv(v) + C * (self.MeSigmaI * s_eDeriv(v))
-        elif adjoint:
-            RHSderiv = MeSigmaIDeriv.T * (C.T * v)
-            SrcDeriv = s_mDeriv(v) + self.MeSigmaI.T * (C.T * s_eDeriv(v))
-
-        if self._makeASymmetric is True and not adjoint:
-            return MfMui.T * (SrcDeriv + RHSderiv)
-
-        return RHSderiv + SrcDeriv
-
-
-
-##########################################################################################
-################################ H-J Formulation #########################################
-##########################################################################################
-
-
-class Problem_j(BaseFDEMProblem):
-    """
-    We eliminate \\\(\\\mathbf{h}\\\) using
-
-    .. math ::
-
-        \mathbf{h} = \\frac{1}{i \omega} \mathbf{M_{\mu}^e}^{-1} \\left(-\mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{j}  + \mathbf{M^e} \mathbf{s_m} \\right)
-
-    and solve for \\\(\\\mathbf{j}\\\) using
-
-    .. math ::
-
-        \\left(\mathbf{C} \mathbf{M_{\mu}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} + i \omega\\right)\mathbf{j} = \mathbf{C} \mathbf{M_{\mu}^e}^{-1} \mathbf{M^e} \mathbf{s_m} -i\omega\mathbf{s_e}
-
-    .. note::
-        This implementation does not yet work with full anisotropy!!
-
-    :param SimPEG.Mesh mesh: mesh
-    """
-
-    _solutionType = 'jSolution'
-    _formulation  = 'HJ'
-    fieldsPair    = Fields_j
-
-    def __init__(self, mesh, **kwargs):
-        BaseFDEMProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self, freq):
-        """
-        System matrix
-
-        .. math ::
-                \\mathbf{A} = \\mathbf{C}  \\mathbf{M^e_{\\mu^{-1}}} \\mathbf{C}^{\\top} \\mathbf{M^f_{\\sigma^{-1}}}  + i\\omega
-
-        :param float freq: Frequency
-        :rtype: scipy.sparse.csr_matrix
-        :return: A
-        """
-
-        MeMuI = self.MeMuI
-        MfRho = self.MfRho
-        C = self.mesh.edgeCurl
-        iomega = 1j * omega(freq) * sp.eye(self.mesh.nF)
-
-        A = C * MeMuI * C.T * MfRho + iomega
-
-        if self._makeASymmetric is True:
-            return MfRho.T*A
-        return A
-
-
-    def getADeriv(self, freq, u, v, adjoint=False):
-        """
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        In this case, we assume that electrical conductivity, :math:`\sigma` is the physical property of interest (i.e. :math:`\sigma` = model.transform). Then we want
-
-        .. math ::
-
-            \\frac{\mathbf{A(\sigma)} \mathbf{v}}{d \mathbf{m}} = \mathbf{C}  \mathbf{M^e_{mu^{-1}}} \mathbf{C^{\\top}} \\frac{d \mathbf{M^f_{\sigma^{-1}}}\mathbf{v} }{d \mathbf{m}}
-
-        :param float freq: frequency
-        :param numpy.ndarray u: solution vector (nF,)
-        :param numpy.ndarray v: vector to take prodct with (nP,) or (nD,) for adjoint
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: derivative of the system matrix times a vector (nP,) or adjoint (nD,)
-        """
-
-        MeMuI = self.MeMuI
-        MfRho = self.MfRho
-        C = self.mesh.edgeCurl
-        MfRhoDeriv = self.MfRhoDeriv(u)
-
-        if adjoint:
-            if self._makeASymmetric is True:
-                v = MfRho * v
-            return MfRhoDeriv.T * (C * (MeMuI.T * (C.T * v)))
-
-        if self._makeASymmetric is True:
-            return MfRho.T * (C * ( MeMuI * (C.T * (MfRhoDeriv * v) )))
-        return C * (MeMuI * (C.T * (MfRhoDeriv * v)))
-
-
-    def getRHS(self, freq):
-        """
-        Right hand side for the system
-
-        .. math ::
-
-            \mathbf{RHS} = \mathbf{C} \mathbf{M_{\mu}^e}^{-1}\mathbf{s_m} -i\omega \mathbf{s_e}
-
-        :param float freq: Frequency
-        :rtype: numpy.ndarray (nE, nSrc)
-        :return: RHS
-        """
-
-        s_m, s_e = self.getSourceTerm(freq)
-        C = self.mesh.edgeCurl
-        MeMuI = self.MeMuI
-
-        RHS = C * (MeMuI * s_m) - 1j * omega(freq) * s_e
-        if self._makeASymmetric is True:
-            MfRho = self.MfRho
-            return MfRho.T*RHS
-
-        return RHS
-
-    def getRHSDeriv(self, freq, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-
-        :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: product of rhs deriv with a vector
-        """
-
-        C = self.mesh.edgeCurl
-        MeMuI = self.MeMuI
-        s_mDeriv, s_eDeriv = src.evalDeriv(self, adjoint=adjoint)
-
-        if adjoint:
-            if self._makeASymmetric:
-                MfRho = self.MfRho
-                v = MfRho*v
-            return s_mDeriv(MeMuI.T * (C.T * v)) - 1j * omega(freq) * s_eDeriv(v)
-
-        else:
-            RHSDeriv = C * (MeMuI * s_mDeriv(v)) - 1j * omega(freq) * s_eDeriv(v)
-
-            if self._makeASymmetric:
-                MfRho = self.MfRho
-                return MfRho.T * RHSDeriv
-            return RHSDeriv
-
-
-
-
-class Problem_h(BaseFDEMProblem):
-    """
-    We eliminate \\\(\\\mathbf{j}\\\) using
-
-    .. math ::
-
-        \mathbf{j} = \mathbf{C} \mathbf{h} - \mathbf{s_e}
-
-    and solve for \\\(\\\mathbf{h}\\\) using
-
-    .. math ::
-
-        \\left(\mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{C} + i \omega \mathbf{M_{\mu}^e}\\right) \mathbf{h} = \mathbf{M^e} \mathbf{s_m} + \mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{s_e}
-
-    :param SimPEG.Mesh mesh: mesh
-    """
-
-    _solutionType = 'hSolution'
-    _formulation  = 'HJ'
-    fieldsPair    = Fields_h
-
-    def __init__(self, mesh, **kwargs):
-        BaseFDEMProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self, freq):
-        """
-        System matrix
-
-        .. math::
-            \mathbf{A} = \mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{C} + i \omega \mathbf{M_{\mu}^e}
-
-        :param float freq: Frequency
-        :rtype: scipy.sparse.csr_matrix
-        :return: A
-        """
-
-        MeMu = self.MeMu
-        MfRho = self.MfRho
-        C = self.mesh.edgeCurl
-
-        return C.T * (MfRho * C) + 1j*omega(freq)*MeMu
-
-    def getADeriv(self, freq, u, v, adjoint=False):
-        """
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        .. math::
-            \\frac{\mathbf{A}(\mathbf{m}) \mathbf{v}}{d \mathbf{m}} = \mathbf{C}^{\\top}\\frac{d \mathbf{M^f_{\\rho}}\mathbf{v} }{d\mathbf{m}}
-
-        :param float freq: frequency
-        :param numpy.ndarray u: solution vector (nE,)
-        :param numpy.ndarray v: vector to take prodct with (nP,) or (nD,) for adjoint
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: derivative of the system matrix times a vector (nP,) or adjoint (nD,)
-        """
-
-        MeMu = self.MeMu
-        C = self.mesh.edgeCurl
-        MfRhoDeriv = self.MfRhoDeriv(C*u)
-
-        if adjoint:
-            return MfRhoDeriv.T * (C * v)
-        return C.T * (MfRhoDeriv * v)
-
-    def getRHS(self, freq):
-        """
-        Right hand side for the system
-
-        .. math ::
-
-            \mathbf{RHS} = \mathbf{M^e} \mathbf{s_m} + \mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{s_e}
-
-        :param float freq: Frequency
-        :rtype: numpy.ndarray
-        :return: RHS (nE, nSrc)
-        """
-
-        s_m, s_e = self.getSourceTerm(freq)
-        C = self.mesh.edgeCurl
-        MfRho  = self.MfRho
-
-        return s_m + C.T * ( MfRho * s_e )
-
-    def getRHSDeriv(self, freq, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-
-        :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: product of rhs deriv with a vector
-        """
-
-        _, s_e = src.eval(self)
-        C = self.mesh.edgeCurl
-        MfRho  = self.MfRho
-
-        MfRhoDeriv = self.MfRhoDeriv(s_e)
-        if not adjoint:
-            RHSDeriv = C.T * (MfRhoDeriv * v)
-        elif adjoint:
-            RHSDeriv = MfRhoDeriv.T * (C * v)
-
-        s_mDeriv, s_eDeriv = src.evalDeriv(self, adjoint=adjoint)
-
-        return RHSDeriv + s_mDeriv(v) + C.T * (MfRho * s_eDeriv(v))
-

SimPEG/EM/FDEM/SrcFDEM.py

@@ -1,609 +0,0 @@
-from SimPEG import Survey, Problem, Utils, np, sp
-from scipy.constants import mu_0
-from SimPEG.EM.Utils import *
-from SimPEG.Utils import Zero
-
-class BaseSrc(Survey.BaseSrc):
-    """
-    Base source class for FDEM Survey
-    """
-
-    freq = None
-    # rxPair = RxFDEM
-    integrate = True
-
-    def eval(self, prob):
-        """
-        Evaluate the source terms.
-        - :math:`s_m` : magnetic source term
-        - :math:`s_e` : electric source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: tuple with magnetic source term and electric source term
-        """
-        s_m = self.s_m(prob)
-        s_e = self.s_e(prob)
-        return s_m, s_e
-
-    def evalDeriv(self, prob, v=None, adjoint=False):
-        """
-        Derivatives of the source terms with respect to the inversion model
-        - :code:`s_mDeriv` : derivative of the magnetic source term
-        - :code:`s_eDeriv` : derivative of the electric source term
-
-        :param Problem prob: FDEM Problem
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: tuple with magnetic source term and electric source term derivatives times a vector
-        """
-        if v is not None:
-            return self.s_mDeriv(prob, v, adjoint), self.s_eDeriv(prob, v, adjoint)
-        else:
-            return lambda v: self.s_mDeriv(prob, v, adjoint), lambda v: self.s_eDeriv(prob, v, adjoint)
-
-    def bPrimary(self, prob):
-        """
-        Primary magnetic flux density
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic flux density
-        """
-        return Zero()
-
-    def hPrimary(self, prob):
-        """
-        Primary magnetic field
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        return Zero()
-
-    def ePrimary(self, prob):
-        """
-        Primary electric field
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary electric field
-        """
-        return Zero()
-
-    def jPrimary(self, prob):
-        """
-        Primary current density
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary current density
-        """
-        return Zero()
-
-    def s_m(self, prob):
-        """
-        Magnetic source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: magnetic source term on mesh
-        """
-        return Zero()
-
-    def s_e(self, prob):
-        """
-        Electric source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: electric source term on mesh
-        """
-        return Zero()
-
-    def s_mDeriv(self, prob, v, adjoint = False):
-        """
-        Derivative of magnetic source term with respect to the inversion model
-
-        :param Problem prob: FDEM Problem
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: product of magnetic source term derivative with a vector
-        """
-
-        return Zero()
-
-    def s_eDeriv(self, prob, v, adjoint = False):
-        """
-        Derivative of electric source term with respect to the inversion model
-
-        :param Problem prob: FDEM Problem
-        :param numpy.ndarray v: vector to take product with
-        :param bool adjoint: adjoint?
-        :rtype: numpy.ndarray
-        :return: product of electric source term derivative with a vector
-        """
-        return Zero()
-
-
-class RawVec_e(BaseSrc):
-    """
-    RawVec electric source. It is defined by the user provided vector s_e
-
-    :param list rxList: receiver list
-    :param float freq: frequency
-    :param numpy.array s_e: electric source term
-    :param bool integrate: Integrate the source term (multiply by Me) [True]
-    """
-
-    def __init__(self, rxList, freq, s_e, integrate=True): #, ePrimary=None, bPrimary=None, hPrimary=None, jPrimary=None):
-        self._s_e = np.array(s_e, dtype=complex)
-        self.freq = float(freq)
-        self.integrate = integrate
-
-        BaseSrc.__init__(self, rxList)
-
-    def s_e(self, prob):
-        """
-        Electric source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: electric source term on mesh
-        """
-        if prob._formulation is 'EB' and self.integrate is True:
-            return prob.Me * self._s_e
-        return self._s_e
-
-
-class RawVec_m(BaseSrc):
-    """
-    RawVec magnetic source. It is defined by the user provided vector s_m
-
-    :param float freq: frequency
-    :param rxList: receiver list
-    :param numpy.array s_m: magnetic source term
-    :param bool integrate: Integrate the source term (multiply by Me) [True]
-    """
-
-    def __init__(self, rxList, freq, s_m, integrate=True):  #ePrimary=Zero(), bPrimary=Zero(), hPrimary=Zero(), jPrimary=Zero()):
-        self._s_m = np.array(s_m, dtype=complex)
-        self.freq = float(freq)
-        self.integrate = integrate
-
-        BaseSrc.__init__(self, rxList)
-
-    def s_m(self, prob):
-        """
-        Magnetic source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: magnetic source term on mesh
-        """
-        if prob._formulation is 'HJ' and self.integrate is True:
-            return prob.Me * self._s_m
-        return self._s_m
-
-
-class RawVec(BaseSrc):
-    """
-    RawVec source. It is defined by the user provided vectors s_m, s_e
-
-    :param rxList: receiver list
-    :param float freq: frequency
-    :param numpy.array s_m: magnetic source term
-    :param numpy.array s_e: electric source term
-    :param bool integrate: Integrate the source term (multiply by Me) [True]
-    """
-    def __init__(self, rxList, freq, s_m, s_e, integrate=True):
-        self._s_m = np.array(s_m, dtype=complex)
-        self._s_e = np.array(s_e, dtype=complex)
-        self.freq = float(freq)
-        self.integrate = integrate
-        BaseSrc.__init__(self, rxList)
-
-    def s_m(self, prob):
-        """
-        Magnetic source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: magnetic source term on mesh
-        """
-        if prob._formulation is 'HJ' and self.integrate is True:
-            return prob.Me * self._s_m
-        return self._s_m
-
-    def s_e(self, prob):
-        """
-        Electric source term
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: electric source term on mesh
-        """
-        if prob._formulation is 'EB' and self.integrate is True:
-            return prob.Me * self._s_e
-        return self._s_e
-
-
-class MagDipole(BaseSrc):
-    """
-    Point magnetic dipole source calculated by taking the curl of a magnetic
-    vector potential. By taking the discrete curl, we ensure that the magnetic
-    flux density is divergence free (no magnetic monopoles!).
-
-    This approach uses a primary-secondary in frequency. Here we show the
-    derivation for E-B formulation noting that similar steps are followed for
-    the H-J formulation.
-
-    .. math::
-        \mathbf{C} \mathbf{e} + i \omega \mathbf{b} = \mathbf{s_m} \\\\
-            {\mathbf{C}^T \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e} \mathbf{e} = \mathbf{s_e}}
-
-    We split up the fields and :math:`\mu^{-1}` into primary (:math:`\mathbf{P}`) and secondary (:math:`\mathbf{S}`) components
-
-    - :math:`\mathbf{e} = \mathbf{e^P} + \mathbf{e^S}`
-    - :math:`\mathbf{b} = \mathbf{b^P} + \mathbf{b^S}`
-    - :math:`\\boldsymbol{\mu}^{\mathbf{-1}} = \\boldsymbol{\mu}^{\mathbf{-1}^\mathbf{P}} + \\boldsymbol{\mu}^{\mathbf{-1}^\mathbf{S}}`
-
-    and define a zero-frequency primary problem, noting that the source is
-    generated by a divergence free electric current
-
-    .. math::
-        \mathbf{C} \mathbf{e^P} = \mathbf{s_m^P} = 0 \\\\
-            {\mathbf{C}^T \mathbf{{M_{\mu^{-1}}^f}^P} \mathbf{b^P} - \mathbf{M_{\sigma}^e} \mathbf{e^P} = \mathbf{M^e} \mathbf{s_e^P}}
-
-    Since :math:`\mathbf{e^P}` is curl-free, divergence-free, we assume that there is no constant field background, the :math:`\mathbf{e^P} = 0`, so our primary problem is
-
-    .. math::
-        \mathbf{e^P} =  0 \\\\
-            {\mathbf{C}^T \mathbf{{M_{\mu^{-1}}^f}^P} \mathbf{b^P} = \mathbf{s_e^P}}
-
-    Our secondary problem is then
-
-    .. math::
-        \mathbf{C} \mathbf{e^S} + i \omega \mathbf{b^S} = - i \omega \mathbf{b^P} \\\\
-            {\mathbf{C}^T \mathbf{M_{\mu^{-1}}^f} \mathbf{b^S} - \mathbf{M_{\sigma}^e} \mathbf{e^S} = -\mathbf{C}^T \mathbf{{M_{\mu^{-1}}^f}^S} \mathbf{b^P}}
-
-    :param list rxList: receiver list
-    :param float freq: frequency
-    :param numpy.ndarray loc: source location (ie: :code:`np.r_[xloc,yloc,zloc]`)
-    :param string orientation: 'X', 'Y', 'Z'
-    :param float moment: magnetic dipole moment
-    :param float mu: background magnetic permeability
-    """
-
-    def __init__(self, rxList, freq, loc, orientation='Z', moment=1., mu=mu_0):
-        self.freq = float(freq)
-        self.loc = loc
-        self.orientation = orientation
-        assert orientation in ['X','Y','Z'], "Orientation (right now) doesn't actually do anything! The methods in SrcUtils should take care of this..."
-        self.moment = moment
-        self.mu = mu
-        self.integrate = False
-        BaseSrc.__init__(self, rxList)
-
-    def bPrimary(self, prob):
-        """
-        The primary magnetic flux density from a magnetic vector potential
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        formulation = prob._formulation
-
-        if formulation is 'EB':
-            gridX = prob.mesh.gridEx
-            gridY = prob.mesh.gridEy
-            gridZ = prob.mesh.gridEz
-            C = prob.mesh.edgeCurl
-
-        elif formulation is 'HJ':
-            gridX = prob.mesh.gridFx
-            gridY = prob.mesh.gridFy
-            gridZ = prob.mesh.gridFz
-            C = prob.mesh.edgeCurl.T
-
-
-        if prob.mesh._meshType is 'CYL':
-            if not prob.mesh.isSymmetric:
-                # TODO ?
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            a = MagneticDipoleVectorPotential(self.loc, gridY, 'y', mu=self.mu, moment=self.moment)
-
-        else:
-            srcfct = MagneticDipoleVectorPotential
-            ax = srcfct(self.loc, gridX, 'x', mu=self.mu, moment=self.moment)
-            ay = srcfct(self.loc, gridY, 'y', mu=self.mu, moment=self.moment)
-            az = srcfct(self.loc, gridZ, 'z', mu=self.mu, moment=self.moment)
-            a = np.concatenate((ax, ay, az))
-
-        return C*a
-
-    def hPrimary(self, prob):
-        """
-        The primary magnetic field from a magnetic vector potential
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        b = self.bPrimary(prob)
-        return 1./self.mu * b
-
-    def s_m(self, prob):
-        """
-        The magnetic source term
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-
-        b_p = self.bPrimary(prob)
-        if prob._formulation is 'HJ':
-            b_p = prob.Me * b_p
-        return -1j*omega(self.freq)*b_p
-
-    def s_e(self, prob):
-        """
-        The electric source term
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-
-        if all(np.r_[self.mu] == np.r_[prob.curModel.mu]):
-            return Zero()
-        else:
-            formulation = prob._formulation
-
-            if formulation is 'EB':
-                mui_s = prob.curModel.mui - 1./self.mu
-                MMui_s = prob.mesh.getFaceInnerProduct(mui_s)
-                C = prob.mesh.edgeCurl
-            elif formulation is 'HJ':
-                mu_s = prob.curModel.mu - self.mu
-                MMui_s = prob.mesh.getEdgeInnerProduct(mu_s, invMat=True)
-                C = prob.mesh.edgeCurl.T
-
-            return -C.T * (MMui_s * self.bPrimary(prob))
-
-
-class MagDipole_Bfield(BaseSrc):
-
-    """
-    Point magnetic dipole source calculated with the analytic solution for the
-    fields from a magnetic dipole. No discrete curl is taken, so the magnetic
-    flux density may not be strictly divergence free.
-
-    This approach uses a primary-secondary in frequency in the same fashion as the MagDipole.
-
-    :param list rxList: receiver list
-    :param float freq: frequency
-    :param numpy.ndarray loc: source location (ie: :code:`np.r_[xloc,yloc,zloc]`)
-    :param string orientation: 'X', 'Y', 'Z'
-    :param float moment: magnetic dipole moment
-    :param float mu: background magnetic permeability
-    """
-
-    def __init__(self, rxList, freq, loc, orientation='Z', moment=1., mu = mu_0):
-        self.freq = float(freq)
-        self.loc = loc
-        assert orientation in ['X','Y','Z'], "Orientation (right now) doesn't actually do anything! The methods in SrcUtils should take care of this..."
-        self.orientation = orientation
-        self.moment = moment
-        self.mu = mu
-        BaseSrc.__init__(self, rxList)
-
-    def bPrimary(self, prob):
-        """
-        The primary magnetic flux density from the analytic solution for magnetic fields from a dipole
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-
-        formulation = prob._formulation
-
-        if formulation is 'EB':
-            gridX = prob.mesh.gridFx
-            gridY = prob.mesh.gridFy
-            gridZ = prob.mesh.gridFz
-            C = prob.mesh.edgeCurl
-
-        elif formulation is 'HJ':
-            gridX = prob.mesh.gridEx
-            gridY = prob.mesh.gridEy
-            gridZ = prob.mesh.gridEz
-            C = prob.mesh.edgeCurl.T
-
-        srcfct = MagneticDipoleFields
-        if prob.mesh._meshType is 'CYL':
-            if not prob.mesh.isSymmetric:
-                # TODO ?
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            bx = srcfct(self.loc, gridX, 'x', mu=self.mu, moment=self.moment)
-            bz = srcfct(self.loc, gridZ, 'z', mu=self.mu, moment=self.moment)
-            b = np.concatenate((bx,bz))
-        else:
-            bx = srcfct(self.loc, gridX, 'x', mu=self.mu, moment=self.moment)
-            by = srcfct(self.loc, gridY, 'y', mu=self.mu, moment=self.moment)
-            bz = srcfct(self.loc, gridZ, 'z', mu=self.mu, moment=self.moment)
-            b = np.concatenate((bx,by,bz))
-
-        return b
-
-    def hPrimary(self, prob):
-        """
-        The primary magnetic field from a magnetic vector potential
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        b = self.bPrimary(prob)
-        return 1/self.mu * b
-
-    def s_m(self, prob):
-        """
-        The magnetic source term
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        b = self.bPrimary(prob)
-        if prob._formulation is 'HJ':
-            b = prob.Me * b
-        return -1j*omega(self.freq)*b
-
-    def s_e(self, prob):
-        """
-        The electric source term
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        if all(np.r_[self.mu] == np.r_[prob.curModel.mu]):
-            return Zero()
-        else:
-            formulation = prob._formulation
-
-            if formulation is 'EB':
-                mui_s = prob.curModel.mui - 1./self.mu
-                MMui_s = prob.mesh.getFaceInnerProduct(mui_s)
-                C = prob.mesh.edgeCurl
-            elif formulation is 'HJ':
-                mu_s = prob.curModel.mu - self.mu
-                MMui_s = prob.mesh.getEdgeInnerProduct(mu_s, invMat=True)
-                C = prob.mesh.edgeCurl.T
-
-            return -C.T * (MMui_s * self.bPrimary(prob))
-
-
-class CircularLoop(BaseSrc):
-    """
-    Circular loop magnetic source calculated by taking the curl of a magnetic
-    vector potential. By taking the discrete curl, we ensure that the magnetic
-    flux density is divergence free (no magnetic monopoles!).
-
-    This approach uses a primary-secondary in frequency in the same fashion as the MagDipole.
-
-    :param list rxList: receiver list
-    :param float freq: frequency
-    :param numpy.ndarray loc: source location (ie: :code:`np.r_[xloc,yloc,zloc]`)
-    :param string orientation: 'X', 'Y', 'Z'
-    :param float moment: magnetic dipole moment
-    :param float mu: background magnetic permeability
-    """
-
-    def __init__(self, rxList, freq, loc, orientation='Z', radius=1., mu=mu_0):
-        self.freq = float(freq)
-        self.orientation = orientation
-        assert orientation in ['X','Y','Z'], "Orientation (right now) doesn't actually do anything! The methods in SrcUtils should take care of this..."
-        self.radius = radius
-        self.mu = mu
-        self.loc = loc
-        self.integrate = False
-        BaseSrc.__init__(self, rxList)
-
-    def bPrimary(self, prob):
-        """
-        The primary magnetic flux density from a magnetic vector potential
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        formulation = prob._formulation
-
-        if formulation is 'EB':
-            gridX = prob.mesh.gridEx
-            gridY = prob.mesh.gridEy
-            gridZ = prob.mesh.gridEz
-            C = prob.mesh.edgeCurl
-
-        elif formulation is 'HJ':
-            gridX = prob.mesh.gridFx
-            gridY = prob.mesh.gridFy
-            gridZ = prob.mesh.gridFz
-            C = prob.mesh.edgeCurl.T
-
-        if prob.mesh._meshType is 'CYL':
-            if not prob.mesh.isSymmetric:
-                # TODO ?
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            a = MagneticDipoleVectorPotential(self.loc, gridY, 'y', moment=self.radius, mu=self.mu)
-
-        else:
-            srcfct = MagneticDipoleVectorPotential
-            ax = srcfct(self.loc, gridX, 'x', self.radius, mu=self.mu)
-            ay = srcfct(self.loc, gridY, 'y', self.radius, mu=self.mu)
-            az = srcfct(self.loc, gridZ, 'z', self.radius, mu=self.mu)
-            a = np.concatenate((ax, ay, az))
-
-        return C*a
-
-    def hPrimary(self, prob):
-        """
-        The primary magnetic field from a magnetic vector potential
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        b = self.bPrimary(prob)
-        return 1./self.mu*b
-
-    def s_m(self, prob):
-        """
-        The magnetic source term
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        b = self.bPrimary(prob)
-        if prob._formulation is 'HJ':
-            b =  prob.Me *  b
-        return -1j*omega(self.freq)*b
-
-    def s_e(self, prob):
-        """
-        The electric source term
-
-        :param Problem prob: FDEM problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        if all(np.r_[self.mu] == np.r_[prob.curModel.mu]):
-            return Zero()
-        else:
-            formulation = prob._formulation
-
-            if formulation is 'EB':
-                mui_s = prob.curModel.mui - 1./self.mu
-                MMui_s = prob.mesh.getFaceInnerProduct(mui_s)
-                C = prob.mesh.edgeCurl
-
-
-            elif formulation is 'HJ':
-                mu_s = prob.curModel.mu - self.mu
-                MMui_s = prob.mesh.getEdgeInnerProduct(mu_s, invMat=True)
-                C = prob.mesh.edgeCurl.T
-
-            return -C.T * (MMui_s * self.bPrimary(prob))
-
-
-
-

SimPEG/EM/FDEM/SurveyFDEM.py

@@ -1,179 +0,0 @@
-import SimPEG
-from SimPEG.EM.Utils import *
-from SimPEG.EM.Base import BaseEMSurvey
-from scipy.constants import mu_0
-from SimPEG.Utils import Zero, Identity
-import SrcFDEM as Src
-from SimPEG import sp
-
-
-####################################################
-# Receivers
-####################################################
-
-class Rx(SimPEG.Survey.BaseRx):
-    """
-    Frequency domain receivers
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string rxType: reciever type from knownRxTypes
-    """
-
-    knownRxTypes = {
-                    'exr':['e', 'x', 'real'],
-                    'eyr':['e', 'y', 'real'],
-                    'ezr':['e', 'z', 'real'],
-                    'exi':['e', 'x', 'imag'],
-                    'eyi':['e', 'y', 'imag'],
-                    'ezi':['e', 'z', 'imag'],
-
-                    'bxr':['b', 'x', 'real'],
-                    'byr':['b', 'y', 'real'],
-                    'bzr':['b', 'z', 'real'],
-                    'bxi':['b', 'x', 'imag'],
-                    'byi':['b', 'y', 'imag'],
-                    'bzi':['b', 'z', 'imag'],
-
-                    'jxr':['j', 'x', 'real'],
-                    'jyr':['j', 'y', 'real'],
-                    'jzr':['j', 'z', 'real'],
-                    'jxi':['j', 'x', 'imag'],
-                    'jyi':['j', 'y', 'imag'],
-                    'jzi':['j', 'z', 'imag'],
-
-                    'hxr':['h', 'x', 'real'],
-                    'hyr':['h', 'y', 'real'],
-                    'hzr':['h', 'z', 'real'],
-                    'hxi':['h', 'x', 'imag'],
-                    'hyi':['h', 'y', 'imag'],
-                    'hzi':['h', 'z', 'imag'],
-                   }
-    radius = None
-
-    def __init__(self, locs, rxType):
-        SimPEG.Survey.BaseRx.__init__(self, locs, rxType)
-
-    @property
-    def projField(self):
-        """Field Type projection (e.g. e b ...)"""
-        return self.knownRxTypes[self.rxType][0]
-
-    @property
-    def projComp(self):
-        """Component projection (real/imag)"""
-        return self.knownRxTypes[self.rxType][2]
-
-    def projGLoc(self, u):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        return u._GLoc(self.rxType[0]) + self.knownRxTypes[self.rxType][1]
-
-    def eval(self, src, mesh, f):
-        """
-        Project fields to recievers to get data.
-
-        :param Source src: FDEM source
-        :param Mesh mesh: mesh used
-        :param Fields f: fields object
-        :rtype: numpy.ndarray
-        :return: fields projected to recievers
-        """
-        # projGLoc = u._GLoc(self.knownRxTypes[self.rxType][0])
-        # projGLoc += self.knownRxTypes[self.rxType][1]
-
-        P = self.getP(mesh, self.projGLoc(f))
-        f_part_complex = f[src, self.projField]
-        # get the real or imag component
-        real_or_imag = self.projComp
-        f_part = getattr(f_part_complex, real_or_imag)
-
-        return P*f_part
-
-    def evalDeriv(self, src, mesh, f, v, adjoint=False):
-        """
-        Derivative of projected fields with respect to the inversion model times a vector.
-
-        :param Source src: FDEM source
-        :param Mesh mesh: mesh used
-        :param Fields f: fields object
-        :param numpy.ndarray v: vector to multiply
-        :rtype: numpy.ndarray
-        :return: fields projected to recievers
-        """
-
-        P = self.getP(mesh, self.projGLoc(f))
-
-        if not adjoint:
-            Pv_complex = P * v
-            real_or_imag = self.projComp
-            Pv = getattr(Pv_complex, real_or_imag)
-        elif adjoint:
-            Pv_real = P.T * v
-
-            real_or_imag = self.projComp
-            if real_or_imag == 'imag':
-                Pv = 1j*Pv_real
-            elif real_or_imag == 'real':
-                Pv = Pv_real.astype(complex)
-            else:
-                raise NotImplementedError('must be real or imag')
-
-        return Pv
-
-
-####################################################
-# Survey
-####################################################
-
-class Survey(BaseEMSurvey):
-    """
-    Frequency domain electromagnetic survey
-
-    :param list srcList: list of FDEM sources used in the survey
-    """
-
-    srcPair = Src.BaseSrc
-    rxPair = Rx
-
-    def __init__(self, srcList, **kwargs):
-        # Sort these by frequency
-        self.srcList = srcList
-        BaseEMSurvey.__init__(self, srcList, **kwargs)
-
-        _freqDict = {}
-        for src in srcList:
-            if src.freq not in _freqDict:
-                _freqDict[src.freq] = []
-            _freqDict[src.freq] += [src]
-
-        self._freqDict = _freqDict
-        self._freqs = sorted([f for f in self._freqDict])
-
-    @property
-    def freqs(self):
-        """Frequencies"""
-        return self._freqs
-
-    @property
-    def nFreq(self):
-        """Number of frequencies"""
-        return len(self._freqDict)
-
-    @property
-    def nSrcByFreq(self):
-        """Number of sources at each frequency"""
-        if getattr(self, '_nSrcByFreq', None) is None:
-            self._nSrcByFreq = {}
-            for freq in self.freqs:
-                self._nSrcByFreq[freq] = len(self.getSrcByFreq(freq))
-        return self._nSrcByFreq
-
-    def getSrcByFreq(self, freq):
-        """
-        Returns the sources associated with a specific frequency.
-        :param float freq: frequency for which we look up sources
-        :rtype: dictionary
-        :return: sources at the sepcified frequency
-        """
-        assert freq in self._freqDict, "The requested frequency is not in this survey."
-        return self._freqDict[freq]
-

SimPEG/EM/FDEM/__init__.py

@@ -1,3 +0,0 @@
-from SurveyFDEM import Rx, Src, Survey
-from FDEM import BaseFDEMProblem, Problem_e, Problem_b, Problem_j, Problem_h
-from FieldsFDEM import *

SimPEG/EM/TDEM/BaseTDEM.py

@@ -1,164 +0,0 @@
-from SimPEG import Solver, Problem
-from SimPEG.Problem import BaseTimeProblem
-from SimPEG.EM.Utils import *
-from scipy.constants import mu_0
-from SimPEG.Utils import sdiag, mkvc
-from SimPEG import Utils, Mesh
-from SimPEG.EM.Base import BaseEMProblem
-import numpy as np
-
-
-class FieldsTDEM(Problem.TimeFields):
-    """Fancy Field Storage for a TDEM survey."""
-    knownFields = {'b': 'F', 'e': 'E'}
-
-    def tovec(self):
-        nSrc, nF, nE = self.survey.nSrc, self.mesh.nF, self.mesh.nE
-        u = np.empty((0,nSrc)) #((0,1) if nSrc == 1 else (0, nSrc))
-
-        for i in range(self.survey.prob.nT):
-            if 'b' in self:
-                b = self[:,'b',i+1]
-            else:
-                b = np.zeros((nF,nSrc)) # if nSrc == 1 else (nF, nSrc))
-
-            if 'e' in self:
-                e = self[:,'e',i+1]
-            else:
-                e = np.zeros((nE,nSrc)) # if nSrc == 1 else (nE, nSrc))
-            u = np.concatenate((u, b, e))
-
-        return Utils.mkvc(u,nSrc)
-
-
-class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem):
-    """docstring for BaseTDEMProblem"""
-    def __init__(self, mesh, mapping=None, **kwargs):
-        BaseTimeProblem.__init__(self, mesh, mapping=mapping, **kwargs)
-
-    _FieldsForward_pair = FieldsTDEM  #: used for the forward calculation only
-
-    waveformType = "STEPOFF"
-    current = None
-
-    def currentwaveform(self, wave):
-        self._timeSteps = np.diff(wave[:,0])
-        self.current = wave[:,1]
-        self.waveformType = "GENERAL"
-
-    def fields(self, m):
-        if self.verbose: print '%s\nCalculating fields(m)\n%s'%('*'*50,'*'*50)
-        self.curModel = m
-        # Create a fields storage object
-        F = self._FieldsForward_pair(self.mesh, self.survey)
-        for src in self.survey.srcList:
-            # Set the initial conditions
-            F[src,:,0] = src.getInitialFields(self.mesh)
-        F = self.forward(m, self.getRHS, F=F)
-        if self.verbose: print '%s\nDone calculating fields(m)\n%s'%('*'*50,'*'*50)
-        return F
-
-    def forward(self, m, RHS, F=None):
-        self.curModel = m
-        F = F or FieldsTDEM(self.mesh, self.survey)
-
-        dtFact = None
-        Ainv   = None
-        for tInd, dt in enumerate(self.timeSteps):
-            if dt != dtFact:
-                dtFact = dt
-                if Ainv is not None:
-                    Ainv.clean()
-                A = self.getA(tInd)
-                if self.verbose: print 'Factoring...   (dt = %e)'%dt
-                Ainv = self.Solver(A, **self.solverOpts)
-                if self.verbose: print 'Done'
-            rhs = RHS(tInd, F)
-            if self.verbose: print '    Solving...   (tInd = %d)'%tInd
-            sol = Ainv * rhs
-            if self.verbose: print '    Done...'
-            if sol.ndim == 1:
-                sol.shape = (sol.size,1)
-            F[:,self.solType,tInd+1] = sol
-        Ainv.clean()
-        return F
-
-    def adjoint(self, m, RHS, F=None):
-        self.curModel = m
-        F = F or FieldsTDEM(self.mesh, self.survey)
-
-        dtFact = None
-        Ainv   = None
-        for tInd, dt in reversed(list(enumerate(self.timeSteps))):
-            if dt != dtFact:
-                dtFact = dt
-                if Ainv is not None:
-                    Ainv.clean()
-                A = self.getA(tInd)
-                if self.verbose: print 'Factoring (Adjoint)...   (dt = %e)'%dt
-                Ainv = self.Solver(A, **self.solverOpts)
-                if self.verbose: print 'Done'
-            rhs = RHS(tInd, F)
-            if self.verbose: print '    Solving (Adjoint)...   (tInd = %d)'%tInd
-            sol = Ainv * rhs
-            if self.verbose: print '    Done...'
-            if sol.ndim == 1:
-                sol.shape = (sol.size,1)
-            F[:,self.solType,tInd+1] = sol
-        Ainv.clean()
-        return F
-
-    def Jvec(self, m, v, f=None):
-        """
-            :param numpy.array m: Conductivity model
-            :param numpy.ndarray v: vector (model object)
-            :param simpegEM.TDEM.FieldsTDEM f: Fields resulting from m
-            :rtype: numpy.ndarray
-            :return: w (data object)
-
-            Multiplying \\\(\\\mathbf{J}\\\) onto a vector can be broken into three steps
-
-            * Compute \\\(\\\\vec{p} = \\\mathbf{G}v\\\)
-            * Solve \\\(\\\hat{\\\mathbf{A}} \\\\vec{y} = \\\\vec{p}\\\)
-            * Compute \\\(\\\\vec{w} = -\\\mathbf{Q} \\\\vec{y}\\\)
-
-        """
-        if self.verbose: print '%s\nCalculating J(v)\n%s'%('*'*50,'*'*50)
-        self.curModel = m
-        if f is None:
-            f = self.fields(m)
-        p = self.Gvec(m, v, f)
-        y = self.solveAh(m, p)
-        Jv = self.survey.evalDeriv(f, v=y)
-        if self.verbose: print '%s\nDone calculating J(v)\n%s'%('*'*50,'*'*50)
-        return - mkvc(Jv)
-
-    def Jtvec(self, m, v, f=None):
-        """
-            :param numpy.array m: Conductivity model
-            :param numpy.ndarray,SimPEG.Survey.Data v: vector (data object)
-            :param simpegEM.TDEM.FieldsTDEM u: Fields resulting from m
-            :rtype: numpy.ndarray
-            :return: w (model object)
-
-            Multiplying \\\(\\\mathbf{J}^\\\\top\\\) onto a vector can be broken into three steps
-
-            * Compute \\\(\\\\vec{p} = \\\mathbf{Q}^\\\\top \\\\vec{v}\\\)
-            * Solve \\\(\\\hat{\\\mathbf{A}}^\\\\top \\\\vec{y} = \\\\vec{p}\\\)
-            * Compute \\\(\\\\vec{w} = -\\\mathbf{G}^\\\\top y\\\)
-
-        """
-        if self.verbose: print '%s\nCalculating J^T(v)\n%s'%('*'*50,'*'*50)
-        self.curModel = m
-        if f is None:
-            f = self.fields(m)
-
-        if not isinstance(v, self.dataPair):
-            v = self.dataPair(self.survey, v)
-
-        p = self.survey.evalDeriv(f, v=v, adjoint=True)
-        y = self.solveAht(m, p)
-        w = self.Gtvec(m, y, f)
-        if self.verbose: print '%s\nDone calculating J^T(v)\n%s'%('*'*50,'*'*50)
-        return - mkvc(w)
-

SimPEG/EM/TDEM/SurveyTDEM.py

@@ -1,199 +0,0 @@
-from SimPEG import Utils, Survey, np
-from SimPEG.Survey import BaseSurvey
-from SimPEG.EM.Utils import *
-from BaseTDEM import FieldsTDEM
-
-
-class RxTDEM(Survey.BaseTimeRx):
-
-    knownRxTypes = {
-                    'ex':['e', 'Ex', 'N'],
-                    'ey':['e', 'Ey', 'N'],
-                    'ez':['e', 'Ez', 'N'],
-
-                    'bx':['b', 'Fx', 'N'],
-                    'by':['b', 'Fy', 'N'],
-                    'bz':['b', 'Fz', 'N'],
-
-                    'dbxdt':['b', 'Fx', 'CC'],
-                    'dbydt':['b', 'Fy', 'CC'],
-                    'dbzdt':['b', 'Fz', 'CC'],
-                   }
-
-    def __init__(self, locs, times, rxType):
-        Survey.BaseTimeRx.__init__(self, locs, times, rxType)
-
-    @property
-    def projField(self):
-        """Field Type projection (e.g. e b ...)"""
-        return self.knownRxTypes[self.rxType][0]
-
-    @property
-    def projGLoc(self):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        return self.knownRxTypes[self.rxType][1]
-
-    @property
-    def projTLoc(self):
-        """Time Location projection (e.g. CC N)"""
-        return self.knownRxTypes[self.rxType][2]
-
-    def getTimeP(self, timeMesh):
-        """
-            Returns the time projection matrix.
-
-            .. note::
-
-                This is not stored in memory, but is created on demand.
-        """
-        if self.rxType in ['dbxdt','dbydt','dbzdt']:
-            return timeMesh.getInterpolationMat(self.times, self.projTLoc)*timeMesh.faceDiv
-        else:
-            return timeMesh.getInterpolationMat(self.times, self.projTLoc)
-
-    def eval(self, src, mesh, timeMesh, u):
-        P = self.getP(mesh, timeMesh)
-        u_part = Utils.mkvc(u[src, self.projField, :])
-        return P*u_part
-
-    def evalDeriv(self, src, mesh, timeMesh, u, v, adjoint=False):
-        P = self.getP(mesh, timeMesh)
-
-        if not adjoint:
-            return P * Utils.mkvc(v[src, self.projField, :])
-        elif adjoint:
-            return P.T * v[src, self]
-
-
-class SrcTDEM(Survey.BaseSrc):
-    rxPair = RxTDEM
-    radius = None
-
-    def getInitialFields(self, mesh):
-        F0 = getattr(self, '_getInitialFields_' + self.srcType)(mesh)
-        return F0
-
-    def getJs(self, mesh, time):
-        return None
-
-
-class SrcTDEM_VMD_MVP(SrcTDEM):
-
-    def __init__(self,rxList,loc,waveformType="STEPOFF"):
-        self.loc = loc
-        self.waveformType = waveformType
-        SrcTDEM.__init__(self,rxList)
-
-    def getInitialFields(self, mesh):
-        """Vertical magnetic dipole, magnetic vector potential"""
-        if self.waveformType == "STEPOFF":
-            print ">> Step waveform: Non-zero initial condition"        
-            if mesh._meshType is 'CYL':
-                if mesh.isSymmetric:
-                    MVP = MagneticDipoleVectorPotential(self.loc, mesh, 'Ey')
-                else:
-                    raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            elif mesh._meshType is 'TENSOR':
-                MVP = MagneticDipoleVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'])
-            else:
-                raise Exception('Unknown mesh for VMD') 
-            return {"b": mesh.edgeCurl*MVP}               
-        elif self.waveformType == "GENERAL":
-            print ">> General waveform: Zero initial condition"
-            return {"b": np.zeros(mesh.nF)}
-        else:
-            raise NotImplementedError("Only use STEPOFF or GENERAL")
-
-    def getMeS(self, mesh, MfMui):
-        if mesh._meshType is 'CYL':
-            if mesh.isSymmetric:
-                MVP = MagneticDipoleVectorPotential(self.loc, mesh, 'Ey')
-            else:
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-        elif mesh._meshType is 'TENSOR':
-            MVP = MagneticDipoleVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'])
-        else:
-            raise Exception('Unknown mesh for VMD')            
-        return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP
-
-
-class SrcTDEM_CircularLoop_MVP(SrcTDEM):
-    def __init__(self,rxList,loc,radius,waveformType="STEPOFF"):
-        self.loc = loc
-        self.radius = radius
-        self.waveformType = waveformType
-        SrcTDEM.__init__(self,rxList)        
-
-    def getInitialFields(self, mesh):
-        """Circular Loop, magnetic vector potential"""
-        if self.waveformType == "STEPOFF":
-            print ">> Step waveform: Non-zero initial condition"
-            if mesh._meshType is 'CYL':
-                if mesh.isSymmetric:
-                    MVP = MagneticLoopVectorPotential(self.loc, mesh, 'Ey', self.radius)
-                else:
-                    raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            elif mesh._meshType is 'TENSOR':
-                MVP = MagneticLoopVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'], self.radius)
-            else:
-                raise Exception('Unknown mesh for CircularLoop')
-            return {"b": mesh.edgeCurl*MVP}
-        elif self.waveformType == "GENERAL":
-            print ">> General waveform: Zero initial condition"
-            return {"b": np.zeros(mesh.nF)}
-        else:
-            raise NotImplementedError("Only use STEPOFF or GENERAL")
-
-    def getMeS(self, mesh, MfMui):
-        if mesh._meshType is 'CYL':
-            if mesh.isSymmetric:
-                MVP = MagneticLoopVectorPotential(self.loc, mesh, 'Ey', self.radius)
-            else:
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-        elif mesh._meshType is 'TENSOR':
-            MVP = MagneticLoopVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'], self.radius)
-        else:
-            raise Exception('Unknown mesh for CircularLoop')            
-        return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP
-
-
-class SurveyTDEM(Survey.BaseSurvey):
-    """
-        docstring for SurveyTDEM
-    """
-    srcPair = SrcTDEM
-
-    def __init__(self, srcList, **kwargs):
-        # Sort these by frequency
-        self.srcList = srcList
-        Survey.BaseSurvey.__init__(self, **kwargs)
-
-    def eval(self, u):
-        data = Survey.Data(self)
-        for src in self.srcList:
-            for rx in src.rxList:
-                data[src, rx] = rx.eval(src, self.mesh, self.prob.timeMesh, u)
-        return data
-
-    def evalDeriv(self, u, v=None, adjoint=False):
-        assert v is not None, 'v to multiply must be provided.'
-
-        if not adjoint:
-            data = Survey.Data(self)
-            for src in self.srcList:
-                for rx in src.rxList:
-                    data[src, rx] = rx.evalDeriv(src, self.mesh, self.prob.timeMesh, u, v)
-            return data
-        else:
-            f = FieldsTDEM(self.mesh, self)
-            for src in self.srcList:
-                for rx in src.rxList:
-                    Ptv = rx.evalDeriv(src, self.mesh, self.prob.timeMesh, u, v, adjoint=True)
-                    Ptv = Ptv.reshape((-1, self.prob.timeMesh.nN), order='F')
-                    if rx.projField not in f: # first time we are projecting
-                        f[src, rx.projField, :] = Ptv
-                    else: # there are already fields, so let's add to them!
-                        f[src, rx.projField, :] += Ptv
-            return f
-
-

SimPEG/EM/TDEM/TDEM_b.py

@@ -1,356 +0,0 @@
-from BaseTDEM import BaseTDEMProblem, FieldsTDEM
-from SimPEG.Utils import mkvc, sdiag
-import numpy as np
-from SurveyTDEM import SurveyTDEM
-
-
-class FieldsTDEM_e_from_b(FieldsTDEM):
-    """Fancy Field Storage for a TDEM survey."""
-    knownFields = {'b': 'F'}
-    aliasFields = {'e': ['b','E','e_from_b']}
-
-    def startup(self):
-        self.MeSigmaI  = self.survey.prob.MeSigmaI
-        self.edgeCurlT = self.survey.prob.mesh.edgeCurl.T
-        self.MfMui     = self.survey.prob.MfMui
-
-    def e_from_b(self, b, srcInd, timeInd):
-        # TODO: implement non-zero js
-        return self.MeSigmaI*(self.edgeCurlT*(self.MfMui*b))
-
-class FieldsTDEM_e_from_b_Ah(FieldsTDEM):
-    """Fancy Field Storage for a TDEM survey.
-
-        This is used when solving Ahat and AhatT
-    """
-    knownFields = {'b': 'F'}
-    aliasFields = {'e': ['b','E','e_from_b']}
-    p = None
-
-    def startup(self):
-        self.MeSigmaI  = self.survey.prob.MeSigmaI
-        self.edgeCurlT = self.survey.prob.mesh.edgeCurl.T
-        self.MfMui     = self.survey.prob.MfMui
-
-    def e_from_b(self, y_b, srcInd, tInd):
-        y_e = self.MeSigmaI*(self.edgeCurlT*(self.MfMui*y_b))
-        if 'e' in self.p:
-            y_e = y_e - self.MeSigmaI*self.p[srcInd,'e',tInd]
-        return y_e
-
-class ProblemTDEM_b(BaseTDEMProblem):
-    """
-        Time-Domain EM problem - B-formulation
-
-        TDEM_b treats the following discretization of Maxwell's equations
-
-        .. math::
-            \dcurl \e^{(t+1)} + \\frac{\\b^{(t+1)} - \\b^{(t)}}{\delta t} = 0 \\\\
-            \dcurl^\\top \MfMui \\b^{(t+1)} - \MeSig \e^{(t+1)} = \Me \j_s^{(t+1)}
-
-        with \\\(\\b\\\) defined on cell faces and \\\(\e\\\) defined on edges.
-    """
-    def __init__(self, mesh, mapping=None, **kwargs):
-        BaseTDEMProblem.__init__(self, mesh, mapping=mapping, **kwargs)
-
-    solType = 'b' #: Type of the solution, in this case the 'b' field
-
-    surveyPair = SurveyTDEM
-    _FieldsForward_pair = FieldsTDEM_e_from_b     #: used for the forward calculation only
-
-    ####################################################
-    # Internal Methods
-    ####################################################
-
-    def getA(self, tInd):
-        """
-            :param int tInd: Time index
-            :rtype: scipy.sparse.csr_matrix
-            :return: A
-        """
-        dt = self.timeSteps[tInd]
-        return self.MfMui*self.mesh.edgeCurl*self.MeSigmaI*self.mesh.edgeCurl.T*self.MfMui + (1.0/dt)*self.MfMui
-
-    def getRHS(self, tInd, F):
-        dt = self.timeSteps[tInd]
-        B_n = np.c_[[F[src,'b',tInd] for src in self.survey.srcList]].T
-        if B_n.shape[0] is not 1:
-            raise NotImplementedError('getRHS not implemented for this shape of B_n')
-        RHS = (1.0/dt)*self.MfMui*B_n[0,:,:] #TODO: This is a hack
-        return RHS
-
-    ####################################################
-    # Derivatives
-    ####################################################
-
-    def Gvec(self, m, vec, u=None):
-        """
-            :param numpy.array m: Conductivity model
-            :param numpy.array vec: vector (like a model)
-            :param simpegEM.TDEM.FieldsTDEM u: Fields resulting from m
-            :rtype: simpegEM.TDEM.FieldsTDEM
-            :return: f
-
-            Multiply G by a vector
-        """
-        if u is None:
-            u = self.fields(m)
-        self.curModel = m
-
-        # Note: Fields has shape (nF/E, nSrc, nT+1)
-        #       However, p will only really fill (:,:,1:nT+1)
-        #       meaning the 'initial fields' are zero (:,:,0)
-        p = FieldsTDEM(self.mesh, self.survey)
-        # 'b' at all times is zero.
-        #       However, to save memory we will **not** do:
-        #
-        #               p[:, 'b', :] = 0.0
-
-        # fake initial 'e' fields
-        p[:, 'e', 0] = 0.0
-        dMdsig = self.MeSigmaDeriv
-        # self.mesh.getEdgeInnerProductDeriv(self.curModel.transform)
-        # dsigdm_x_v = self.curModel.sigmaDeriv*vec
-        # dsigdm_x_v = self.curModel.transformDeriv*vec
-        for i in range(1,self.nT+1):
-            # TODO: G[1] may be dependent on the model
-            #       for a galvanic source (deriv of the dc problem)
-            #
-            # Do multiplication for all src in self.survey.srcList
-            for src in self.survey.srcList:
-                p[src, 'e', i] = - dMdsig(u[src,'e',i]) *  vec
-        return p
-
-    def Gtvec(self, m, vec, u=None):
-        """
-            :param numpy.array m: Conductivity model
-            :param numpy.array vec: vector (like a fields)
-            :param simpegEM.TDEM.FieldsTDEM u: Fields resulting from m
-            :rtype: np.ndarray (like a model)
-            :return: p
-
-            Multiply G.T by a vector
-        """
-        if u is None:
-            u = self.fields(m)
-        self.curModel = m
-        # dMdsig = self.mesh.getEdgeInnerProductDeriv(self.curModel.transform)
-        # dsigdm = self.curModel.transformDeriv
-        MeSigmaDeriv = self.MeSigmaDeriv
-
-        nSrc = self.survey.nSrc
-        VUs = None
-        # Here we can do internal multiplications of Gt*v and then multiply by MsigDeriv.T in one go.
-        for i in range(1,self.nT+1):
-            vu = None
-            for src in self.survey.srcList:
-                vusrc = MeSigmaDeriv(u[src,'e',i]).T * vec[src,'e',i]
-                vu = vusrc if vu is None else vu + vusrc
-            VUs = vu if VUs is None else VUs + vu
-        # p = -dsigdm.T*VUs
-        return -VUs
-
-    def solveAh(self, m, p):
-        """
-            :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM p: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
-            :return: y
-
-            Solve the block-matrix system \\\(\\\hat{A} \\\hat{y} = \\\hat{p}\\\):
-
-            .. math::
-                \mathbf{\hat{A}} = \left[
-                    \\begin{array}{cccc}
-                        A & 0 & & \\\\
-                        B & A & & \\\\
-                        & \ddots & \ddots & \\\\
-                        & & B & A
-                    \end{array}
-                \\right] \\\\
-                \mathbf{A} =
-                \left[
-                    \\begin{array}{cc}
-                        \\frac{1}{\delta t} \MfMui & \MfMui\dcurl \\\\
-                        \dcurl^\\top \MfMui & -\MeSig
-                    \end{array}
-                \\right] \\\\
-                \mathbf{B} =
-                \left[
-                    \\begin{array}{cc}
-                        -\\frac{1}{\delta t} \MfMui & 0 \\\\
-                        0 & 0
-                    \end{array}
-                \\right] \\\\
-        """
-
-        def AhRHS(tInd, y):
-            rhs = self.MfMui*(self.mesh.edgeCurl*(self.MeSigmaI*p[:,'e',tInd+1]))
-            if 'b' in p:
-                rhs = rhs + p[:,'b',tInd+1]
-            if tInd == 0:
-                return rhs
-            dt = self.timeSteps[tInd]
-            return rhs + 1.0/dt*self.MfMui*y[:,'b',tInd]
-
-        F = FieldsTDEM_e_from_b_Ah(self.mesh, self.survey, p=p)
-
-        return self.forward(m, AhRHS, F)
-
-    def solveAht(self, m, p):
-        """
-            :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM p: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
-            :return: y
-
-            Solve the block-matrix system \\\(\\\hat{A}^\\\\top \\\hat{y} = \\\hat{p}\\\):
-
-            .. math::
-                \mathbf{\hat{A}}^\\top = \left[
-                    \\begin{array}{cccc}
-                        A & B & & \\\\
-                          & \ddots & \ddots & \\\\
-                          & & A & B \\\\
-                          & & 0 & A
-                    \end{array}
-                \\right] \\\\
-                \mathbf{A} =
-                \left[
-                    \\begin{array}{cc}
-                        \\frac{1}{\delta t} \MfMui & \MfMui\dcurl \\\\
-                        \dcurl^\\top \MfMui & -\MeSig
-                    \end{array}
-                \\right] \\\\
-                \mathbf{B} =
-                \left[
-                    \\begin{array}{cc}
-                        -\\frac{1}{\delta t} \MfMui & 0 \\\\
-                        0 & 0
-                    \end{array}
-                \\right] \\\\
-        """
-
-        #  Mini Example:
-        #
-        #       nT = 3, len(times) == 4, fields stored in F[:,:,1:4]
-        #
-        #       0 is held for initial conditions (this shifts the storage by +1)
-        #       ^
-        #  fLoc 0     1     2     3
-        #       |-----|-----|-----|
-        #  tInd    0     1     2
-        #                        / ___/
-        #                      2          (tInd=2 uses fields 3 and would use 4 but it doesn't exist)
-        #                 / ___/
-        #                1                (tInd=1 uses fields 2 and 3)
-
-        def AhtRHS(tInd, y):
-            nSrc, nF = self.survey.nSrc, self.mesh.nF
-            rhs = np.zeros((nF,1) if nSrc == 1 else (nF, nSrc))
-
-            if 'e' in p:
-                rhs += self.MfMui*(self.mesh.edgeCurl*(self.MeSigmaI*p[:,'e',tInd+1]))
-            if 'b' in p:
-                rhs += p[:,'b',tInd+1]
-
-            if tInd == self.nT-1:
-                return rhs
-            dt = self.timeSteps[tInd+1]
-            return rhs + 1.0/dt*self.MfMui*y[:,'b',tInd+2]
-
-        F = FieldsTDEM_e_from_b_Ah(self.mesh, self.survey, p=p)
-
-        return self.adjoint(m, AhtRHS, F)
-
-    ####################################################
-    # Functions for tests
-    ####################################################
-
-    def _AhVec(self, m, vec):
-        """
-            :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM vec: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
-            :return: f
-
-            Multiply the matrix \\\(\\\hat{A}\\\) by a fields vector where
-
-            .. math::
-                \mathbf{\hat{A}} = \left[
-                    \\begin{array}{cccc}
-                        A & 0 & & \\\\
-                        B & A & & \\\\
-                        & \ddots & \ddots & \\\\
-                        & & B & A
-                    \end{array}
-                \\right] \\\\
-                \mathbf{A} =
-                \left[
-                    \\begin{array}{cc}
-                        \\frac{1}{\delta t} \MfMui & \MfMui\dcurl \\\\
-                        \dcurl^\\top \MfMui & -\MeSig
-                    \end{array}
-                \\right] \\\\
-                \mathbf{B} =
-                \left[
-                    \\begin{array}{cc}
-                        -\\frac{1}{\delta t} \MfMui & 0 \\\\
-                        0 & 0
-                    \end{array}
-                \\right] \\\\
-        """
-
-        self.curModel = m
-        f = FieldsTDEM(self.mesh, self.survey)
-        for i in range(1,self.nT+1):
-            dt = self.timeSteps[i-1]
-            b = 1.0/dt*self.MfMui*vec[:,'b',i] + self.MfMui*(self.mesh.edgeCurl*vec[:,'e',i])
-            if i > 1:
-                b = b - 1.0/dt*self.MfMui*vec[:,'b',i-1]
-            f[:,'b',i] = b
-            f[:,'e',i] = self.mesh.edgeCurl.T*(self.MfMui*vec[:,'b',i]) - self.MeSigma*vec[:,'e',i]
-        return f
-
-    def _AhtVec(self, m, vec):
-        """
-            :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM vec: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
-            :return: f
-
-            Multiply the matrix \\\(\\\hat{A}\\\) by a fields vector where
-
-            .. math::
-                \mathbf{\hat{A}}^\\top = \left[
-                    \\begin{array}{cccc}
-                        A & B & & \\\\
-                          & \ddots & \ddots & \\\\
-                          & & A & B \\\\
-                          & & 0 & A
-                    \end{array}
-                \\right] \\\\
-                \mathbf{A} =
-                \left[
-                    \\begin{array}{cc}
-                        \\frac{1}{\delta t} \MfMui & \MfMui\dcurl \\\\
-                        \dcurl^\\top \MfMui & -\MeSig
-                    \end{array}
-                \\right] \\\\
-                \mathbf{B} =
-                \left[
-                    \\begin{array}{cc}
-                        -\\frac{1}{\delta t} \MfMui & 0 \\\\
-                        0 & 0
-                    \end{array}
-                \\right] \\\\
-        """
-        self.curModel = m
-        f = FieldsTDEM(self.mesh, self.survey)
-        for i in range(self.nT):
-            b = 1.0/self.timeSteps[i]*self.MfMui*vec[:,'b',i+1] + self.MfMui*(self.mesh.edgeCurl*vec[:,'e',i+1])
-            if i < self.nT-1:
-                b = b - 1.0/self.timeSteps[i+1]*self.MfMui*vec[:,'b',i+2]
-            f[:,'b', i+1] = b
-            f[:,'e', i+1] = self.mesh.edgeCurl.T*(self.MfMui*vec[:,'b',i+1]) - self.MeSigma*vec[:,'e',i+1]
-        return f

SimPEG/EM/TDEM/__init__.py

@@ -1,3 +0,0 @@
-from SurveyTDEM import * #SurveyTDEM, RxTDEM, SrcTDEM
-from BaseTDEM import BaseTDEMProblem, FieldsTDEM
-from TDEM_b import ProblemTDEM_b

SimPEG/EM/Utils/AnalyticUtils.py

@@ -1,203 +0,0 @@
-from SimPEG import *
-from scipy.special import ellipk, ellipe
-from scipy.constants import mu_0, pi
-
-def MagneticDipoleVectorPotential(srcLoc, obsLoc, component, moment=1., dipoleMoment=(0., 0., 1.), mu = mu_0):
-    """
-        Calculate the vector potential of a set of magnetic dipoles
-        at given locations 'ref. <http://en.wikipedia.org/wiki/Dipole#Magnetic_vector_potential>'
-
-        :param numpy.ndarray srcLoc: Location of the source(s) (x, y, z)
-        :param numpy.ndarray,SimPEG.Mesh obsLoc: Where the potentials will be calculated (x, y, z) or a SimPEG Mesh
-        :param str,list component: The component to calculate - 'x', 'y', or 'z' if an array, or grid type if mesh, can be a list
-        :param numpy.ndarray dipoleMoment: The vector dipole moment
-        :rtype: numpy.ndarray
-        :return: The vector potential each dipole at each observation location
-    """
-    #TODO: break this out!
-
-    if type(component) in [list, tuple]:
-        out = range(len(component))
-        for i, comp in enumerate(component):
-            out[i] = MagneticDipoleVectorPotential(srcLoc, obsLoc, comp, dipoleMoment=dipoleMoment)
-        return np.concatenate(out)
-
-    if isinstance(obsLoc, Mesh.BaseMesh):
-        mesh = obsLoc
-        assert component in ['Ex','Ey','Ez','Fx','Fy','Fz'], "Components must be in: ['Ex','Ey','Ez','Fx','Fy','Fz']"
-        return MagneticDipoleVectorPotential(srcLoc, getattr(mesh,'grid'+component), component[1], dipoleMoment=dipoleMoment)
-
-    if component == 'x':
-        dimInd = 0
-    elif component == 'y':
-        dimInd = 1
-    elif component == 'z':
-        dimInd = 2
-    else:
-        raise ValueError('Invalid component')
-
-    srcLoc = np.atleast_2d(srcLoc)
-    obsLoc = np.atleast_2d(obsLoc)
-    dipoleMoment = np.atleast_2d(dipoleMoment)
-
-    nEdges = obsLoc.shape[0]
-    nSrc = srcLoc.shape[0]
-
-    m = np.array(dipoleMoment).repeat(nEdges, axis=0)
-    A = np.empty((nEdges, nSrc))
-    for i in range(nSrc):
-        dR = obsLoc - srcLoc[i, np.newaxis].repeat(nEdges, axis=0)
-        mCr = np.cross(m, dR)
-        r = np.sqrt((dR**2).sum(axis=1))
-        A[:, i] = +(mu/(4*pi)) * mCr[:,dimInd]/(r**3)
-    if nSrc == 1:
-        return A.flatten()
-    return A
-
-
-def MagneticDipoleFields(srcLoc, obsLoc, component, moment=1., mu = mu_0):
-    """
-        Calculate the vector potential of a set of magnetic dipoles
-        at given locations 'ref. <http://en.wikipedia.org/wiki/Dipole#Magnetic_vector_potential>'
-
-        :param numpy.ndarray srcLoc: Location of the source(s) (x, y, z)
-        :param numpy.ndarray obsLoc: Where the potentials will be calculated (x, y, z)
-        :param str component: The component to calculate - 'x', 'y', or 'z'
-        :param numpy.ndarray moment: The vector dipole moment (vertical)
-        :rtype: numpy.ndarray
-        :return: The vector potential each dipole at each observation location
-    """
-
-    if component=='x':
-        dimInd = 0
-    elif component=='y':
-        dimInd = 1
-    elif component=='z':
-        dimInd = 2
-    else:
-        raise ValueError('Invalid component')
-
-    srcLoc = np.atleast_2d(srcLoc)
-    obsLoc = np.atleast_2d(obsLoc)
-    moment = np.atleast_2d(moment)
-
-    nFaces = obsLoc.shape[0]
-    nSrc = srcLoc.shape[0]
-
-    m = np.array(moment).repeat(nFaces, axis=0)
-    B = np.empty((nFaces, nSrc))
-    for i in range(nSrc):
-        dR = obsLoc - srcLoc[i, np.newaxis].repeat(nFaces, axis=0)
-        r = np.sqrt((dR**2).sum(axis=1))
-        if dimInd == 0:
-            B[:, i] = +(mu/(4*pi)) /(r**3) * (3*dR[:,2]*dR[:,0]/r**2)
-        elif dimInd == 1:
-            B[:, i] = +(mu/(4*pi)) /(r**3) * (3*dR[:,2]*dR[:,1]/r**2)
-        elif dimInd == 2:
-            B[:, i] = +(mu/(4*pi)) /(r**3) * (3*dR[:,2]**2/r**2-1)
-        else:
-            raise Exception("Not Implemented")
-    if nSrc == 1:
-        return B.flatten()
-    return B
-
-
-
-def MagneticLoopVectorPotential(srcLoc, obsLoc, component, radius, mu=mu_0):
-    """
-        Calculate the vector potential of horizontal circular loop
-        at given locations
-
-        :param numpy.ndarray srcLoc: Location of the source(s) (x, y, z)
-        :param numpy.ndarray,SimPEG.Mesh obsLoc: Where the potentials will be calculated (x, y, z) or a SimPEG Mesh
-        :param str,list component: The component to calculate - 'x', 'y', or 'z' if an array, or grid type if mesh, can be a list
-        :param numpy.ndarray I: Input current of the loop
-        :param numpy.ndarray radius: radius of the loop
-        :rtype: numpy.ndarray
-        :return: The vector potential each dipole at each observation location
-    """
-
-    if type(component) in [list, tuple]:
-        out = range(len(component))
-        for i, comp in enumerate(component):
-            out[i] = MagneticLoopVectorPotential(srcLoc, obsLoc, comp, radius, mu)
-        return np.concatenate(out)
-
-    if isinstance(obsLoc, Mesh.BaseMesh):
-        mesh = obsLoc
-        assert component in ['Ex','Ey','Ez','Fx','Fy','Fz'], "Components must be in: ['Ex','Ey','Ez','Fx','Fy','Fz']"
-        return MagneticLoopVectorPotential(srcLoc, getattr(mesh,'grid'+component), component[1], radius, mu)
-
-    srcLoc = np.atleast_2d(srcLoc)
-    obsLoc = np.atleast_2d(obsLoc)
-
-    n = obsLoc.shape[0]
-    nSrc = srcLoc.shape[0]
-
-    if component=='z':
-        A = np.zeros((n, nSrc))
-        if nSrc ==1:
-            return A.flatten()
-        return A
-
-    else:
-
-        A = np.zeros((n, nSrc))
-        for i in range (nSrc):
-            x = obsLoc[:, 0] - srcLoc[i, 0]
-            y = obsLoc[:, 1] - srcLoc[i, 1]
-            z = obsLoc[:, 2] - srcLoc[i, 2]
-            r = np.sqrt(x**2 + y**2)
-            m = (4 * radius * r) / ((radius + r)**2 + z**2)
-            m[m > 1.] = 1.
-            # m might be slightly larger than 1 due to rounding errors
-            # but ellipke requires 0 <= m <= 1
-            K = ellipk(m)
-            E = ellipe(m)
-            ind = (r > 0) & (m < 1)
-            # % 1/r singular at r = 0 and K(m) singular at m = 1
-            Aphi = np.zeros(n)
-            # % Common factor is (mu * I) / pi with I = 1 and mu = 4e-7 * pi.
-            Aphi[ind] = 4e-7 / np.sqrt(m[ind])  * np.sqrt(radius / r[ind]) *((1. - m[ind] / 2.) * K[ind] - E[ind])
-            if component == 'x':
-                A[ind, i] = Aphi[ind] * (-y[ind] / r[ind] )
-            elif component == 'y':
-                A[ind, i] = Aphi[ind] * ( x[ind] / r[ind] )
-            else:
-                raise ValueError('Invalid component')
-
-        if nSrc == 1:
-            return A.flatten()
-        return A
-
-if __name__ == '__main__':
-    from SimPEG import Mesh
-    import matplotlib.pyplot as plt
-    cs = 20
-    ncx, ncy, ncz = 41, 41, 40
-    hx = np.ones(ncx)*cs
-    hy = np.ones(ncy)*cs
-    hz = np.ones(ncz)*cs
-    mesh = Mesh.TensorMesh([hx, hy, hz], 'CCC')
-    srcLoc = np.r_[0., 0., 0.]
-    Ax = MagneticLoopVectorPotential(srcLoc, mesh.gridEx, 'x', 200)
-    Ay = MagneticLoopVectorPotential(srcLoc, mesh.gridEy, 'y', 200)
-    Az = MagneticLoopVectorPotential(srcLoc, mesh.gridEz, 'z', 200)
-    A = np.r_[Ax, Ay, Az]
-    B0 = mesh.edgeCurl*A
-    J0 = mesh.edgeCurl.T*B0
-
-    # mesh.plotImage(A, vType = 'Ex')
-    # mesh.plotImage(A, vType = 'Ey')
-
-    mesh.plotImage(B0, vType = 'Fx')
-    mesh.plotImage(B0, vType = 'Fy')
-    mesh.plotImage(B0, vType = 'Fz')
-
-    # # mesh.plotImage(J0, vType = 'Ex')
-    # mesh.plotImage(J0, vType = 'Ey')
-    # mesh.plotImage(J0, vType = 'Ez')
-
-    plt.show()
-
-

SimPEG/EM/Utils/EMUtils.py

@@ -1,16 +0,0 @@
-import numpy as np
-from scipy.constants import mu_0, epsilon_0
-
-# useful params
-def omega(freq):
-    """Angular frequency, omega"""
-    return 2.*np.pi*freq
-
-def k(freq, sigma, mu=mu_0, eps=epsilon_0):
-    """ Eq 1.47 - 1.49 in Ward and Hohmann """
-    w = omega(freq)
-    alp  = w * np.sqrt( mu*eps/2 * ( np.sqrt(1. + (sigma / (eps*w))**2 ) + 1) ) 
-    beta = w * np.sqrt( mu*eps/2 * ( np.sqrt(1. + (sigma / (eps*w))**2 ) - 1) ) 
-    return alp - 1j*beta
-
-

SimPEG/EM/Utils/__init__.py

@@ -1,2 +0,0 @@
-from EMUtils import omega, k
-from AnalyticUtils import MagneticDipoleFields, MagneticDipoleVectorPotential, MagneticLoopVectorPotential

SimPEG/EM/Utils/testingUtils.py

@@ -1,126 +0,0 @@
-import unittest
-from SimPEG import *
-from SimPEG import EM
-import sys
-from scipy.constants import mu_0
-
-FLR = 1e-20 # "zero", so if residual below this --> pass regardless of order
-CONDUCTIVITY = 1e1
-MU = mu_0
-freq = 5e-1
-
-
-def getFDEMProblem(fdemType, comp, SrcList, freq, useMu=False, verbose=False):
-    cs = 10.
-    ncx, ncy, ncz = 0, 0, 0
-    npad = 8
-    hx = [(cs,npad,-1.3), (cs,ncx), (cs,npad,1.3)]
-    hy = [(cs,npad,-1.3), (cs,ncy), (cs,npad,1.3)]
-    hz = [(cs,npad,-1.3), (cs,ncz), (cs,npad,1.3)]
-    mesh = Mesh.TensorMesh([hx,hy,hz],['C','C','C'])
-
-    if useMu is True:
-        mapping = [('sigma', Maps.ExpMap(mesh)), ('mu', Maps.IdentityMap(mesh))] 
-    else:
-        mapping = Maps.ExpMap(mesh)
-
-    x = np.array([np.linspace(-5.*cs,-2.*cs,3),np.linspace(5.*cs,2.*cs,3)]) + cs/4. #don't sample right by the source, slightly off alignment from either staggered grid
-    XYZ = Utils.ndgrid(x,x,np.linspace(-2.*cs,2.*cs,5))
-    Rx0 = EM.FDEM.Rx(XYZ, comp)
-
-    Src = []
-
-    for SrcType in SrcList:
-        if SrcType is 'MagDipole':
-            Src.append(EM.FDEM.Src.MagDipole([Rx0], freq=freq, loc=np.r_[0.,0.,0.]))
-        elif SrcType is 'MagDipole_Bfield':
-            Src.append(EM.FDEM.Src.MagDipole_Bfield([Rx0], freq=freq, loc=np.r_[0.,0.,0.]))
-        elif SrcType is 'CircularLoop':
-            Src.append(EM.FDEM.Src.CircularLoop([Rx0], freq=freq, loc=np.r_[0.,0.,0.]))
-        elif SrcType is 'RawVec':
-            if fdemType is 'e' or fdemType is 'b':
-                S_m = np.zeros(mesh.nF)
-                S_e = np.zeros(mesh.nE)
-                S_m[Utils.closestPoints(mesh,[0.,0.,0.],'Fz') + np.sum(mesh.vnF[:1])] = 1e-3
-                S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Ez') + np.sum(mesh.vnE[:1])] = 1e-3
-                Src.append(EM.FDEM.Src.RawVec([Rx0], freq, S_m, S_e))
-
-            elif fdemType is 'h' or fdemType is 'j':
-                S_m = np.zeros(mesh.nE)
-                S_e = np.zeros(mesh.nF)
-                S_m[Utils.closestPoints(mesh,[0.,0.,0.],'Ez') + np.sum(mesh.vnE[:1])] = 1e-3
-                S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Fz') + np.sum(mesh.vnF[:1])] = 1e-3
-                Src.append(EM.FDEM.Src.RawVec([Rx0], freq, S_m, S_e))
-
-    if verbose:
-        print '  Fetching %s problem' % (fdemType)
-
-    if fdemType == 'e':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_e(mesh, mapping=mapping)
-
-    elif fdemType == 'b':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_b(mesh, mapping=mapping)
-
-    elif fdemType == 'j':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_j(mesh, mapping=mapping)
-
-    elif fdemType == 'h':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_h(mesh, mapping=mapping)
-
-    else:
-        raise NotImplementedError()
-    prb.pair(survey)
-
-    try:
-        from pymatsolver import MumpsSolver
-        prb.Solver = MumpsSolver
-    except ImportError, e:
-        prb.Solver = SolverLU
-
-    return prb
-
-def crossCheckTest(SrcList, fdemType1, fdemType2, comp, addrandoms = False, useMu=False, TOL=1e-5, verbose=False):
-
-    l2norm = lambda r: np.sqrt(r.dot(r))
-
-    prb1 = getFDEMProblem(fdemType1, comp, SrcList, freq, useMu, verbose)
-    mesh = prb1.mesh
-    print 'Cross Checking Forward: %s, %s formulations - %s' % (fdemType1, fdemType2, comp)
-    
-    logsig = np.log(np.ones(mesh.nC)*CONDUCTIVITY)
-    mu = np.ones(mesh.nC)*MU
-
-    if addrandoms is True:
-        logsig  += np.random.randn(mesh.nC)*np.log(CONDUCTIVITY)*1e-1
-        mu += np.random.randn(mesh.nC)*MU*1e-1
-
-    if useMu is True:
-        m = np.r_[logsig, mu]
-    else:
-        m = logsig
-
-    survey1 = prb1.survey
-    d1 = survey1.dpred(m)
-
-    if verbose:
-        print '  Problem 1 solved'
-
-
-    prb2 = getFDEMProblem(fdemType2, comp, SrcList, freq, useMu, verbose)
-
-    survey2 = prb2.survey
-    d2 = survey2.dpred(m)
-
-    if verbose:
-        print '  Problem 2 solved'
-
-    r = d2-d1
-    l2r = l2norm(r)
-
-    tol = np.max([TOL*(10**int(np.log10(0.5* (l2norm(d1) + l2norm(d2)) ))),FLR])
-    print l2norm(d1), l2norm(d2),  l2r , tol, l2r < tol
-    return l2r < tol

SimPEG/EM/__init__.py

@@ -1,6 +0,0 @@
-import TDEM
-import FDEM
-import Base
-import Analytics
-import Utils
-from scipy.constants import mu_0, epsilon_0

SimPEG/Examples/DC_Analytic_Dipole.py

@@ -1,68 +0,0 @@
-from SimPEG import *
-import SimPEG.DCIP as DC
-
-def run(plotIt=False):
-    cs = 25.
-    hx = [(cs,7, -1.3),(cs,21),(cs,7, 1.3)]
-    hy = [(cs,7, -1.3),(cs,21),(cs,7, 1.3)]
-    hz = [(cs,7, -1.3),(cs,20)]
-    mesh = Mesh.TensorMesh([hx, hy, hz], 'CCN')
-    sighalf = 1e-2
-    sigma = np.ones(mesh.nC)*sighalf
-    xtemp = np.linspace(-150, 150, 21)
-    ytemp = np.linspace(-150, 150, 21)
-    xyz_rxP = Utils.ndgrid(xtemp-10., ytemp, np.r_[0.])
-    xyz_rxN = Utils.ndgrid(xtemp+10., ytemp, np.r_[0.])
-    xyz_rxM = Utils.ndgrid(xtemp, ytemp, np.r_[0.])
-
-    # if plotIt:
-    #     fig, ax = plt.subplots(1,1, figsize = (5,5))
-    #     mesh.plotSlice(sigma, grid=True, ax = ax)
-    #     ax.plot(xyz_rxP[:,0],xyz_rxP[:,1], 'w.')
-    #     ax.plot(xyz_rxN[:,0],xyz_rxN[:,1], 'r.', ms = 3)
-
-    rx = DC.RxDipole(xyz_rxP, xyz_rxN)
-    src = DC.SrcDipole([rx], [-200, 0, -12.5], [+200, 0, -12.5])
-    survey = DC.SurveyDC([src])
-    problem = DC.ProblemDC_CC(mesh)
-    problem.pair(survey)
-    try:
-        from pymatsolver import MumpsSolver
-        problem.Solver = MumpsSolver
-    except Exception, e:
-        pass
-    data = survey.dpred(sigma)
-
-    def DChalf(srclocP, srclocN, rxloc, sigma, I=1.):
-        rp = (srclocP.reshape([1,-1])).repeat(rxloc.shape[0], axis = 0)
-        rn = (srclocN.reshape([1,-1])).repeat(rxloc.shape[0], axis = 0)
-        rP = np.sqrt(((rxloc-rp)**2).sum(axis=1))
-        rN = np.sqrt(((rxloc-rn)**2).sum(axis=1))
-        return I/(sigma*2.*np.pi)*(1/rP-1/rN)
-
-    data_anaP = DChalf(np.r_[-200, 0, 0.],np.r_[+200, 0, 0.], xyz_rxP, sighalf)
-    data_anaN = DChalf(np.r_[-200, 0, 0.],np.r_[+200, 0, 0.], xyz_rxN, sighalf)
-    data_ana = data_anaP-data_anaN
-    Data_ana = data_ana.reshape((21, 21), order = 'F')
-    Data = data.reshape((21, 21), order = 'F')
-    X = xyz_rxM[:,0].reshape((21, 21), order = 'F')
-    Y = xyz_rxM[:,1].reshape((21, 21), order = 'F')
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,2, figsize = (12, 5))
-        vmin = np.r_[data, data_ana].min()
-        vmax = np.r_[data, data_ana].max()
-        dat1 = ax[1].contourf(X, Y, Data, 60, vmin = vmin, vmax = vmax)
-        dat0 = ax[0].contourf(X, Y, Data_ana, 60, vmin = vmin, vmax = vmax)
-        cb0 = plt.colorbar(dat1, orientation = 'horizontal', ax = ax[0])
-        cb1 = plt.colorbar(dat1, orientation = 'horizontal', ax = ax[1])
-        ax[1].set_title('Analytic')
-        ax[0].set_title('Computed')
-        plt.show()
-
-    return np.linalg.norm(data-data_ana)/np.linalg.norm(data_ana)
-
-
-if __name__ == '__main__':
-    print run(plotIt=True)

SimPEG/Examples/DC_Forward_PseudoSection.py

@@ -1,210 +0,0 @@
-from SimPEG import Mesh, Utils, np, sp
-import SimPEG.DCIP as DC
-import time
-
-def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', dtype='appc', plotIt=True):
-    """
-        DC Forward Simulation
-        =====================
-
-        Forward model two conductive spheres in a half-space and plot a
-        pseudo-section. Assumes an infinite line source and measures along the
-        center of the spheres.
-
-        INPUT:
-        loc     = Location of spheres [[x1,y1,z1],[x2,y2,z2]]
-        radi    = Radius of spheres [r1,r2]
-        param   = Conductivity of background and two spheres [m0,m1,m2]
-        stype   = survey type "pdp" (pole dipole) or "dpdp" (dipole dipole)
-        dtype   = Data type "appr" (app res) | "appc" (app cond) | "volt" (potential)
-        Created by @fourndo
-
-    """
-
-    assert stype in ['pdp', 'dpdp'], "Source type (stype) must be pdp or dpdp (pole dipole or dipole dipole)"
-    assert dtype in ['appr', 'appc', 'volt'], "Data type (dtype) must be appr (app res) or appc (app cond) or volt (potential)"
-
-    if loc is None:
-        loc = np.c_[[-50.,0.,-50.],[50.,0.,-50.]]
-    if sig is None:
-        sig = np.r_[1e-2,1e-1,1e-3]
-    if radi is None:
-        radi = np.r_[25.,25.]
-    if param is None:
-        param = np.r_[30.,30.,5]
-
-
-    # First we need to create a mesh and a model.
-    # This is our mesh
-    dx    = 5.
-
-    hxind = [(dx,15,-1.3), (dx, 75), (dx,15,1.3)]
-    hyind = [(dx,15,-1.3), (dx, 10), (dx,15,1.3)]
-    hzind = [(dx,15,-1.3),(dx, 15)]
-
-    mesh = Mesh.TensorMesh([hxind, hyind, hzind], 'CCN')
-
-
-    # Set background conductivity
-    model = np.ones(mesh.nC) * sig[0]
-
-    # First anomaly
-    ind = Utils.ModelBuilder.getIndicesSphere(loc[:,0],radi[0],mesh.gridCC)
-    model[ind] = sig[1]
-
-    # Second anomaly
-    ind = Utils.ModelBuilder.getIndicesSphere(loc[:,1],radi[1],mesh.gridCC)
-    model[ind] = sig[2]
-
-    # Get index of the center
-    indy = int(mesh.nCy/2)
-
-    # Plot the model for reference
-    # Define core mesh extent
-    xlim = 200
-    zlim = 100
-
-    # Then specify the end points of the survey. Let's keep it simple for now and survey above the anomalies, top of the mesh
-    ends = [(-175,0),(175,0)]
-    ends = np.c_[np.asarray(ends),np.ones(2).T*mesh.vectorNz[-1]]
-
-    # Snap the endpoints to the grid. Easier to create 2D section.
-    indx = Utils.closestPoints(mesh, ends )
-    locs = np.c_[mesh.gridCC[indx,0],mesh.gridCC[indx,1],np.ones(2).T*mesh.vectorNz[-1]]
-
-    # We will handle the geometry of the survey for you and create all the combination of tx-rx along line
-    # [Tx, Rx] = DC.gen_DCIPsurvey(locs, mesh, stype, param[0], param[1], param[2])
-    survey, Tx, Rx = DC.gen_DCIPsurvey(locs, mesh, stype, param[0], param[1], param[2])
-
-    # Define some global geometry
-    dl_len = np.sqrt( np.sum((locs[0,:] - locs[1,:])**2) )
-    dl_x = ( Tx[-1][0,1] - Tx[0][0,0] ) / dl_len
-    dl_y = ( Tx[-1][1,1] - Tx[0][1,0]  ) / dl_len
-    #azm =  np.arctan(dl_y/dl_x)
-
-    #Set boundary conditions
-    mesh.setCellGradBC('neumann')
-
-    # Define the linear system needed for the DC problem. We assume an infitite
-    # line source for simplicity.
-    Div = mesh.faceDiv
-    Grad = mesh.cellGrad
-    Msig = Utils.sdiag(1./(mesh.aveF2CC.T*(1./model)))
-
-    A = Div*Msig*Grad
-
-    # Change one corner to deal with nullspace
-    A[0,0] = 1
-    A = sp.csc_matrix(A)
-
-    # We will solve the system iteratively, so a pre-conditioner is helpful
-    # This is simply a Jacobi preconditioner (inverse of the main diagonal)
-    dA = A.diagonal()
-    P = sp.spdiags(1/dA,0,A.shape[0],A.shape[0])
-
-    # Now we can solve the system for all the transmitters
-    # We want to store the data
-    data = []
-
-    # There is probably a more elegant way to do this, but we can just for-loop through the transmitters
-    for ii in range(len(Tx)):
-
-        start_time = time.time() # Let's time the calculations
-
-        #print("Transmitter %i / %i\r" % (ii+1,len(Tx)))
-
-        # Select dipole locations for receiver
-        rxloc_M = np.asarray(Rx[ii][:,0:3])
-        rxloc_N = np.asarray(Rx[ii][:,3:])
-
-
-        # For usual cases "dpdp" or "gradient"
-        if stype == 'pdp':
-            # Create an "inifinity" pole
-            tx =  np.squeeze(Tx[ii][:,0:1])
-            tinf = tx + np.array([dl_x,dl_y,0])*dl_len*2
-            inds = Utils.closestPoints(mesh, np.c_[tx,tinf].T)
-            RHS = mesh.getInterpolationMat(np.asarray(Tx[ii]).T, 'CC').T*( [-1] / mesh.vol[inds] )
-        else:
-            inds = Utils.closestPoints(mesh, np.asarray(Tx[ii]).T )
-            RHS = mesh.getInterpolationMat(np.asarray(Tx[ii]).T, 'CC').T*( [-1,1] / mesh.vol[inds] )
-
-        # Iterative Solve
-        Ainvb = sp.linalg.bicgstab(P*A,P*RHS, tol=1e-5)
-
-        # We now have the potential everywhere
-        phi = Utils.mkvc(Ainvb[0])
-
-        # Solve for phi on pole locations
-        P1 = mesh.getInterpolationMat(rxloc_M, 'CC')
-        P2 = mesh.getInterpolationMat(rxloc_N, 'CC')
-
-        # Compute the potential difference
-        dtemp = (P1*phi - P2*phi)*np.pi
-
-        data.append( dtemp )
-        print '\rTransmitter {0} of {1} -> Time:{2} sec'.format(ii,len(Tx),time.time()- start_time),
-
-    print 'Transmitter {0} of {1}'.format(ii,len(Tx))
-    print 'Forward completed'
-
-    # Let's just convert the 3D format into 2D (distance along line) and plot
-    survey2D = DC.convertObs_DC3D_to_2D(survey, np.ones(survey.nSrc) , 'Xloc')
-    survey2D.dobs =np.hstack(data)
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig = plt.figure(figsize=(7,7))
-        ax = plt.subplot(2,1,1, aspect='equal')
-        # Plot the location of the spheres for reference
-        circle1=plt.Circle((loc[0,0],loc[2,0]),radi[0],color='w',fill=False, lw=3)
-        circle2=plt.Circle((loc[0,1],loc[2,1]),radi[1],color='k',fill=False, lw=3)
-        ax.add_artist(circle1)
-        ax.add_artist(circle2)
-
-        dat = mesh.plotSlice(np.log10(model), ax =ax, normal = 'Y',
-                             ind = indy,grid=True, clim = np.log10([sig.min(),sig.max()]))
-
-        ax.set_title('3-D model')
-        plt.gca().set_aspect('equal', adjustable='box')
-
-        plt.scatter(Tx[0][0,:],Tx[0][2,:],s=40,c='g', marker='v')
-        plt.scatter(Rx[0][:,0::3],Rx[0][:,2::3],s=40,c='y')
-        plt.xlim([-xlim,xlim])
-        plt.ylim([-zlim,mesh.vectorNz[-1]+dx])
-
-
-        pos =  ax.get_position()
-        ax.set_position([pos.x0 , pos.y0 + 0.025 ,  pos.width, pos.height])
-        pos =  ax.get_position()
-        cbarax = fig.add_axes([pos.x0 , pos.y0 + 0.025 ,  pos.width, pos.height * 0.04])  ## the parameters are the specified position you set
-        cb = fig.colorbar(dat[0],cax=cbarax, orientation="horizontal",
-                          ax = ax, ticks=np.linspace(np.log10(sig.min()),
-                         np.log10(sig.max()), 3), format="$10^{%.1f}$")
-        cb.set_label("Conductivity (S/m)",size=12)
-        cb.ax.tick_params(labelsize=12)
-
-        # Second plot for the predicted apparent resistivity data
-        ax2 = plt.subplot(2,1,2, aspect='equal')
-
-        # Plot the location of the spheres for reference
-        circle1=plt.Circle((loc[0,0],loc[2,0]),radi[0],color='w',fill=False, lw=3)
-        circle2=plt.Circle((loc[0,1],loc[2,1]),radi[1],color='k',fill=False, lw=3)
-        ax2.add_artist(circle1)
-        ax2.add_artist(circle2)
-
-        # Add the speudo section
-        dat = DC.plot_pseudoSection(survey2D,ax2,stype=stype, dtype = dtype)
-
-        # plt.scatter(Tx2d[0][:],Tx[0][2,:],s=40,c='g', marker='v')
-        # plt.scatter(Rx2d[0][:],Rx[0][:,2::3],s=40,c='y')
-        # plt.plot(np.r_[Tx2d[0][0],Rx2d[-1][-1,-1]],np.ones(2)*mesh.vectorNz[-1], color='k')
-        ax2.set_title('Apparent Conductivity data')
-
-        plt.ylim([-zlim,mesh.vectorNz[-1]+dx])
-        plt.show()
-
-        return fig, ax
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/DCfwd.py

@@ -0,0 +1,71 @@
+from SimPEG import Mesh, Utils, np, SolverLU
+import matplotlib.pyplot as plt
+import matplotlib
+from matplotlib.mlab import griddata
+
+## 2D DC forward modeling example with Tensor and Curvilinear Meshes
+
+# Step1: Generate Tensor and Curvilinear Mesh
+sz = [40,40]
+# Tensor Mesh
+tM = Mesh.TensorMesh(sz)
+# Curvilinear Mesh
+rM = Mesh.CurvilinearMesh(Utils.meshutils.exampleLrmGrid(sz,'rotate'))
+
+# Step2: Direct Current (DC) operator
+def DCfun(mesh, pts):
+    D = mesh.faceDiv
+    G = D.T
+    sigma = 1e-2*np.ones(mesh.nC)
+    Msigi = mesh.getFaceInnerProduct(1./sigma)
+    MsigI = Utils.sdInv(Msigi)
+    A = D*MsigI*G
+    A[-1,-1] /= mesh.vol[-1] # Remove null space
+    rhs = np.zeros(mesh.nC)
+    txind = Utils.meshutils.closestPoints(mesh, pts)
+    rhs[txind] = np.r_[1,-1]
+    return A, rhs
+
+pts = np.vstack((np.r_[0.25, 0.5], np.r_[0.75, 0.5]))
+
+#Step3: Solve DC problem (LU solver)
+AtM, rhstM = DCfun(tM, pts)
+AinvtM = SolverLU(AtM)
+phitM = AinvtM*rhstM
+
+ArM, rhsrM = DCfun(rM, pts)
+AinvrM = SolverLU(ArM)
+phirM = AinvrM*rhsrM
+
+#Step4: Making Figure
+fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
+label = ["(a)", "(b)"]
+opts = {}
+vmin, vmax = phitM.min(), phitM.max()
+dat = tM.plotImage(phitM, ax=axes[0], clim=(vmin, vmax), grid=True)
+
+#TODO: At the moment Curvilinear Mesh do not have plotimage 
+
+Xi = tM.gridCC[:,0].reshape(sz[0], sz[1], order='F')
+Yi = tM.gridCC[:,1].reshape(sz[0], sz[1], order='F')
+PHIrM = griddata(rM.gridCC[:,0], rM.gridCC[:,1], phirM, Xi, Yi, interp='linear')
+axes[1].contourf(Xi, Yi, PHIrM, 100, vmin=vmin, vmax=vmax)
+
+cb = plt.colorbar(dat[0], ax=axes[0]); cb.set_label("Voltage (V)")
+cb = plt.colorbar(dat[0], ax=axes[1]); cb.set_label("Voltage (V)")
+
+tM.plotGrid(ax=axes[0], **opts)
+axes[0].set_title('TensorMesh')
+rM.plotGrid(ax=axes[1], **opts)
+axes[1].set_title('CurvilinearMesh')
+for i in range(2):
+    axes[i].set_xlim(0.025, 0.975)
+    axes[i].set_ylim(0.025, 0.975)
+    axes[i].text(0., 1.0, label[i], fontsize=20)
+    if i==0:        
+        axes[i].set_ylabel("y")
+    else:
+        axes[i].set_ylabel(" ")
+    axes[i].set_xlabel("x")
+
+plt.show()

SimPEG/Examples/EM_FDEM_1D_Inversion.py

@@ -1,115 +0,0 @@
-from SimPEG import *
-import SimPEG.EM as EM
-from SimPEG.EM import mu_0
-
-
-def run(plotIt=True):
-    """
-        EM: FDEM: 1D: Inversion
-        =======================
-
-        Here we will create and run a FDEM 1D inversion.
-
-    """
-
-    cs, ncx, ncz, npad = 5., 25, 15, 15
-    hx = [(cs,ncx), (cs,npad,1.3)]
-    hz = [(cs,npad,-1.3), (cs,ncz), (cs,npad,1.3)]
-    mesh = Mesh.CylMesh([hx,1,hz], '00C')
-
-    layerz = -100.
-
-    active = mesh.vectorCCz<0.
-    layer = (mesh.vectorCCz<0.) & (mesh.vectorCCz>=layerz)
-    actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
-    mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap
-    sig_half = 2e-2
-    sig_air = 1e-8
-    sig_layer = 1e-2
-    sigma = np.ones(mesh.nCz)*sig_air
-    sigma[active] = sig_half
-    sigma[layer] = sig_layer
-    mtrue = np.log(sigma[active])
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,1, figsize = (3, 6))
-        plt.semilogx(sigma[active], mesh.vectorCCz[active])
-        ax.set_ylim(-500, 0)
-        ax.set_xlim(1e-3, 1e-1)
-        ax.set_xlabel('Conductivity (S/m)', fontsize = 14)
-        ax.set_ylabel('Depth (m)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-
-
-    rxOffset=10. 
-    bzi = EM.FDEM.Rx(np.array([[rxOffset, 0., 1e-3]]), 'bzi')
-
-    freqs = np.logspace(1,3,10)
-    srcLoc = np.array([0., 0., 10.])
-
-    srcList = [EM.FDEM.Src.MagDipole([bzi],freq, srcLoc,orientation='Z') for freq in freqs]
-
-    survey = EM.FDEM.Survey(srcList)
-    prb = EM.FDEM.Problem_b(mesh, mapping=mapping)
-
-    try:
-        from pymatsolver import MumpsSolver
-        prb.Solver = MumpsSolver
-    except ImportError, e:
-        prb.Solver = SolverLU
-
-    prb.pair(survey)
-
-    std = 0.05
-    survey.makeSyntheticData(mtrue, std)
-
-    survey.std = std
-    survey.eps = np.linalg.norm(survey.dtrue)*1e-5
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,1, figsize = (6, 6))
-        ax.semilogx(freqs,survey.dtrue[:freqs.size], 'b.-')
-        ax.semilogx(freqs,survey.dobs[:freqs.size], 'r.-')
-        ax.legend(('Noisefree', '$d^{obs}$'), fontsize = 16)
-        ax.set_xlabel('Time (s)', fontsize = 14)
-        ax.set_ylabel('$B_z$ (T)', fontsize = 16)
-        ax.set_xlabel('Time (s)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-
-    dmisfit = DataMisfit.l2_DataMisfit(survey)
-    regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
-    reg = Regularization.Tikhonov(regMesh)
-    opt = Optimization.InexactGaussNewton(maxIter = 6)
-    invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)
-
-    # Create an inversion object
-    beta = Directives.BetaSchedule(coolingFactor=5, coolingRate=2)
-    betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1e0)
-    inv = Inversion.BaseInversion(invProb, directiveList=[beta,betaest])
-    m0 = np.log(np.ones(mtrue.size)*sig_half)
-    reg.alpha_s = 1e-3
-    reg.alpha_x = 1.
-    prb.counter = opt.counter = Utils.Counter()
-    opt.LSshorten = 0.5
-    opt.remember('xc')
-
-    mopt = inv.run(m0)
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,1, figsize = (3, 6))
-        plt.semilogx(sigma[active], mesh.vectorCCz[active])
-        plt.semilogx(np.exp(mopt), mesh.vectorCCz[active])
-        ax.set_ylim(-500, 0)
-        ax.set_xlim(1e-3, 1e-1)
-        ax.set_xlabel('Conductivity (S/m)', fontsize = 14)
-        ax.set_ylabel('Depth (m)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-        plt.legend(['$\sigma_{true}$', '$\sigma_{pred}$'],loc='best')
-        plt.show()
-
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/EM_FDEM_Analytic_MagDipoleWholespace.py

@@ -1,43 +0,0 @@
-from SimPEG import *
-import SimPEG.EM as EM
-
-def run(XYZ=None, loc=np.r_[0.,0.,0.], sig=1.0, freq=1.0, orientation='Z', plotIt=True):
-    """
-        EM: Magnetic Dipole in a Whole-Space
-        ====================================
-
-        Here we plot the magnetic flux density from a harmonic dipole in a wholespace.
-
-    """
-
-    if XYZ is None:
-        x = np.arange(-100.5,100.5,step = 1.) #(avoid putting measurement points where source is located)
-        y = np.r_[0]
-        z = x
-        XYZ = Utils.ndgrid(x,y,z)
-
-
-    Bx, By, Bz = EM.Analytics.FDEM.MagneticDipoleWholeSpace(XYZ, loc, sig, freq, orientation=orientation)
-    absB = np.sqrt(Bx*Bx.conj()+By*By.conj()+Bz*Bz.conj()).real
-
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        from matplotlib.colors import LogNorm
-        fig, ax = plt.subplots(1,1,figsize=(6,5))
-        bxplt = Bx.reshape(x.size,z.size)
-        bzplt = Bz.reshape(x.size,z.size)
-        pc = ax.pcolor(x,z,absB.reshape(x.size,z.size),norm=LogNorm())
-        ax.streamplot(x,z,bxplt.real,bzplt.real,color='k',density=1)
-        ax.set_xlim([x.min(),x.max()])
-        ax.set_ylim([z.min(),z.max()])
-        ax.set_xlabel('x')
-        ax.set_ylabel('z')
-        cb = plt.colorbar(pc,ax = ax)
-        cb.set_label('|B| (T)')
-        plt.show()
-
-        return fig, ax
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/EM_Schenkel_Morrison_Casing.py

@@ -1,275 +0,0 @@
-from SimPEG import *
-from SimPEG.EM import FDEM, Analytics, mu_0
-import time
-
-try:
-    from pymatsolver import MumpsSolver
-    solver = MumpsSolver
-except Exception:
-    solver = SolverLU
-    pass
-
-def run(plotIt=True):
-    """
-        EM: Schenkel and Morrison Casing Model
-        ======================================
-
-        Here we create and run a FDEM forward simulation to calculate the vertical
-        current inside a steel-cased. The model is based on the Schenkel and
-        Morrison Casing Model, and the results are used in a 2016 SEG abstract by
-        Yang et al.
-
-        - Schenkel, C.J., and H.F. Morrison, 1990, Effects of well casing on potential field measurements using downhole current sources: Geophysical prospecting, 38, 663-686.
-
-
-        The model consists of:
-        - Air: Conductivity 1e-8 S/m, above z = 0
-        - Background: conductivity 1e-2 S/m, below z = 0
-        - Casing: conductivity 1e6 S/m
-            - 300m long
-            - radius of 0.1m
-            - thickness of 6e-3m
-
-        Inside the casing, we take the same conductivity as the background.
-
-        We are using an EM code to simulate DC, so we use frequency low enough
-        that the skin depth inside the casing is longer than the casing length (f
-        = 1e-6 Hz). The plot produced is of the current inside the casing.
-
-        These results are shown in the SEG abstract by Yang et al., 2016: 3D DC
-        resistivity modeling of steel casing for reservoir monitoring using
-        equivalent resistor network. The solver used to produce these results and
-        achieve the CPU time of ~30s is Mumps, which was installed using pymatsolver_
-
-        .. _pymatsolver: https://github.com/rowanc1/pymatsolver
-
-        This example is on figshare: https://dx.doi.org/10.6084/m9.figshare.3126961.v1
-
-        If you would use this example for a code comparison, or build upon it, a
-        citation would be much appreciated!
-
-    """
-
-    if plotIt:
-        import matplotlib.pylab as plt
-
-    # ------------------ MODEL ------------------
-    sigmaair = 1e-8 # air
-    sigmaback = 1e-2 # background
-    sigmacasing = 1e6 # casing
-    sigmainside = sigmaback # inside the casing
-
-
-    casing_t = 0.006  # 1cm thickness
-    casing_l = 300   # length of the casing
-
-    casing_r = 0.1
-    casing_a = casing_r - casing_t/2. # inner radius
-    casing_b = casing_r + casing_t/2. # outer radius
-    casing_z = np.r_[-casing_l,0.]
-
-
-    # ------------------ SURVEY PARAMETERS ------------------
-    freqs = np.r_[1e-6] #[1e-1, 1, 5] # frequencies
-    dsz = -300 # down-hole z source location
-    src_loc = np.r_[0.,0.,dsz]
-    inf_loc = np.r_[0.,0.,1e4]
-
-    print 'Skin Depth: ', [(500./np.sqrt(sigmaback*_)) for _ in freqs]
-
-
-    # ------------------ MESH ------------------
-    # fine cells near well bore
-    csx1, csx2 = 2e-3, 60.
-    pfx1, pfx2 = 1.3, 1.3
-    ncx1 = np.ceil(casing_b/csx1+2)
-
-    # pad nicely to second cell size
-    npadx1 = np.floor(np.log(csx2/csx1) / np.log(pfx1))
-    hx1a,hx1b = Utils.meshTensor([(csx1,ncx1)]),Utils.meshTensor([(csx1,npadx1,pfx1)])
-    dx1 = sum(hx1a)+sum(hx1b)
-    dx1 = np.floor(dx1/csx2)
-    hx1b *= (dx1*csx2 - sum(hx1a))/sum(hx1b)
-
-    # second chunk of mesh
-    dx2 = 300. # uniform mesh out to here
-    ncx2 = np.ceil((dx2 - dx1)/csx2)
-    npadx2 = 45
-    hx2a, hx2b = Utils.meshTensor([(csx2,ncx2)]), Utils.meshTensor([(csx2,npadx2,pfx2)])
-    hx = np.hstack([hx1a,hx1b,hx2a,hx2b])
-
-    # z-direction
-    csz = 0.05
-    nza = 10
-    ncz, npadzu, npadzd = np.int(np.ceil(np.diff(casing_z)[0]/csz))+10, 68, 68 # cell size, number of core cells, number of padding cells in the x- direction
-    hz = Utils.meshTensor([(csz,npadzd,-1.3), (csz,ncz), (csz,npadzu,1.3)]) # vector of cell widths in the z-direction
-
-    # Mesh
-    mesh = Mesh.CylMesh([hx,1.,hz], [0.,0.,-np.sum(hz[:npadzu+ncz-nza])])
-
-    print 'Mesh Extent xmax: %f,: zmin: %f, zmax: %f'%(mesh.vectorCCx.max(), mesh.vectorCCz.min(), mesh.vectorCCz.max())
-    print 'Number of cells', mesh.nC
-
-    if plotIt is True:
-        fig, ax = plt.subplots(1, 1, figsize=(6, 4))
-        ax.set_title('Simulation Mesh')
-        mesh.plotGrid(ax=ax)
-        plt.show()
-
-    # Put the model on the mesh
-    sigWholespace = sigmaback*np.ones((mesh.nC))
-
-    sigBack = sigWholespace.copy()
-    sigBack[mesh.gridCC[:,2] > 0.] = sigmaair
-
-    sigCasing = sigBack.copy()
-    iCasingZ = (mesh.gridCC[:,2] <= casing_z[1]) & (mesh.gridCC[:,2] >= casing_z[0])
-    iCasingX = (mesh.gridCC[:,0] >= casing_a) & (mesh.gridCC[:,0] <= casing_b)
-    iCasing = iCasingX & iCasingZ
-    sigCasing[iCasing] = sigmacasing
-
-
-    if plotIt is True:
-
-        # plotting parameters
-        xlim = np.r_[0., 0.2]
-        zlim = np.r_[-350., 10.]
-        clim_sig = np.r_[-8,6]
-
-        # plot models
-        fig, ax = plt.subplots(1,1,figsize=(4,4))
-
-        f = plt.colorbar(mesh.plotImage(np.log10(sigCasing),ax=ax)[0], ax=ax)
-        ax.grid(which='both')
-        ax.set_title('Log_10 (Sigma)')
-        ax.set_xlim(xlim)
-        ax.set_ylim(zlim)
-        f.set_clim(clim_sig)
-
-        plt.show()
-
-
-    # -------------- Sources --------------------
-    # Define Custom Current Sources
-
-    # surface source
-    sg_x = np.zeros(mesh.vnF[0],dtype=complex)
-    sg_y = np.zeros(mesh.vnF[1],dtype=complex)
-    sg_z = np.zeros(mesh.vnF[2],dtype=complex)
-
-    nza = 2 # put the wire two cells above the surface
-    ncin = 2
-
-    # vertically directed wire
-    sgv_indx = (mesh.gridFz[:,0] > casing_a) & (mesh.gridFz[:,0] < casing_a + csx1)  # hook it up to casing at the surface
-    sgv_indz = (mesh.gridFz[:,2] <= +csz*nza) & (mesh.gridFz[:,2] >= -csz*2)
-    sgv_ind = sgv_indx & sgv_indz
-    sg_z[sgv_ind] = -1.
-
-    # horizontally directed wire
-    sgh_indx = (mesh.gridFx[:,0] > casing_a)    & (mesh.gridFx[:,0] <= inf_loc[2])
-    sgh_indz = (mesh.gridFx[:,2] > csz*(nza-0.5)) & (mesh.gridFx[:,2] < csz*(nza+0.5))
-    sgh_ind = sgh_indx & sgh_indz
-    sg_x[sgh_ind] = -1.
-
-    sgv2_indx = (mesh.gridFz[:,0] >= mesh.gridFx[sgh_ind,0].max()) & (mesh.gridFz[:,0] <= inf_loc[2]*1.2)  # hook it up to casing at the surface
-    sgv2_indz = (mesh.gridFz[:,2] <= +csz*nza) & (mesh.gridFz[:,2] >= -csz*2)
-    sgv2_ind = sgv2_indx & sgv2_indz
-    sg_z[sgv2_ind] = 1.
-
-    # assemble the source
-    sg = np.hstack([sg_x,sg_y,sg_z])
-    sg_p = [FDEM.Src.RawVec_e([],_,sg/mesh.area) for _ in freqs]
-
-    # downhole source
-    dg_x = np.zeros(mesh.vnF[0],dtype=complex)
-    dg_y = np.zeros(mesh.vnF[1],dtype=complex)
-    dg_z = np.zeros(mesh.vnF[2],dtype=complex)
-
-    # vertically directed wire
-    dgv_indx = (mesh.gridFz[:,0] < csx1)  # go through the center of the well
-    dgv_indz = (mesh.gridFz[:,2] <= +csz*nza) & (mesh.gridFz[:,2] > dsz + csz/2.)
-    dgv_ind = dgv_indx & dgv_indz
-    dg_z[dgv_ind] = -1.
-
-    # couple to the casing downhole
-    dgh_indx = mesh.gridFx[:,0] < casing_a + csx1
-    dgh_indz = (mesh.gridFx[:,2] < dsz + csz)  & (mesh.gridFx[:,2] >= dsz)
-    dgh_ind = dgh_indx & dgh_indz
-    dg_x[dgh_ind] = 1.
-
-    # horizontal part at surface
-    dgh2_indx = mesh.gridFx[:,0] <= inf_loc[2]*1.2
-    dgh2_indz = sgh_indz.copy()
-    dgh2_ind = dgh2_indx & dgh2_indz
-    dg_x[dgh2_ind] = -1.
-
-    # vertical part at surface
-    dgv2_ind = sgv2_ind.copy()
-    dg_z[dgv2_ind] = 1.
-
-    # assemble the source
-    dg = np.hstack([dg_x,dg_y,dg_z])
-    dg_p = [FDEM.Src.RawVec_e([],_,dg/mesh.area) for _ in freqs]
-
-    # ------------ Problem and Survey ---------------
-    survey = FDEM.Survey(sg_p + dg_p)
-    mapping = [('sigma', Maps.IdentityMap(mesh))]
-    problem = FDEM.Problem_h(mesh, mapping=mapping)
-    problem.pair(survey)
-
-    # ------------- Solve ---------------------------
-    t0 = time.time()
-    fieldsCasing = problem.fields(sigCasing)
-    print 'Time to solve 2 sources', time.time() - t0
-
-    # Plot current
-
-    # current density
-    jn0 = fieldsCasing[dg_p,'j']
-    jn1 = fieldsCasing[sg_p,'j']
-
-    # current
-    in0 = [mesh.area*fieldsCasing[dg_p,'j'][:,i] for i in range(len(freqs))]
-    in1 = [mesh.area*fieldsCasing[sg_p,'j'][:,i] for i in range(len(freqs))]
-
-    in0 = np.vstack(in0).T
-    in1 = np.vstack(in1).T
-
-    # integrate to get z-current inside casing
-    inds_inx = (mesh.gridFz[:,0] >= casing_a) & (mesh.gridFz[:,0] <= casing_b)
-    inds_inz = (mesh.gridFz[:,2] >= dsz )     & (mesh.gridFz[:,2] <= 0)
-    inds_fz = inds_inx & inds_inz
-
-    indsx = [False]*mesh.nFx
-    inds = list(indsx) + list(inds_fz)
-
-    in0_in = in0[np.r_[inds]]
-    in1_in = in1[np.r_[inds]]
-    z_in = mesh.gridFz[inds_fz,2]
-
-    in0_in = in0_in.reshape([in0_in.shape[0]/3,3])
-    in1_in = in1_in.reshape([in1_in.shape[0]/3,3])
-    z_in = z_in.reshape([z_in.shape[0]/3,3])
-
-    I0 = in0_in.sum(1).real
-    I1 = in1_in.sum(1).real
-    z_in = z_in[:,0]
-
-    if plotIt is True:
-        fig, ax = plt.subplots(1,2,figsize=(12,4))
-
-        ax[0].plot(z_in,np.absolute(I0), z_in,np.absolute(I1))
-        ax[0].legend(['top casing', 'bottom casing'],loc='best')
-        ax[0].set_title('Magnitude of Vertical Current in Casing')
-
-        ax[1].semilogy(z_in,np.absolute(I0), z_in,np.absolute(I1))
-        ax[1].legend(['top casing', 'bottom casing'],loc='best')
-        ax[1].set_title('Magnitude of Vertical Current in Casing')
-        ax[1].set_ylim([1e-2, 1.])
-
-        plt.show()
-
-if __name__ == '__main__':
-    run()
-

SimPEG/Examples/EM_TDEM_1D_Inversion.py

@@ -1,106 +0,0 @@
-from SimPEG import *
-import SimPEG.EM as EM
-from SimPEG.EM import mu_0
-
-
-def run(plotIt=True):
-    """
-        EM: TDEM: 1D: Inversion
-        =======================
-
-        Here we will create and run a TDEM 1D inversion.
-
-    """
-
-    cs, ncx, ncz, npad = 5., 25, 15, 15
-    hx = [(cs,ncx), (cs,npad,1.3)]
-    hz = [(cs,npad,-1.3), (cs,ncz), (cs,npad,1.3)]
-    mesh = Mesh.CylMesh([hx,1,hz], '00C')
-
-    active = mesh.vectorCCz<0.
-    layer = (mesh.vectorCCz<0.) & (mesh.vectorCCz>=-100.)
-    actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
-    mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap
-    sig_half = 2e-3
-    sig_air = 1e-8
-    sig_layer = 1e-3
-    sigma = np.ones(mesh.nCz)*sig_air
-    sigma[active] = sig_half
-    sigma[layer] = sig_layer
-    mtrue = np.log(sigma[active])
-
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,1, figsize = (3, 6))
-        plt.semilogx(sigma[active], mesh.vectorCCz[active])
-        ax.set_ylim(-600, 0)
-        ax.set_xlim(1e-4, 1e-2)
-        ax.set_xlabel('Conductivity (S/m)', fontsize = 14)
-        ax.set_ylabel('Depth (m)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-
-
-    rxOffset=1e-3
-    rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 30]]), np.logspace(-5,-3, 31), 'bz')
-    src = EM.TDEM.SrcTDEM_VMD_MVP([rx], np.array([0., 0., 80]))
-    survey = EM.TDEM.SurveyTDEM([src])
-    prb = EM.TDEM.ProblemTDEM_b(mesh, mapping=mapping)
-
-    prb.Solver = SolverLU
-    prb.timeSteps = [(1e-06, 20),(1e-05, 20), (0.0001, 20)]
-    prb.pair(survey)
-
-    # create observed data
-    std = 0.05
-    
-    survey.dobs = survey.makeSyntheticData(mtrue,std)
-    survey.std = std 
-    survey.eps = 1e-5*np.linalg.norm(survey.dobs)
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,1, figsize = (10, 6))
-        ax.loglog(rx.times, survey.dtrue, 'b.-')
-        ax.loglog(rx.times, survey.dobs, 'r.-')
-        ax.legend(('Noisefree', '$d^{obs}$'), fontsize = 16)
-        ax.set_xlabel('Time (s)', fontsize = 14)
-        ax.set_ylabel('$B_z$ (T)', fontsize = 16)
-        ax.set_xlabel('Time (s)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-
-    dmisfit = DataMisfit.l2_DataMisfit(survey)
-    regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
-    reg = Regularization.Tikhonov(regMesh)
-    opt = Optimization.InexactGaussNewton(maxIter = 5)
-    invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)
-
-    # Create an inversion object
-    beta = Directives.BetaSchedule(coolingFactor=5, coolingRate=2)
-    betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1e0)
-    inv = Inversion.BaseInversion(invProb, directiveList=[beta,betaest])
-    m0 = np.log(np.ones(mtrue.size)*sig_half)
-    reg.alpha_s = 1e-2
-    reg.alpha_x = 1.
-    prb.counter = opt.counter = Utils.Counter()
-    opt.LSshorten = 0.5
-    opt.remember('xc')
-
-    mopt = inv.run(m0)
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, ax = plt.subplots(1,1, figsize = (3, 6))
-        plt.semilogx(sigma[active], mesh.vectorCCz[active])
-        plt.semilogx(np.exp(mopt), mesh.vectorCCz[active])
-        ax.set_ylim(-600, 0)
-        ax.set_xlim(1e-4, 1e-2)
-        ax.set_xlabel('Conductivity (S/m)', fontsize = 14)
-        ax.set_ylabel('Depth (m)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-        plt.legend(['$\sigma_{true}$', '$\sigma_{pred}$'])
-        plt.show()
-
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/FLOW_Richards_1D_Celia1990.py

@@ -1,86 +0,0 @@
-from SimPEG import *
-from SimPEG.FLOW import Richards
-
-def run(plotIt=True):
-    """
-        FLOW: Richards: 1D: Celia1990
-        =============================
-
-        There are two different forms of Richards equation that differ
-        on how they deal with the non-linearity in the time-stepping term.
-
-        The most fundamental form, referred to as the
-        'mixed'-form of Richards Equation Celia1990_
-
-        .. math::
-
-            \\frac{\partial \\theta(\psi)}{\partial t} - \\nabla \cdot k(\psi) \\nabla \psi - \\frac{\partial k(\psi)}{\partial z} = 0
-            \quad \psi \in \Omega
-
-        where \\\\(\\\\theta\\\\) is water content, and \\\\(\\\\psi\\\\) is pressure head.
-        This formulation of Richards equation is called the
-        'mixed'-form because the equation is parameterized in \\\\(\\\\psi\\\\)
-        but the time-stepping is in terms of \\\\(\\\\theta\\\\).
-
-        As noted in Celia1990_ the 'head'-based form of Richards
-        equation can be written in the continuous form as:
-
-        .. math::
-
-            \\frac{\partial \\theta}{\partial \psi}\\frac{\partial \psi}{\partial t} - \\nabla \cdot k(\psi) \\nabla \psi - \\frac{\partial k(\psi)}{\partial z} = 0 \quad \psi \in \Omega
-
-        However, it can be shown that this does not conserve mass in the discrete formulation.
-
-        Here we reproduce the results from Celia1990_ demonstrating the head-based formulation and the mixed-formulation.
-
-        .. _Celia1990: http://www.webpages.uidaho.edu/ch/papers/Celia.pdf
-    """
-    M = Mesh.TensorMesh([np.ones(40)])
-    M.setCellGradBC('dirichlet')
-    params = Richards.Empirical.HaverkampParams().celia1990
-    params['Ks'] = np.log(params['Ks'])
-    E = Richards.Empirical.Haverkamp(M, **params)
-
-    bc = np.array([-61.5,-20.7])
-    h = np.zeros(M.nC) + bc[0]
-
-
-    def getFields(timeStep,method):
-        timeSteps = np.ones(360/timeStep)*timeStep
-        prob = Richards.RichardsProblem(M, mapping=E, timeSteps=timeSteps,
-                                        boundaryConditions=bc, initialConditions=h,
-                                        doNewton=False, method=method)
-        return prob.fields(params['Ks'])
-
-    Hs_M10 = getFields(10., 'mixed')
-    Hs_M30 = getFields(30., 'mixed')
-    Hs_M120= getFields(120.,'mixed')
-    Hs_H10 = getFields(10., 'head')
-    Hs_H30 = getFields(30., 'head')
-    Hs_H120= getFields(120.,'head')
-
-    if not plotIt:return
-    import matplotlib.pyplot as plt
-    plt.figure(figsize=(13,5))
-    plt.subplot(121)
-    plt.plot(40-M.gridCC, Hs_M10[-1],'b-')
-    plt.plot(40-M.gridCC, Hs_M30[-1],'r-')
-    plt.plot(40-M.gridCC, Hs_M120[-1],'k-')
-    plt.ylim([-70,-10])
-    plt.title('Mixed Method')
-    plt.xlabel('Depth, cm')
-    plt.ylabel('Pressure Head, cm')
-    plt.legend(('$\Delta t$ = 10 sec','$\Delta t$ = 30 sec','$\Delta t$ = 120 sec'))
-    plt.subplot(122)
-    plt.plot(40-M.gridCC, Hs_H10[-1],'b-')
-    plt.plot(40-M.gridCC, Hs_H30[-1],'r-')
-    plt.plot(40-M.gridCC, Hs_H120[-1],'k-')
-    plt.ylim([-70,-10])
-    plt.title('Head-Based Method')
-    plt.xlabel('Depth, cm')
-    plt.ylabel('Pressure Head, cm')
-    plt.legend(('$\Delta t$ = 10 sec','$\Delta t$ = 30 sec','$\Delta t$ = 120 sec'))
-    plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Forward_BasicDirectCurrent.py

@@ -1,77 +0,0 @@
-from SimPEG import Mesh, Utils, np, SolverLU
-
-## 2D DC forward modeling example with Tensor and Curvilinear Meshes
-
-def run(plotIt=True):
-    # Step1: Generate Tensor and Curvilinear Mesh
-    sz = [40,40]
-    # Tensor Mesh
-    tM = Mesh.TensorMesh(sz)
-    # Curvilinear Mesh
-    rM = Mesh.CurvilinearMesh(Utils.meshutils.exampleLrmGrid(sz,'rotate'))
-    # Step2: Direct Current (DC) operator
-    def DCfun(mesh, pts):
-        D = mesh.faceDiv
-        G = D.T
-        sigma = 1e-2*np.ones(mesh.nC)
-        Msigi = mesh.getFaceInnerProduct(1./sigma)
-        MsigI = Utils.sdInv(Msigi)
-        A = D*MsigI*G
-        A[-1,-1] /= mesh.vol[-1] # Remove null space
-        rhs = np.zeros(mesh.nC)
-        txind = Utils.meshutils.closestPoints(mesh, pts)
-        rhs[txind] = np.r_[1,-1]
-        return A, rhs
-
-    pts = np.vstack((np.r_[0.25, 0.5], np.r_[0.75, 0.5]))
-
-    #Step3: Solve DC problem (LU solver)
-    AtM, rhstM = DCfun(tM, pts)
-    AinvtM = SolverLU(AtM)
-    phitM = AinvtM*rhstM
-
-    ArM, rhsrM = DCfun(rM, pts)
-    AinvrM = SolverLU(ArM)
-    phirM = AinvrM*rhsrM
-
-    if not plotIt: return
-
-    import matplotlib.pyplot as plt
-    import matplotlib
-    from matplotlib.mlab import griddata
-
-    #Step4: Making Figure
-    fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
-    label = ["(a)", "(b)"]
-    opts = {}
-    vmin, vmax = phitM.min(), phitM.max()
-    dat = tM.plotImage(phitM, ax=axes[0], clim=(vmin, vmax), grid=True)
-
-    #TODO: At the moment Curvilinear Mesh do not have plotimage
-
-    Xi = tM.gridCC[:,0].reshape(sz[0], sz[1], order='F')
-    Yi = tM.gridCC[:,1].reshape(sz[0], sz[1], order='F')
-    PHIrM = griddata(rM.gridCC[:,0], rM.gridCC[:,1], phirM, Xi, Yi, interp='linear')
-    axes[1].contourf(Xi, Yi, PHIrM, 100, vmin=vmin, vmax=vmax)
-
-    cb = plt.colorbar(dat[0], ax=axes[0]); cb.set_label("Voltage (V)")
-    cb = plt.colorbar(dat[0], ax=axes[1]); cb.set_label("Voltage (V)")
-
-    tM.plotGrid(ax=axes[0], **opts)
-    axes[0].set_title('TensorMesh')
-    rM.plotGrid(ax=axes[1], **opts)
-    axes[1].set_title('CurvilinearMesh')
-    for i in range(2):
-        axes[i].set_xlim(0.025, 0.975)
-        axes[i].set_ylim(0.025, 0.975)
-        axes[i].text(0., 1.0, label[i], fontsize=20)
-        if i==0:
-            axes[i].set_ylabel("y")
-        else:
-            axes[i].set_ylabel(" ")
-        axes[i].set_xlabel("x")
-    plt.show()
-
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Inversion_IRLS.py

@@ -1,132 +0,0 @@
-from SimPEG import *
-
-
-def run(N=200, plotIt=True):
-    """
-        Inversion: Linear Problem
-        =========================
-
-        Here we go over the basics of creating a linear problem and inversion.
-
-    """
-
-
-    np.random.seed(1)
-
-    std_noise = 1e-2
-
-    mesh = Mesh.TensorMesh([N])
-
-    m0 = np.ones(mesh.nC) * 1e-4
-    nk = 10
-    jk = np.linspace(1.,nk,nk)
-    p = -2.
-    q = 1.
-
-    g = lambda k: np.exp(p*jk[k]*mesh.vectorCCx)*np.cos(np.pi*q*jk[k]*mesh.vectorCCx)
-
-    G = np.empty((nk, mesh.nC))
-
-    for i in range(nk):
-        G[i,:] = g(i)
-
-    mtrue = np.zeros(mesh.nC)
-    mtrue[mesh.vectorCCx > 0.3] = 1.
-    mtrue[mesh.vectorCCx > 0.45] = -0.5
-    mtrue[mesh.vectorCCx > 0.6] = 0
-
-
-    prob = Problem.LinearProblem(mesh, G)
-    survey = Survey.LinearSurvey()
-    survey.pair(prob)
-    survey.dobs = prob.fields(mtrue) + std_noise * np.random.randn(nk)
-    #survey.makeSyntheticData(mtrue, std=std_noise)
-
-    wd = np.ones(nk) * std_noise
-
-    #print survey.std[0]
-    #M = prob.mesh
-    # Distance weighting
-    wr = np.sum(prob.G**2.,axis=0)**0.5
-    wr = ( wr/np.max(wr) )
-
-    reg = Regularization.Simple(mesh)
-    reg.wght = wr
-
-    dmis = DataMisfit.l2_DataMisfit(survey)
-    dmis.Wd = 1./wd
-
-    opt = Optimization.ProjectedGNCG(maxIter=30,lower=-2.,upper=2., maxIterCG= 20, tolCG = 1e-4)
-    invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
-    invProb.curModel = m0
-
-    beta = Directives.BetaSchedule(coolingFactor=2, coolingRate=1)
-    target = Directives.TargetMisfit()
-
-    betaest = Directives.BetaEstimate_ByEig()
-    inv = Inversion.BaseInversion(invProb, directiveList=[beta, betaest, target])
-
-
-    mrec = inv.run(m0)
-    ml2 = mrec
-    print "Final misfit:" + str(invProb.dmisfit.eval(mrec))
-
-    # Switch regularization to sparse
-    phim = invProb.phi_m_last
-    phid =  invProb.phi_d
-
-    reg = Regularization.Sparse(mesh)
-
-#==============================================================================
-#     fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
-#     dmdx = reg.mesh.cellDiffxStencil * mrec
-#     plt.plot(np.sort(dmdx))
-#==============================================================================
-
-    #reg.recModel = mrec
-    reg.wght = np.ones(mesh.nC)
-    reg.mref = np.zeros(mesh.nC)
-    reg.eps_p = 5e-2
-    reg.eps_q = 1e-2
-    reg.norms   = [0., 0., 2., 2.]
-    reg.wght = wr
-
-    opt = Optimization.ProjectedGNCG(maxIter=10 ,lower=-2.,upper=2., maxIterLS = 20, maxIterCG= 20, tolCG = 1e-3)
-    invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta = invProb.beta*2.)
-    beta = Directives.BetaSchedule(coolingFactor=1, coolingRate=1)
-    #betaest = Directives.BetaEstimate_ByEig()
-    target = Directives.TargetMisfit()
-    IRLS =Directives.Update_IRLS( phi_m_last = phim, phi_d_last = phid )
-
-    inv = Inversion.BaseInversion(invProb, directiveList=[beta,IRLS])
-
-    m0 = mrec
-
-    # Run inversion
-    mrec = inv.run(m0)
-
-    print "Final misfit:" + str(invProb.dmisfit.eval(mrec))
-
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-
-        fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
-        for i in range(prob.G.shape[0]):
-            axes[0].plot(prob.G[i,:])
-        axes[0].set_title('Columns of matrix G')
-
-        axes[1].plot(mesh.vectorCCx, mtrue, 'b-')
-        axes[1].plot(mesh.vectorCCx, ml2, 'r-')
-        #axes[1].legend(('True Model', 'Recovered Model'))
-        axes[1].set_ylim(-1.0,1.25)
-
-        axes[1].plot(mesh.vectorCCx, mrec, 'k-',lw = 2)
-        axes[1].legend(('True Model', 'Smooth l2-l2',
-        'Sparse lp:' + str(reg.norms[0]) + ', lqx:' + str(reg.norms[1]) ), fontsize = 12)
-        plt.show()
-
-    return prob, survey, mesh, mrec
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Linear.py

@@ -1,17 +1,29 @@
 from SimPEG import *
 
+class LinearSurvey(Survey.BaseSurvey):
+    def projectFields(self, u):
+        return u
 
-def run(N=100, plotIt=True):
-    """
-        Inversion: Linear Problem
-        =========================
+class LinearProblem(Problem.BaseProblem):
+    """docstring for LinearProblem"""
 
-        Here we go over the basics of creating a linear problem and inversion.
+    surveyPair = LinearSurvey
 
-    """
+    def __init__(self, mesh, G, **kwargs):
+        Problem.BaseProblem.__init__(self, mesh, **kwargs)
+        self.G = G
 
-    np.random.seed(1)
+    def fields(self, m, u=None):
+        return self.G.dot(m)
 
+    def Jvec(self, m, v, u=None):
+        return self.G.dot(v)
+
+    def Jtvec(self, m, v, u=None):
+        return self.G.T.dot(v)
+
+
+def run(N, plotIt=True):
     mesh = Mesh.TensorMesh([N])
 
     nk = 20
@@ -31,8 +43,8 @@ def run(N=100, plotIt=True):
     mtrue[mesh.vectorCCx > 0.45] = -0.5
     mtrue[mesh.vectorCCx > 0.6] = 0
 
-    prob = Problem.LinearProblem(mesh, G)
-    survey = Survey.LinearSurvey()
+    prob = LinearProblem(mesh, G)
+    survey = LinearSurvey()
     survey.pair(prob)
     survey.makeSyntheticData(mtrue, std=0.01)
 
@@ -40,7 +52,7 @@ def run(N=100, plotIt=True):
 
     reg = Regularization.Tikhonov(mesh)
     dmis = DataMisfit.l2_DataMisfit(survey)
-    opt = Optimization.InexactGaussNewton(maxIter=35)
+    opt = Optimization.InexactGaussNewton(maxIter=20)
     invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
     beta = Directives.BetaSchedule()
     betaest = Directives.BetaEstimate_ByEig()
@@ -51,18 +63,16 @@ def run(N=100, plotIt=True):
 
     if plotIt:
         import matplotlib.pyplot as plt
-
-        fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
+        plt.figure(1)
         for i in range(prob.G.shape[0]):
-            axes[0].plot(prob.G[i,:])
-        axes[0].set_title('Columns of matrix G')
+            plt.plot(prob.G[i,:])
 
-        axes[1].plot(M.vectorCCx, survey.mtrue, 'b-')
-        axes[1].plot(M.vectorCCx, mrec, 'r-')
-        axes[1].legend(('True Model', 'Recovered Model'))
+        plt.figure(2)
+        plt.plot(M.vectorCCx, survey.mtrue, 'b-')
+        plt.plot(M.vectorCCx, mrec, 'r-')
         plt.show()
 
     return prob, survey, mesh, mrec
 
 if __name__ == '__main__':
-    run()
+    run(100)

SimPEG/Examples/MT_1D_ForwardAndInversion.py

@@ -1,129 +0,0 @@
-import SimPEG as simpeg
-import numpy as np
-import SimPEG.MT as MT
-from scipy.constants import mu_0
-import matplotlib.pyplot as plt
-
-def run(plotIt=True):
-    """
-        MT: 1D: Inversion
-        =======================
-
-        Forward model 1D MT data.
-        Setup and run a MT 1D inversion.
-
-    """
-
-    ## Setup the forward modeling
-    # Setting up 1D mesh and conductivity models to forward model data.
-    # Frequency
-    nFreq = 31
-    freqs = np.logspace(3,-3,nFreq)
-    # Set mesh parameters
-    ct = 20
-    air = simpeg.Utils.meshTensor([(ct,16,1.4)])
-    core = np.concatenate( (  np.kron(simpeg.Utils.meshTensor([(ct,10,-1.3)]),np.ones((5,))) , simpeg.Utils.meshTensor([(ct,5)]) ) )
-    bot = simpeg.Utils.meshTensor([(core[0],10,-1.4)])
-    x0 = -np.array([np.sum(np.concatenate((core,bot)))])
-    # Make the model
-    m1d = simpeg.Mesh.TensorMesh([np.concatenate((bot,core,air))], x0=x0)
-
-    # Setup model varibles
-    active = m1d.vectorCCx<0.
-    layer1 = (m1d.vectorCCx<-500.) & (m1d.vectorCCx>=-800.)
-    layer2 = (m1d.vectorCCx<-3500.) & (m1d.vectorCCx>=-5000.)
-    # Set the conductivity values
-    sig_half = 2e-3
-    sig_air = 1e-8
-    sig_layer1 = .2
-    sig_layer2 = .2
-    # Make the true model
-    sigma_true = np.ones(m1d.nCx)*sig_air
-    sigma_true[active] = sig_half
-    sigma_true[layer1] = sig_layer1
-    sigma_true[layer2] = sig_layer2
-    # Extract the model
-    m_true = np.log(sigma_true[active])
-    # Make the background model
-    sigma_0 = np.ones(m1d.nCx)*sig_air
-    sigma_0[active] = sig_half
-    m_0 = np.log(sigma_0[active])
-
-    # Set the mapping
-    actMap = simpeg.Maps.ActiveCells(m1d, active, np.log(1e-8), nC=m1d.nCx)
-    mappingExpAct = simpeg.Maps.ExpMap(m1d) * actMap
-
-    ## Setup the layout of the survey, set the sources and the connected receivers
-    # Receivers
-    rxList = []
-    for rxType in ['z1dr','z1di']:
-        rxList.append(MT.Rx(simpeg.mkvc(np.array([0.0]),2).T,rxType))
-    # Source list
-    srcList =[]
-    for freq in freqs:
-            srcList.append(MT.SrcMT.polxy_1Dprimary(rxList,freq))
-    # Make the survey
-    survey = MT.Survey(srcList)
-    survey.mtrue = m_true
-
-    ## Set the problem
-    problem = MT.Problem1D.eForm_psField(m1d,sigmaPrimary=sigma_0,mapping=mappingExpAct)
-    problem.pair(survey)
-
-    ## Forward model data
-    # Project the data
-    survey.dtrue = survey.dpred(m_true)
-    survey.dobs = survey.dtrue + 0.025*abs(survey.dtrue)*np.random.randn(*survey.dtrue.shape)
-
-    if plotIt:
-        fig = MT.Utils.dataUtils.plotMT1DModelData(problem)
-        fig.suptitle('Target - smooth true')
-
-
-    # Assign uncertainties
-    std = 0.05 # 5% std
-    survey.std = np.abs(survey.dobs*std)
-    # Assign the data weight
-    Wd = 1./survey.std
-
-    ## Setup the inversion proceedure
-    # Define a counter
-    C =  simpeg.Utils.Counter()
-    # Set the optimization
-    opt = simpeg.Optimization.InexactGaussNewton(maxIter = 30)
-    opt.counter = C
-    opt.LSshorten = 0.5
-    opt.remember('xc')
-    # Data misfit
-    dmis = simpeg.DataMisfit.l2_DataMisfit(survey)
-    dmis.Wd = Wd
-    # Regularization - with a regularization mesh
-    regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]],m1d.x0)
-    reg = simpeg.Regularization.Tikhonov(regMesh)
-    reg.mrefInSmooth = True
-    reg.alpha_s = 1e-7
-    reg.alpha_x = 1.
-    # Inversion problem
-    invProb = simpeg.InvProblem.BaseInvProblem(dmis, reg, opt)
-    invProb.counter = C
-    # Beta cooling
-    beta = simpeg.Directives.BetaSchedule()
-    beta.coolingRate = 4
-    betaest = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)
-    targmis = simpeg.Directives.TargetMisfit()
-    targmis.target = survey.nD
-    saveModel = simpeg.Directives.SaveModelEveryIteration()
-    saveModel.fileName = 'Inversion_TargMisEqnD_smoothTrue'
-    # Create an inversion object
-    inv = simpeg.Inversion.BaseInversion(invProb, directiveList=[beta,betaest,targmis])
-
-    ## Run the inversion
-    mopt = inv.run(m_0)
-
-    if plotIt:
-        fig = MT.Utils.dataUtils.plotMT1DModelData(problem,[mopt])
-        fig.suptitle('Target - smooth true')
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/MT_3D_Foward.py

@@ -1,64 +0,0 @@
-# Test script to use SimPEG.MT platform to forward model synthetic data.
-
-# Import
-import SimPEG as simpeg
-from SimPEG import MT
-import numpy as np
-try:
-    from pymatsolver import MumpsSolver as Solver
-except:
-    from SimPEG import Solver
-
-def run(plotIt=True, nFreq=1):
-    """
-        MT: 3D: Forward
-        =======================
-
-        Forward model 3D MT data.
-
-    """
-
-    # Make a mesh
-    M = simpeg.Mesh.TensorMesh([[(100,5,-1.5),(100.,10),(100,5,1.5)],[(100,5,-1.5),(100.,10),(100,5,1.5)],[(100,5,1.6),(100.,10),(100,3,2)]], x0=['C','C',-3529.5360])
-    # Setup the model
-    conds = [1e-2,1]
-    sig = simpeg.Utils.ModelBuilder.defineBlock(M.gridCC,[-1000,-1000,-400],[1000,1000,-200],conds)
-    sig[M.gridCC[:,2]>0] = 1e-8
-    sig[M.gridCC[:,2]<-600] = 1e-1
-    sigBG = np.zeros(M.nC) + conds[0]
-    sigBG[M.gridCC[:,2]>0] = 1e-8
-
-    ## Setup the the survey object
-    # Receiver locations
-    rx_x, rx_y = np.meshgrid(np.arange(-500,501,50),np.arange(-500,501,50))
-    rx_loc = np.hstack((simpeg.Utils.mkvc(rx_x,2),simpeg.Utils.mkvc(rx_y,2),np.zeros((np.prod(rx_x.shape),1))))
-    # Make a receiver list
-    rxList = []
-    for loc in rx_loc:
-        # NOTE: loc has to be a (1,3) np.ndarray otherwise errors accure
-        for rxType in ['zxxr','zxxi','zxyr','zxyi','zyxr','zyxi','zyyr','zyyi','tzxr','tzxi','tzyr','tzyi']:
-            rxList.append(MT.Rx(simpeg.mkvc(loc,2).T,rxType))
-    # Source list
-    srcList =[]
-    for freq in np.logspace(3,-3,nFreq):
-        srcList.append(MT.SrcMT.polxy_1Dprimary(rxList,freq))
-    # Survey MT
-    survey = MT.Survey(srcList)
-
-    ## Setup the problem object
-    problem = MT.Problem3D.eForm_ps(M, sigmaPrimary=sigBG)
-    problem.pair(survey)
-    problem.Solver = Solver
-
-    # Calculate the data
-    fields = problem.fields(sig)
-    dataVec = survey.eval(fields)
-
-    # Make the data
-    mtData = MT.Data(survey,dataVec)
-    # Add plots
-    if plotIt:
-        pass
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_Basic_PlotImage.py

@@ -1,46 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True):
-    """
-        Mesh: Basic: PlotImage
-        ======================
-
-        You can use M.PlotImage to plot images on all of the Meshes.
-
-
-    """
-    M = Mesh.TensorMesh([32,32])
-    v = Utils.ModelBuilder.randomModel(M.vnC, seed=789)
-    v = Utils.mkvc(v)
-
-    O = Mesh.TreeMesh([32,32])
-    O.refine(1)
-    def function(cell):
-        if (cell.center[0] < 0.75 and cell.center[0] > 0.25 and
-            cell.center[1] < 0.75 and cell.center[1] > 0.25):return 5
-        if (cell.center[0] < 0.9 and cell.center[0] > 0.1 and
-            cell.center[1] < 0.9 and cell.center[1] > 0.1):return 4
-        return 3
-    O.refine(function)
-
-    P = M.getInterpolationMat(O.gridCC, 'CC')
-
-    ov = P * v
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-
-        fig, axes = plt.subplots(1,2,figsize=(10,5))
-
-        out = M.plotImage(v, grid=True, ax=axes[0])
-        cb = plt.colorbar(out[0], ax=axes[0]); cb.set_label("Random Field")
-        axes[0].set_title('TensorMesh')
-
-        out = O.plotImage(ov, grid=True, ax=axes[1], clim=[0,1])
-        cb = plt.colorbar(out[0], ax=axes[1]); cb.set_label("Random Field")
-        axes[1].set_title('TreeMesh')
-
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_Basic_Types.py

@@ -1,30 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True):
-    """
-        Mesh: Basic: Types
-        ==================
-
-        Here we show SimPEG used to create three different types of meshes.
-
-    """
-    sz = [16,16]
-    tM = Mesh.TensorMesh(sz)
-    qM = Mesh.TreeMesh(sz)
-    qM.refine(lambda cell: 4 if np.sqrt(((np.r_[cell.center]-0.5)**2).sum()) < 0.4 else 3)
-    rM = Mesh.CurvilinearMesh(Utils.meshutils.exampleLrmGrid(sz,'rotate'))
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, axes = plt.subplots(1,3,figsize=(14,5))
-        opts = {}
-        tM.plotGrid(ax=axes[0], **opts)
-        axes[0].set_title('TensorMesh')
-        qM.plotGrid(ax=axes[1], **opts)
-        axes[1].set_title('TreeMesh')
-        rM.plotGrid(ax=axes[2], **opts)
-        axes[2].set_title('CurvilinearMesh')
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_Operators_CahnHilliard.py

@@ -1,105 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True, n=60):
-    """
-        Mesh: Operators: Cahn Hilliard
-        ==============================
-
-        This example is based on the example in the FiPy_ library.
-        Please see their documentation for more information about the Cahn-Hilliard equation.
-
-        The "Cahn-Hilliard" equation separates a field \\\\( \\\\phi \\\\) into 0 and 1 with smooth transitions.
-
-        .. math::
-
-            \\frac{\partial \phi}{\partial t} = \\nabla \cdot D \\nabla \left( \\frac{\partial f}{\partial \phi} - \epsilon^2 \\nabla^2 \phi \\right)
-
-        Where \\\\( f \\\\) is the energy function \\\\( f = ( a^2 / 2 )\\\\phi^2(1 - \\\\phi)^2 \\\\)
-        which drives \\\\( \\\\phi \\\\) towards either 0 or 1, this competes with the term
-        \\\\(\\\\epsilon^2 \\\\nabla^2 \\\\phi \\\\) which is a diffusion term that creates smooth changes in \\\\( \\\\phi \\\\).
-        The equation can be factored:
-
-        .. math::
-
-            \\frac{\partial \phi}{\partial t} = \\nabla \cdot D \\nabla \psi \\\\
-            \psi = \\frac{\partial^2 f}{\partial \phi^2} (\phi - \phi^{\\text{old}}) + \\frac{\partial f}{\partial \phi} - \epsilon^2 \\nabla^2 \phi
-
-        Here we will need the derivatives of \\\\( f \\\\):
-
-        .. math::
-
-            \\frac{\partial f}{\partial \phi} = (a^2/2)2\phi(1-\phi)(1-2\phi)
-            \\frac{\partial^2 f}{\partial \phi^2} = (a^2/2)2[1-6\phi(1-\phi)]
-
-        The implementation below uses backwards Euler in time with an exponentially increasing time step.
-        The initial \\\\( \\\\phi \\\\) is a normally distributed field with a standard deviation of 0.1 and mean of 0.5.
-        The grid is 60x60 and takes a few seconds to solve ~130 times. The results are seen below, and you can see the
-        field separating as the time increases.
-
-        .. _FiPy: http://www.ctcms.nist.gov/fipy/examples/cahnHilliard/generated/examples.cahnHilliard.mesh2DCoupled.html
-
-    """
-
-    np.random.seed(5)
-
-    # Here we are going to rearrange the equations:
-
-    # (phi_ - phi)/dt = A*(d2fdphi2*(phi_ - phi) + dfdphi - L*phi_)
-    # (phi_ - phi)/dt = A*(d2fdphi2*phi_ - d2fdphi2*phi + dfdphi - L*phi_)
-    # (phi_ - phi)/dt = A*d2fdphi2*phi_ + A*( - d2fdphi2*phi + dfdphi - L*phi_)
-    # phi_ - phi = dt*A*d2fdphi2*phi_ + dt*A*(- d2fdphi2*phi + dfdphi - L*phi_)
-    # phi_ - dt*A*d2fdphi2 * phi_ =  dt*A*(- d2fdphi2*phi + dfdphi - L*phi_) + phi
-    # (I - dt*A*d2fdphi2) * phi_ =  dt*A*(- d2fdphi2*phi + dfdphi - L*phi_) + phi
-    # (I - dt*A*d2fdphi2) * phi_ =  dt*A*dfdphi - dt*A*d2fdphi2*phi - dt*A*L*phi_ + phi
-    # (dt*A*d2fdphi2 - I) * phi_ =  dt*A*d2fdphi2*phi + dt*A*L*phi_ - phi - dt*A*dfdphi
-    # (dt*A*d2fdphi2 - I - dt*A*L) * phi_ =  (dt*A*d2fdphi2 - I)*phi - dt*A*dfdphi
-
-    h = [(0.25,n)]
-    M = Mesh.TensorMesh([h,h])
-
-    # Constants
-    D = a = epsilon = 1.
-    I = Utils.speye(M.nC)
-
-    # Operators
-    A = D * M.faceDiv * M.cellGrad
-    L = epsilon**2 * M.faceDiv * M.cellGrad
-
-    duration = 75
-    elapsed = 0.
-    dexp = -5
-    phi = np.random.normal(loc=0.5,scale=0.01,size=M.nC)
-    ii, jj = 0, 0
-    PHIS = []
-    capture = np.logspace(-1,np.log10(duration),8)
-    while elapsed < duration:
-        dt = min(100, np.exp(dexp))
-        elapsed += dt
-        dexp += 0.05
-
-        dfdphi   = a**2 * 2 * phi * (1 - phi) * (1 - 2 * phi)
-        d2fdphi2 = Utils.sdiag(a**2 * 2 * (1 - 6 * phi * (1 - phi)))
-
-        MAT = (dt*A*d2fdphi2 - I - dt*A*L)
-        rhs = (dt*A*d2fdphi2 - I)*phi - dt*A*dfdphi
-        phi = Solver(MAT)*rhs
-
-        if elapsed > capture[jj]:
-            PHIS += [(elapsed, phi.copy())]
-            jj += 1
-        if ii % 10 == 0: print ii, elapsed
-        ii += 1
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, axes = plt.subplots(2,4,figsize=(14,6))
-        axes = np.array(axes).flatten().tolist()
-        for ii, ax in zip(np.linspace(0,len(PHIS)-1,len(axes)),axes):
-            ii = int(ii)
-            out = M.plotImage(PHIS[ii][1],ax=ax)
-            ax.axis('off')
-            ax.set_title('Elapsed Time: %4.1f'%PHIS[ii][0])
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_QuadTree_Creation.py

@@ -1,28 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True):
-    """
-        Mesh: QuadTree: Creation
-        ========================
-
-        You can give the refine method a function, which is evaluated on every cell
-        of the TreeMesh.
-
-        Occasionally it is useful to initially refine to a constant level
-        (e.g. 3 in this 32x32 mesh). This means the function is first evaluated
-        on an 8x8 mesh (2^3).
-
-    """
-    M = Mesh.TreeMesh([32,32])
-    M.refine(3)
-    def function(cell):
-        xyz = cell.center
-        for i in range(3):
-            if np.abs(np.sin(xyz[0]*np.pi*2)*0.5 + 0.5 - xyz[1]) < 0.2*i:
-                return 6-i
-        return 0
-    M.refine(function);
-    if plotIt: M.plotGrid(showIt=True)
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_QuadTree_FaceDiv.py

@@ -1,49 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True, n=60):
-    """
-        Mesh: QuadTree: FaceDiv
-        =======================
-
-
-
-    """
-
-
-    M = Mesh.TreeMesh([[(1,16)],[(1,16)]], levels=4)
-    M._refineCell([0,0,0])
-    M._refineCell([0,0,1])
-    M._refineCell([4,4,2])
-    M.__dirty__ = True
-    M.number()
-
-
-    if plotIt:
-        import matplotlib.pyplot as plt
-        fig, axes = plt.subplots(2,1,figsize=(10,10))
-
-        M.plotGrid(cells=True, nodes=False, ax=axes[0])
-        axes[0].axis('off')
-        axes[0].set_title('Simple QuadTree Mesh')
-        axes[0].set_xlim([-1,17])
-        axes[0].set_ylim([-1,17])
-
-        for ii, loc in zip(range(M.nC),M.gridCC):
-            axes[0].text(loc[0]+0.2,loc[1],'%d'%ii, color='r')
-
-        axes[0].plot(M.gridFx[:,0],M.gridFx[:,1], 'g>')
-        for ii, loc in zip(range(M.nFx),M.gridFx):
-            axes[0].text(loc[0]+0.2,loc[1],'%d'%ii, color='g')
-
-        axes[0].plot(M.gridFy[:,0],M.gridFy[:,1], 'm^')
-        for ii, loc in zip(range(M.nFy),M.gridFy):
-            axes[0].text(loc[0]+0.2,loc[1]+0.2,'%d'%(ii+M.nFx), color='m')
-
-        axes[1].spy(M.faceDiv)
-        axes[1].set_title('Face Divergence')
-        axes[1].set_ylabel('Cell Number')
-        axes[1].set_xlabel('Face Number')
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_QuadTree_HangingNodes.py

@@ -1,32 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True):
-    """
-        Mesh: QuadTree: Hanging Nodes
-        =============================
-
-        You can give the refine method a function, which is evaluated on every cell
-        of the TreeMesh.
-
-        Occasionally it is useful to initially refine to a constant level
-        (e.g. 3 in this 32x32 mesh). This means the function is first evaluated
-        on an 8x8 mesh (2^3).
-
-    """
-    M = Mesh.TreeMesh([8,8])
-    def function(cell):
-        xyz = cell.center
-        dist = ((xyz - [0.25,0.25])**2).sum()**0.5
-        if dist < 0.25:
-            return 3
-        return 2
-    M.refine(function);
-    M.number()
-    if plotIt:
-        import matplotlib.pyplot as plt
-        M.plotGrid(nodes=True, cells=True, facesX=True)
-        plt.legend(('Grid', 'Cell Centers', 'Nodes', 'Hanging Nodes', 'X faces', 'Hanging X faces'))
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_Tensor_Creation.py

@@ -1,35 +0,0 @@
-from SimPEG import *
-
-def run(plotIt=True):
-    """
-
-        Mesh: Tensor: Creation
-        ======================
-
-        For tensor meshes, there are some functions that can come
-        in handy. For example, creating mesh tensors can be a bit time
-        consuming, these can be created speedily by just giving numbers
-        and sizes of padding. See the example below, that follows this
-        notation::
-
-            h1 = (
-                   (cellSize, numPad, [, increaseFactor]),
-                   (cellSize, numCore),
-                   (cellSize, numPad, [, increaseFactor])
-                 )
-
-        .. note::
-
-            You can center your mesh by passing a 'C' for the x0[i] position.
-            A 'N' will make the entire mesh negative, and a '0' (or a 0) will
-            make the mesh start at zero.
-
-    """
-    h1 = [(10, 5, -1.3), (5, 20), (10, 3, 1.3)]
-    M = Mesh.TensorMesh([h1, h1], x0='CN')
-    if plotIt:
-        M.plotGrid(showIt=True)
-
-if __name__ == '__main__':
-    run()
-

SimPEG/Examples/__init__.py

@@ -1,112 +1 @@
-# Run this file to add imports.
-
-##### AUTOIMPORTS #####
-import DC_Analytic_Dipole
-import DC_Forward_PseudoSection
-import EM_FDEM_1D_Inversion
-import EM_FDEM_Analytic_MagDipoleWholespace
-import EM_Schenkel_Morrison_Casing
-import EM_TDEM_1D_Inversion
-import FLOW_Richards_1D_Celia1990
-import Forward_BasicDirectCurrent
-import Inversion_IRLS
-import Inversion_Linear
-import Mesh_Basic_PlotImage
-import Mesh_Basic_Types
-import Mesh_Operators_CahnHilliard
-import Mesh_QuadTree_Creation
-import Mesh_QuadTree_FaceDiv
-import Mesh_QuadTree_HangingNodes
-import Mesh_Tensor_Creation
-import MT_1D_ForwardAndInversion
-import MT_3D_Foward
-
-__examples__ = ["DC_Analytic_Dipole", "DC_Forward_PseudoSection", "EM_FDEM_1D_Inversion", "EM_FDEM_Analytic_MagDipoleWholespace", "EM_Schenkel_Morrison_Casing", "EM_TDEM_1D_Inversion", "FLOW_Richards_1D_Celia1990", "Forward_BasicDirectCurrent", "Inversion_IRLS", "Inversion_Linear", "Mesh_Basic_PlotImage", "Mesh_Basic_Types", "Mesh_Operators_CahnHilliard", "Mesh_QuadTree_Creation", "Mesh_QuadTree_FaceDiv", "Mesh_QuadTree_HangingNodes", "Mesh_Tensor_Creation", "MT_1D_ForwardAndInversion", "MT_3D_Foward"]
-
-##### AUTOIMPORTS #####
-
-if __name__ == '__main__':
-    """
-
-        Run the following to create the examples documentation and add to the imports at the top.
-
-    """
-
-    import shutil, os
-    from SimPEG import Examples
-
-    # Create the examples dir in the docs folder.
-    fName = os.path.realpath(__file__)
-    docExamplesDir = os.path.sep.join(fName.split(os.path.sep)[:-3] + ['docs', 'examples'])
-    shutil.rmtree(docExamplesDir)
-    os.makedirs(docExamplesDir)
-
-    # Get all the python examples in this folder
-    thispath = os.path.sep.join(fName.split(os.path.sep)[:-1])
-    exfiles  = [f[:-3] for f in os.listdir(thispath) if os.path.isfile(os.path.join(thispath, f)) and f.endswith('.py') and not f.startswith('_')]
-
-    # Add the imports to the top in the AUTOIMPORTS section
-    f = file(fName, 'r')
-    inimports = False
-    out = ''
-    for line in f:
-        if not inimports:
-            out += line
-
-        if line == "##### AUTOIMPORTS #####\n":
-            inimports = not inimports
-            if inimports:
-                out += '\n'.join(["import %s"%_ for _ in exfiles])
-                out += '\n\n__examples__ = ["' + '", "'.join(exfiles)+ '"]\n'
-                out += '\n##### AUTOIMPORTS #####\n'
-    f.close()
-
-    f = file(fName, 'w')
-    f.write(out)
-    f.close()
-
-
-    def _makeExample(filePath, runFunction):
-        """Makes the example given a path of the file and the run function."""
-        filePath = os.path.realpath(filePath)
-        name = filePath.split(os.path.sep)[-1].rstrip('.pyc').rstrip('.py')
-
-        docstr = runFunction.__doc__
-        if docstr is None:
-            doc = '%s\n%s'%(name.replace('_',' '),'='*len(name))
-        else:
-            doc = '\n'.join([_[8:].rstrip() for _ in docstr.split('\n')])
-
-        out = """.. _examples_%s:
-
-.. --------------------------------- ..
-..                                   ..
-..    THIS FILE IS AUTO GENEREATED   ..
-..                                   ..
-..    SimPEG/Examples/__init__.py    ..
-..                                   ..
-.. --------------------------------- ..
-
-%s
-
-.. plot::
-
-    from SimPEG import Examples
-    Examples.%s.run()
-
-.. literalinclude:: ../../SimPEG/Examples/%s.py
-    :language: python
-    :linenos:
-"""%(name,doc,name,name)
-
-        rst = os.path.sep.join((filePath.split(os.path.sep)[:-3] + ['docs', 'examples', name + '.rst']))
-
-        print 'Creating: %s.rst'%name
-        f = open(rst, 'w')
-        f.write(out)
-        f.close()
-
-    for ex in dir(Examples):
-        if ex.startswith('_'): continue
-        E = getattr(Examples,ex)
-        _makeExample(E.__file__, E.run)
+import Linear

SimPEG/FLOW/Richards/Empirical.py

@@ -1,578 +0,0 @@
-from SimPEG import Mesh, Maps, Utils, np
-
-
-class NonLinearMap(object):
-    """
-    SimPEG NonLinearMap
-
-    """
-
-    __metaclass__ = Utils.SimPEGMetaClass
-
-    counter = None   #: A SimPEG.Utils.Counter object
-    mesh = None      #: A SimPEG Mesh
-
-    def __init__(self, mesh):
-        self.mesh = mesh
-
-    def _transform(self, u, m):
-        """
-            :param numpy.array u: fields
-            :param numpy.array m: model
-            :rtype: numpy.array
-            :return: transformed model
-
-            The *transform* changes the model into the physical property.
-
-        """
-        return m
-
-    def derivU(self, u, m):
-        """
-            :param numpy.array u: fields
-            :param numpy.array m: model
-            :rtype: scipy.csr_matrix
-            :return: derivative of transformed model
-
-            The *transform* changes the model into the physical property.
-            The *transformDerivU* provides the derivative of the *transform* with respect to the fields.
-        """
-        raise NotImplementedError('The transformDerivU is not implemented.')
-
-
-    def derivM(self, u, m):
-        """
-            :param numpy.array u: fields
-            :param numpy.array m: model
-            :rtype: scipy.csr_matrix
-            :return: derivative of transformed model
-
-            The *transform* changes the model into the physical property.
-            The *transformDerivU* provides the derivative of the *transform* with respect to the model.
-        """
-        raise NotImplementedError('The transformDerivM is not implemented.')
-
-    @property
-    def nP(self):
-        """Number of parameters in the model."""
-        return self.mesh.nC
-
-    def example(self):
-        raise NotImplementedError('The example is not implemented.')
-
-    def test(self, m=None):
-        raise NotImplementedError('The test is not implemented.')
-
-
-class RichardsMap(object):
-    """docstring for RichardsMap"""
-
-    mesh       = None  #: SimPEG mesh
-
-    @property
-    def thetaModel(self):
-        """Model for moisture content"""
-        return self._thetaModel
-
-    @property
-    def kModel(self):
-        """Model for hydraulic conductivity"""
-        return self._kModel
-
-    def __init__(self, mesh, thetaModel, kModel):
-        self.mesh = mesh
-        assert isinstance(thetaModel, NonLinearMap)
-        assert isinstance(kModel, NonLinearMap)
-
-        self._thetaModel = thetaModel
-        self._kModel = kModel
-
-    def theta(self, u, m):
-        return self.thetaModel.transform(u, m)
-
-    def thetaDerivM(self, u, m):
-        return self.thetaModel.transformDerivM(u, m)
-
-    def thetaDerivU(self, u, m):
-        return self.thetaModel.transformDerivU(u, m)
-
-    def k(self, u, m):
-        return self.kModel.transform(u, m)
-
-    def kDerivM(self, u, m):
-        return self.kModel.transformDerivM(u, m)
-
-    def kDerivU(self, u, m):
-        return self.kModel.transformDerivU(u, m)
-
-    def plot(self, m):
-        import matplotlib.pyplot as plt
-
-        m = m[0]
-        h = np.linspace(-100, 20, 1000)
-        ax = plt.subplot(121)
-        ax.plot(self.theta(h, m), h)
-        ax = plt.subplot(122)
-        ax.semilogx(self.k(h, m), h)
-
-    def _assertMatchesPair(self, pair):
-        assert isinstance(self, pair), "Mapping object must be an instance of a %s class."%(pair.__name__)
-
-
-
-def _ModelProperty(name, models, doc=None, default=None):
-
-    def fget(self):
-        model = models[0]
-        if getattr(self, model, None) is not None:
-            MOD = getattr(self, model)
-            return getattr(MOD, name, default)
-        return default
-
-    def fset(self, value):
-        for model in models:
-            if getattr(self, model, None) is not None:
-                MOD = getattr(self, model)
-                setattr(MOD, name, value)
-
-    return property(fget, fset=fset, doc=doc)
-
-
-class HaverkampParams(object):
-    """Holds some default parameterizations for the Haverkamp model."""
-    def __init__(self): pass
-    @property
-    def celia1990(self):
-        """
-            Parameters used in:
-
-                Celia, Michael A., Efthimios T. Bouloutas, and Rebecca L. Zarba.
-                "A general mass-conservative numerical solution for the unsaturated flow equation."
-                Water Resources Research 26.7 (1990): 1483-1496.
-
-        """
-        return {'alpha':1.611e+06, 'beta':3.96,
-                'theta_r':0.075, 'theta_s':0.287,
-                'Ks':9.44e-03, 'A':1.175e+06,
-                'gamma':4.74}
-
-
-class _haverkamp_theta(NonLinearMap):
-
-    theta_s = 0.430
-    theta_r = 0.078
-    alpha   = 0.036
-    beta    = 3.960
-
-    def __init__(self, mesh, **kwargs):
-        NonLinearMap.__init__(self, mesh)
-        Utils.setKwargs(self, **kwargs)
-
-    def setModel(self, m):
-        self._currentModel = m
-
-    def transform(self, u, m):
-        self.setModel(m)
-        f = (self.alpha*(self.theta_s  -    self.theta_r  )/
-                        (self.alpha    + abs(u)**self.beta) + self.theta_r)
-        if Utils.isScalar(self.theta_s):
-            f[u >= 0] = self.theta_s
-        else:
-            f[u >= 0] = self.theta_s[u >= 0]
-        return f
-
-    def transformDerivM(self, u, m):
-        self.setModel(m)
-
-    def transformDerivU(self, u, m):
-        self.setModel(m)
-        g = (self.alpha*((self.theta_s - self.theta_r)/
-             (self.alpha + abs(u)**self.beta)**2)
-             *(-self.beta*abs(u)**(self.beta-1)*np.sign(u)))
-        g[u >= 0] = 0
-        g = Utils.sdiag(g)
-        return g
-
-
-class _haverkamp_k(NonLinearMap):
-
-    A       = 1.175e+06
-    gamma   = 4.74
-    Ks      = np.log(24.96)
-
-    def __init__(self, mesh, **kwargs):
-        NonLinearMap.__init__(self, mesh)
-        Utils.setKwargs(self, **kwargs)
-
-    def setModel(self, m):
-        self._currentModel = m
-        #TODO: Fix me!
-        self.Ks = m
-
-    def transform(self, u, m):
-        self.setModel(m)
-        f = np.exp(self.Ks)*self.A/(self.A+abs(u)**self.gamma)
-        if Utils.isScalar(self.Ks):
-            f[u >= 0] = np.exp(self.Ks)
-        else:
-            f[u >= 0] = np.exp(self.Ks[u >= 0])
-        return f
-
-    def transformDerivM(self, u, m):
-        self.setModel(m)
-        #A
-        # dA = np.exp(self.Ks)/(self.A+abs(u)**self.gamma) - np.exp(self.Ks)*self.A/(self.A+abs(u)**self.gamma)**2
-        #gamma
-        # dgamma = -(self.A*np.exp(self.Ks)*np.log(abs(u))*abs(u)**self.gamma)/(self.A + abs(u)**self.gamma)**2
-
-        # This assumes that the the model is Ks
-        return Utils.sdiag(self.transform(u, m))
-
-    def transformDerivU(self, u, m):
-        self.setModel(m)
-        g = -(np.exp(self.Ks)*self.A*self.gamma*abs(u)**(self.gamma-1)*np.sign(u))/((self.A+abs(u)**self.gamma)**2)
-        g[u >= 0] = 0
-        g = Utils.sdiag(g)
-        return g
-
-class Haverkamp(RichardsMap):
-    """Haverkamp Model"""
-
-    alpha   = _ModelProperty('alpha',   ['thetaModel'], default=1.6110e+06)
-    beta    = _ModelProperty('beta',    ['thetaModel'], default=3.96)
-    theta_r = _ModelProperty('theta_r', ['thetaModel'], default=0.075)
-    theta_s = _ModelProperty('theta_s', ['thetaModel'], default=0.287)
-
-    Ks    = _ModelProperty('Ks',    ['kModel'], default=np.log(24.96))
-    A     = _ModelProperty('A',     ['kModel'], default=1.1750e+06)
-    gamma = _ModelProperty('gamma', ['kModel'], default=4.74)
-
-    def __init__(self, mesh, **kwargs):
-        RichardsMap.__init__(self, mesh,
-                               _haverkamp_theta(mesh),
-                               _haverkamp_k(mesh))
-        Utils.setKwargs(self, **kwargs)
-
-
-
-
-class _vangenuchten_theta(NonLinearMap):
-
-    theta_s = 0.430
-    theta_r = 0.078
-    alpha   = 0.036
-    n       = 1.560
-
-    def __init__(self, mesh, **kwargs):
-        NonLinearMap.__init__(self, mesh)
-        Utils.setKwargs(self, **kwargs)
-
-    def setModel(self, m):
-        self._currentModel = m
-
-    def transform(self, u, m):
-        self.setModel(m)
-        m = 1 - 1.0/self.n
-        f = ((  self.theta_s  -  self.theta_r  )/
-             ((1+abs(self.alpha*u)**self.n)**m)   +  self.theta_r)
-        if Utils.isScalar(self.theta_s):
-            f[u >= 0] = self.theta_s
-        else:
-            f[u >= 0] = self.theta_s[u >= 0]
-
-        return f
-
-    def transformDerivM(self, u, m):
-        self.setModel(m)
-
-    def transformDerivU(self, u, m):
-        g = -self.alpha*self.n*abs(self.alpha*u)**(self.n - 1)*np.sign(self.alpha*u)*(1./self.n - 1)*(self.theta_r - self.theta_s)*(abs(self.alpha*u)**self.n + 1)**(1./self.n - 2)
-        g[u >= 0] = 0
-        g = Utils.sdiag(g)
-        return g
-
-
-class _vangenuchten_k(NonLinearMap):
-
-    I       = 0.500
-    alpha   = 0.036
-    n       = 1.560
-    Ks      = np.log(24.96)
-
-    def __init__(self, mesh, **kwargs):
-        NonLinearMap.__init__(self, mesh)
-        Utils.setKwargs(self, **kwargs)
-
-    def setModel(self, m):
-        self._currentModel = m
-        #TODO: Fix me!
-        self.Ks = m
-
-    def transform(self, u, m):
-        self.setModel(m)
-
-        alpha = self.alpha
-        I = self.I
-        n = self.n
-        Ks = self.Ks
-        m = 1.0 - 1.0/n
-
-        theta_e = 1.0/((1.0+abs(alpha*u)**n)**m)
-        f = np.exp(Ks)*theta_e**I* ( ( 1.0 - ( 1.0 - theta_e**(1.0/m) )**m )**2 )
-        if Utils.isScalar(self.Ks):
-            f[u >= 0] = np.exp(self.Ks)
-        else:
-            f[u >= 0] = np.exp(self.Ks[u >= 0])
-        return f
-
-    def transformDerivM(self, u, m):
-        self.setModel(m)
-#         #alpha
-#         # dA = I*u*n*np.exp(Ks)*abs(alpha*u)**(n - 1)*np.sign(alpha*u)*(1.0/n - 1)*((abs(alpha*u)**n + 1)**(1.0/n - 1))**(I - 1)*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1)**2*(abs(alpha*u)**n + 1)**(1.0/n - 2) - (2*u*n*np.exp(Ks)*abs(alpha*u)**(n - 1)*np.sign(alpha*u)*(1.0/n - 1)*((abs(alpha*u)**n + 1)**(1.0/n - 1))**I*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1)*(abs(alpha*u)**n + 1)**(1.0/n - 2))/(((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1) + 1)*(1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1.0/n));
-#         #n
-#         # dn = 2*np.exp(Ks)*((np.log(1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))*(1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n))/n**2 + ((1.0/n - 1)*(((np.log(abs(alpha*u)**n + 1)*(abs(alpha*u)**n + 1)**(1.0/n - 1))/n**2 - abs(alpha*u)**n*np.log(abs(alpha*u))*(1.0/n - 1)*(abs(alpha*u)**n + 1)**(1.0/n - 2))/((1.0/n - 1)*((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1) + 1)) - np.log((abs(alpha*u)**n + 1)**(1.0/n - 1))/(n**2*(1.0/n - 1)**2*((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))))/(1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1.0/n))*((abs(alpha*u)**n + 1)**(1.0/n - 1))**I*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1) - I*np.exp(Ks)*((np.log(abs(alpha*u)**n + 1)*(abs(alpha*u)**n + 1)**(1.0/n - 1))/n**2 - abs(alpha*u)**n*np.log(abs(alpha*u))*(1.0/n - 1)*(abs(alpha*u)**n + 1)**(1.0/n - 2))*((abs(alpha*u)**n + 1)**(1.0/n - 1))**(I - 1)*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1)**2;
-#         #I
-#         # dI = np.exp(Ks)*np.log((abs(alpha*u)**n + 1)**(1.0/n - 1))*((abs(alpha*u)**n + 1)**(1.0/n - 1))**I*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1)**2;
-        return Utils.sdiag(self.transform(u, m)) # This assumes that the the model is Ks
-
-    def transformDerivU(self, u, m):
-        self.setModel(m)
-        alpha = self.alpha
-        I = self.I
-        n = self.n
-        Ks = self.Ks
-        m = 1.0 - 1.0/n
-
-        g = I*alpha*n*np.exp(Ks)*abs(alpha*u)**(n - 1.0)*np.sign(alpha*u)*(1.0/n - 1.0)*((abs(alpha*u)**n + 1)**(1.0/n - 1))**(I - 1)*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1)**2*(abs(alpha*u)**n + 1)**(1.0/n - 2) - (2*alpha*n*np.exp(Ks)*abs(alpha*u)**(n - 1)*np.sign(alpha*u)*(1.0/n - 1)*((abs(alpha*u)**n + 1)**(1.0/n - 1))**I*((1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1 - 1.0/n) - 1)*(abs(alpha*u)**n + 1)**(1.0/n - 2))/(((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1) + 1)*(1 - 1.0/((abs(alpha*u)**n + 1)**(1.0/n - 1))**(1.0/(1.0/n - 1)))**(1.0/n))
-        g[u >= 0] = 0
-        g = Utils.sdiag(g)
-        return g
-
-class VanGenuchten(RichardsMap):
-    """vanGenuchten Model"""
-
-    theta_r = _ModelProperty('theta_r', ['thetaModel'], default=0.075)
-    theta_s = _ModelProperty('theta_s', ['thetaModel'], default=0.287)
-
-    alpha   = _ModelProperty('alpha',   ['thetaModel', 'kModel'], default=0.036)
-    n       = _ModelProperty('n',       ['thetaModel', 'kModel'], default=1.560)
-
-    Ks    = _ModelProperty('Ks',    ['kModel'], default=np.log(24.96))
-    I     = _ModelProperty('I',     ['kModel'], default=0.500)
-
-    def __init__(self, mesh, **kwargs):
-        RichardsMap.__init__(self, mesh,
-                               _vangenuchten_theta(mesh),
-                               _vangenuchten_k(mesh))
-        Utils.setKwargs(self, **kwargs)
-
-
-class VanGenuchtenParams(object):
-    """
-        The RETC code for quantifying the hydraulic functions of unsaturated soils,
-        Van Genuchten, M Th, Leij, F J, Yates, S R
-
-        Table 3: Average values for selected soil water retention and hydraulic
-        conductivity parameters for 11 major soil textural groups
-        according to Rawls et al. [1982]
-
-    """
-    def __init__(self): pass
-    @property
-    def sand(self):
-        return {"theta_r": 0.020, "theta_s": 0.417, "alpha": 0.138*100., "n": 1.592, "Ks": 504.0/100./24./60./60.}
-    @property
-    def loamySand(self):
-        return {"theta_r": 0.035, "theta_s": 0.401, "alpha": 0.115*100., "n": 1.474, "Ks": 146.6/100./24./60./60.}
-    @property
-    def sandyLoam(self):
-        return {"theta_r": 0.041, "theta_s": 0.412, "alpha": 0.068*100., "n": 1.322, "Ks": 62.16/100./24./60./60.}
-    @property
-    def loam(self):
-        return {"theta_r": 0.027, "theta_s": 0.434, "alpha": 0.090*100., "n": 1.220, "Ks": 16.32/100./24./60./60.}
-    @property
-    def siltLoam(self):
-        return {"theta_r": 0.015, "theta_s": 0.486, "alpha": 0.048*100., "n": 1.211, "Ks": 31.68/100./24./60./60.}
-    @property
-    def sandyClayLoam(self):
-        return {"theta_r": 0.068, "theta_s": 0.330, "alpha": 0.036*100., "n": 1.250, "Ks": 10.32/100./24./60./60.}
-    @property
-    def clayLoam(self):
-        return {"theta_r": 0.075, "theta_s": 0.390, "alpha": 0.039*100., "n": 1.194, "Ks": 5.52/100./24./60./60.}
-    @property
-    def siltyClayLoam(self):
-        return {"theta_r": 0.040, "theta_s": 0.432, "alpha": 0.031*100., "n": 1.151, "Ks": 3.60/100./24./60./60.}
-    @property
-    def sandyClay(self):
-        return {"theta_r": 0.109, "theta_s": 0.321, "alpha": 0.034*100., "n": 1.168, "Ks": 2.88/100./24./60./60.}
-    @property
-    def siltyClay(self):
-        return {"theta_r": 0.056, "theta_s": 0.423, "alpha": 0.029*100., "n": 1.127, "Ks": 2.16/100./24./60./60.}
-    @property
-    def clay(self):
-        return {"theta_r": 0.090, "theta_s": 0.385, "alpha": 0.027*100., "n": 1.131, "Ks": 1.44/100./24./60./60.}
-
-
-    # From: INDIRECT METHODS FOR ESTIMATING THE HYDRAULIC PROPERTIES OF UNSATURATED SOILS
-    # @property
-    # def siltLoamGE3(self):
-    #     """Soil Index: 3310"""
-    #     return {"theta_r": 0.139, "theta_s": 0.394, "alpha": 0.00414, "n": 2.15}
-    # @property
-    # def yoloLightClayK_WC(self):
-    #     """Soil Index: None"""
-    #     return {"theta_r": 0.205, "theta_s": 0.499, "alpha": 0.02793, "n": 1.71}
-    # @property
-    # def yoloLightClayK_H(self):
-    #     """Soil Index: None"""
-    #     return {"theta_r": 0.205, "theta_s": 0.499, "alpha": 0.02793, "n": 1.71}
-    # @property
-    # def hygieneSandstone(self):
-    #     """Soil Index: 4130"""
-    #     return {"theta_r": 0.000, "theta_s": 0.256, "alpha": 0.00562, "n": 3.27}
-    # @property
-    # def lambcrgClay(self):
-    #     """Soil Index: 1003"""
-    #     return {"theta_r": 0.000, "theta_s": 0.502, "alpha": 0.140, "n": 1.93}
-    # @property
-    # def beitNetofaClaySoil(self):
-    #     """Soil Index: 1006"""
-    #     return {"theta_r": 0.000, "theta_s": 0.447, "alpha": 0.00156, "n": 1.17}
-    # @property
-    # def shiohotSiltyClay(self):
-    #     """Soil Index: 1101"""
-    #     return {"theta_r": 0.000, "theta_s": 0.456, "alpha": 183, "n":1.17}
-    # @property
-    # def siltColumbia(self):
-    #     """Soil Index: 2001"""
-    #     return {"theta_r": 0.146, "theta_s": 0.397,  "alpha": 0.0145, "n": 1.85}
-    # @property
-    # def siltMontCenis(self):
-    #     """Soil Index: 2002"""
-    #     return {"theta_r": 0.000, "theta_s": 0.425, "alpha": 0.0103, "n": 1.34}
-    # @property
-    # def slateDust(self):
-    #     """Soil Index: 2004"""
-    #     return {"theta_r": 0.000, "theta_s": 0.498, "alpha": 0.00981, "n": 6.75}
-    # @property
-    # def weldSiltyClayLoam(self):
-    #     """Soil Index: 3001"""
-    #     return {"theta_r": 0.159, "theta_s": 0.496, "alpha": 0.0136, "n": 5.45}
-    # @property
-    # def rideauClayLoam_Wetting(self):
-    #     """Soil Index: 3101a"""
-    #     return {"theta_r": 0.279, "theta_s": 0.419, "alpha": 0.0661, "n": 1.89}
-    # @property
-    # def rideauClayLoam_Drying(self):
-    #     """Soil Index: 3101b"""
-    #     return {"theta_r": 0.290, "theta_s": 0.419, "alpha": 0.0177, "n": 3.18}
-    # @property
-    # def caribouSiltLoam_Drying(self):
-    #     """Soil Index: 3301a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.451, "alpha": 0.00845, "n": 1.29}
-    # @property
-    # def caribouSiltLoam_Wetting(self):
-    #     """Soil Index: 3301b"""
-    #     return {"theta_r": 0.000, "theta_s": 0.450, "alpha": 0.140, "n": 1.09}
-    # @property
-    # def grenvilleSiltLoam_Wetting(self):
-    #     """Soil Index: 3302a"""
-    #     return {"theta_r": 0.013, "theta_s": 0523,  "alpha": 0.0630, "n": 1.24}
-    # @property
-    # def grenvilleSiltLoam_Drying(self):
-    #     """Soil Index: 3302c"""
-    #     return {"theta_r": 0.000, "theta_s": 0.488, "alpha": 0.0112, "n": 1.23}
-    # @property
-    # def touchetSiltLoam(self):
-    #     """Soil Index: 3304"""
-    #     return {"theta_r": 0.183, "theta_s": 0.498, "alpha": 0.0104, "n": 5.78}
-    # @property
-    # def gilatLoam(self):
-    #     """Soil Index: 3402a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.454, "alpha": 0.0291, "n": 1.47}
-    # @property
-    # def pachapaLoam(self):
-    #     """Soil Index: 3403"""
-    #     return {"theta_r": 0.000, "theta_s": 0.472, "alpha": 0.00829, "n": 1.62}
-    # @property
-    # def adelantoLoam(self):
-    #     """Soil Index: 3404"""
-    #     return {"theta_r": 0.000, "theta_s": 0.444, "alpha": 0.00710, "n": 1.26}
-    # @property
-    # def indioLoam(self):
-    #     """Soil Index: 3405a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.507, "alpha": 0.00847, "n": 1.60}
-    # @property
-    # def guclphLoam(self):
-    #     """Soil Index: 3407a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.563, "alpha": 0.0275, "n": 1.27}
-    # @property
-    # def guclphLoam(self):
-    #     """Soil Index: 3407b"""
-    #     return {"theta_r": 0.236, "theta_s": 0.435, "alpha": 0.0271, "n": 262}
-    # @property
-    # def rubiconSandyLoam(self):
-    #     """Soil Index: 3501a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.393,  "alpha": 0.00972, "n": 2.18}
-    # @property
-    # def rubiconSandyLoam(self):
-    #     """Soil Index: 350lb"""
-    #     return {"theta_r": 0.000, "theta_s": 0.433, "alpha": 0.147, "n": 1.28}
-    # @property
-    # def pachapaFmeSandyClay(self):
-    #     """Soil Index: 3503a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.340, "alpha": 0.0194, "n": 1.45}
-    # @property
-    # def gilatSandyLoam(self):
-    #     """Soil Index: 3504"""
-    #     return {"theta_r": 0.000, "theta_s": 0.432, "alpha": 0.0103, "n": 1.48}
-    # @property
-    # def plainfieldSand_210to250(self):
-    #     """Soil Index: 4101a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.351, "alpha": 0.0236, "n": 12.30}
-    # @property
-    # def plainfieldSand_210to250(self):
-    #     """Soil Index: 4101b"""
-    #     return {"theta_r": 0.000, "theta_s": 0.312, "alpha": 0.0387, "n": 4.48}
-    # @property
-    # def plainfieldSand_177to210(self):
-    #     """Soil Index: 4102a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.361, "alpha": 0.0207, "n": 10.0}
-    # @property
-    # def plainfieldSand_177to210(self):
-    #     """Soil Index: 4102b"""
-    #     return {"theta_r": 0.022, "theta_s": 0.309, "alpha": 0.0328, "n": 6.23}
-    # @property
-    # def plainfieldSand_149to177(self):
-    #     """Soil Index: 4103a"""
-    #     return {"theta_r": 0.000, "theta_s": 0.387, "alpha": 0.0173, "n": 7.80}
-    # @property
-    # def plainfieldSand_149to177(self):
-    #     """Soil Index: 4103b"""
-    #     return {"theta_r": 0.025, "theta_s": 0.321, "alpha": 0.0272, "n": 6.69}
-    # @property
-    # def plainfieldSand_l25to149(self):
-    #     """Soil Index: 4104a"""
-    #     return {"theta_r": 0.000, "theta_s": 03770, "alpha": 0.0145, "n": 10.60}
-    # @property
-    # def plainfieldSand_125to149(self):
-    #     """Soil Index: 4104b"""
-    #     return {"theta_r": 0.000, "theta_s": 0.342, "alpha": 0.0230, "n": 5.18}
-
-
-if __name__ == '__main__':
-    import matplotlib.pyplot as plt
-    M = Mesh.TensorMesh([10])
-    VGparams = VanGenuchtenParams()
-    leg = []
-    for p in dir(VGparams):
-        if p[0] == '_': continue
-        leg += [p]
-        params = getattr(VGparams, p)
-        model = VanGenuchten(M, **params)
-        ks = np.log(np.r_[params['Ks']])
-        model.plot(ks)
-
-    plt.legend(leg)
-
-    plt.show()

SimPEG/FLOW/Richards/RichardsProblem.py

@@ -1,304 +0,0 @@
-from SimPEG import *
-from Empirical import RichardsMap
-import time
-
-
-class RichardsRx(Survey.BaseTimeRx):
-    """Richards Receiver Object"""
-
-    knownRxTypes = ['saturation','pressureHead']
-
-    def eval(self, U, m, mapping, mesh, timeMesh):
-
-        if self.rxType == 'pressureHead':
-            u = np.concatenate(U)
-        elif self.rxType == 'saturation':
-            u = np.concatenate([mapping.theta(ui, m) for ui in U])
-
-        return self.getP(mesh, timeMesh) * u
-
-    def evalDeriv(self, U, m, mapping, mesh, timeMesh):
-
-        P = self.getP(mesh, timeMesh)
-        if self.rxType == 'pressureHead':
-            return P
-        elif self.rxType == 'saturation':
-            #TODO: if m is a parameter in the theta
-            #      distribution, we may need to do
-            #      some more chain rule here.
-            dT = sp.block_diag([mapping.thetaDerivU(ui, m) for ui in U])
-            return P*dT
-
-
-class RichardsSurvey(Survey.BaseSurvey):
-    """docstring for RichardsSurvey"""
-
-    rxList = None
-
-    def __init__(self, rxList, **kwargs):
-        self.rxList = rxList
-        Survey.BaseSurvey.__init__(self, **kwargs)
-
-    @property
-    def nD(self):
-        return np.array([rx.nD for rx in self.rxList]).sum()
-
-    @Utils.count
-    @Utils.requires('prob')
-    def dpred(self, m, f=None):
-        """
-            Create the projected data from a model.
-            The field, f, (if provided) will be used for the predicted data
-            instead of recalculating the fields (which may be expensive!).
-
-            .. math::
-                d_\\text{pred} = P(f(m), m)
-
-            Where P is a projection of the fields onto the data space.
-        """
-        if f is None: f = self.prob.fields(m)
-        return Utils.mkvc(self.eval(f, m))
-
-    @Utils.requires('prob')
-    def eval(self, U, m):
-        Ds = range(len(self.rxList))
-        for ii, rx in enumerate(self.rxList):
-            Ds[ii] = rx.eval(U, m,
-                                self.prob.mapping,
-                                self.prob.mesh,
-                                self.prob.timeMesh)
-
-        return np.concatenate(Ds)
-
-    @Utils.requires('prob')
-    def evalDeriv(self, U, m):
-        """The Derivative with respect to the fields."""
-        Ds = range(len(self.rxList))
-        for ii, rx in enumerate(self.rxList):
-            Ds[ii] = rx.evalDeriv(U, m,
-                                self.prob.mapping,
-                                self.prob.mesh,
-                                self.prob.timeMesh)
-
-        return sp.vstack(Ds)
-
-class RichardsProblem(Problem.BaseTimeProblem):
-    """docstring for RichardsProblem"""
-
-    boundaryConditions = None
-    initialConditions  = None
-
-    surveyPair  = RichardsSurvey
-    mapPair = RichardsMap
-
-    debug=True
-
-    Solver = Solver
-    solverOpts = {}
-
-    def __init__(self, mesh, mapping=None, **kwargs):
-        Problem.BaseTimeProblem.__init__(self, mesh, mapping=mapping, **kwargs)
-
-    def getBoundaryConditions(self, ii, u_ii):
-        if type(self.boundaryConditions) is np.ndarray:
-            return self.boundaryConditions
-
-        time = self.timeMesh.vectorCCx[ii]
-
-        return self.boundaryConditions(time, u_ii)
-
-    @property
-    def method(self):
-        """Method must be either 'mixed' or 'head'. See notes in Celia et al., 1990."""
-        return getattr(self, '_method', 'mixed')
-    @method.setter
-    def method(self, value):
-        assert value in ['mixed','head'], "method must be 'mixed' or 'head'."
-        self._method = value
-
-    # Setting doNewton will clear the rootFinder, which will be reinitialized when called
-    doNewton = Utils.dependentProperty('_doNewton', False, ['_rootFinder'],
-                "Do a Newton iteration. If False, a Picard iteration will be completed.")
-
-    maxIterRootFinder = Utils.dependentProperty('_maxIterRootFinder', 30, ['_rootFinder'],
-                "Maximum iterations for rootFinder iteration.")
-    tolRootFinder = Utils.dependentProperty('_tolRootFinder', 1e-4, ['_rootFinder'],
-                "Maximum iterations for rootFinder iteration.")
-
-    @property
-    def rootFinder(self):
-        """Root-finding Algorithm"""
-        if getattr(self, '_rootFinder', None) is None:
-            self._rootFinder = Optimization.NewtonRoot(doLS=self.doNewton, maxIter=self.maxIterRootFinder, tol=self.tolRootFinder, Solver=self.Solver)
-        return self._rootFinder
-
-    @Utils.timeIt
-    def fields(self, m):
-        tic = time.time()
-        u = range(self.nT+1)
-        u[0] = self.initialConditions
-        for ii, dt in enumerate(self.timeSteps):
-            bc = self.getBoundaryConditions(ii, u[ii])
-            u[ii+1] = self.rootFinder.root(lambda hn1m, return_g=True: self.getResidual(m, u[ii], hn1m, dt, bc, return_g=return_g), u[ii])
-            if self.debug: print "Solving Fields (%4d/%d - %3.1f%% Done) %d Iterations, %4.2f seconds"%(ii+1, self.nT, 100.0*(ii+1)/self.nT, self.rootFinder.iter, time.time() - tic)
-        return u
-
-    @Utils.timeIt
-    def diagsJacobian(self, m, hn, hn1, dt, bc):
-
-        DIV  = self.mesh.faceDiv
-        GRAD = self.mesh.cellGrad
-        BC   = self.mesh.cellGradBC
-        AV   = self.mesh.aveF2CC.T
-        if self.mesh.dim == 1:
-            Dz = self.mesh.faceDivx
-        elif self.mesh.dim == 2:
-            Dz = sp.hstack((Utils.spzeros(self.mesh.nC,self.mesh.vnF[0]), self.mesh.faceDivy),format='csr')
-        elif self.mesh.dim == 3:
-            Dz = sp.hstack((Utils.spzeros(self.mesh.nC,self.mesh.vnF[0]+self.mesh.vnF[1]), self.mesh.faceDivz),format='csr')
-
-        dT   = self.mapping.thetaDerivU(hn, m)
-        dT1  = self.mapping.thetaDerivU(hn1, m)
-        K1   = self.mapping.k(hn1, m)
-        dK1  = self.mapping.kDerivU(hn1, m)
-        dKm1 = self.mapping.kDerivM(hn1, m)
-
-        # Compute part of the derivative of:
-        #
-        #       DIV*diag(GRAD*hn1+BC*bc)*(AV*(1.0/K))^-1
-
-        DdiagGh1 = DIV*Utils.sdiag(GRAD*hn1+BC*bc)
-        diagAVk2_AVdiagK2 = Utils.sdiag((AV*(1./K1))**(-2)) * AV*Utils.sdiag(K1**(-2))
-
-        # The matrix that we are computing has the form:
-        #
-        #   -                                      -   -  -     -  -
-        #  |  Adiag                                 | | h1 |   | b1 |
-        #  |   Asub    Adiag                        | | h2 |   | b2 |
-        #  |            Asub    Adiag               | | h3 | = | b3 |
-        #  |                 ...     ...            | | .. |   | .. |
-        #  |                         Asub    Adiag  | | hn |   | bn |
-        #   -                                      -   -  -     -  -
-
-        Asub = (-1.0/dt)*dT
-
-        Adiag = (
-                  (1.0/dt)*dT1
-                 -DdiagGh1*diagAVk2_AVdiagK2*dK1
-                 -DIV*Utils.sdiag(1./(AV*(1./K1)))*GRAD
-                 -Dz*diagAVk2_AVdiagK2*dK1
-                )
-
-        B = DdiagGh1*diagAVk2_AVdiagK2*dKm1 + Dz*diagAVk2_AVdiagK2*dKm1
-
-        return Asub, Adiag, B
-
-    @Utils.timeIt
-    def getResidual(self, m, hn, h, dt, bc, return_g=True):
-        """
-            Where h is the proposed value for the next time iterate (h_{n+1})
-        """
-        DIV  = self.mesh.faceDiv
-        GRAD = self.mesh.cellGrad
-        BC   = self.mesh.cellGradBC
-        AV   = self.mesh.aveF2CC.T
-        if self.mesh.dim == 1:
-            Dz = self.mesh.faceDivx
-        elif self.mesh.dim == 2:
-            Dz = sp.hstack((Utils.spzeros(self.mesh.nC,self.mesh.vnF[0]), self.mesh.faceDivy),format='csr')
-        elif self.mesh.dim == 3:
-            Dz = sp.hstack((Utils.spzeros(self.mesh.nC,self.mesh.vnF[0]+self.mesh.vnF[1]), self.mesh.faceDivz),format='csr')
-
-        T  = self.mapping.theta(h, m)
-        dT = self.mapping.thetaDerivU(h, m)
-        Tn = self.mapping.theta(hn, m)
-        K  = self.mapping.k(h, m)
-        dK = self.mapping.kDerivU(h, m)
-
-        aveK = 1./(AV*(1./K))
-
-        RHS = DIV*Utils.sdiag(aveK)*(GRAD*h+BC*bc) + Dz*aveK
-        if self.method == 'mixed':
-            r = (T-Tn)/dt - RHS
-        elif self.method == 'head':
-            r = dT*(h - hn)/dt - RHS
-
-        if not return_g: return r
-
-        J = dT/dt - DIV*Utils.sdiag(aveK)*GRAD
-        if self.doNewton:
-            DDharmAve = Utils.sdiag(aveK**2)*AV*Utils.sdiag(K**(-2)) * dK
-            J = J - DIV*Utils.sdiag(GRAD*h + BC*bc)*DDharmAve - Dz*DDharmAve
-
-        return r, J
-
-    @Utils.timeIt
-    def Jfull(self, m, f=None):
-        if f is None:
-            f = self.fields(m)
-
-        nn = len(f)-1
-        Asubs, Adiags, Bs = range(nn), range(nn), range(nn)
-        for ii in range(nn):
-            dt = self.timeSteps[ii]
-            bc = self.getBoundaryConditions(ii, f[ii])
-            Asubs[ii], Adiags[ii], Bs[ii] = self.diagsJacobian(m, f[ii], f[ii+1], dt, bc)
-        Ad = sp.block_diag(Adiags)
-        zRight = Utils.spzeros((len(Asubs)-1)*Asubs[0].shape[0],Adiags[0].shape[1])
-        zTop = Utils.spzeros(Adiags[0].shape[0], len(Adiags)*Adiags[0].shape[1])
-        As = sp.vstack((zTop,sp.hstack((sp.block_diag(Asubs[1:]),zRight))))
-        A = As + Ad
-        B = np.array(sp.vstack(Bs).todense())
-
-        Ainv = self.Solver(A, **self.solverOpts)
-        P = self.survey.evalDeriv(f, m)
-        AinvB = Ainv * B
-        z = np.zeros((self.mesh.nC, B.shape[1]))
-        zAinvB = np.vstack((z, AinvB))
-        J = P * zAinvB
-        return J
-
-    @Utils.timeIt
-    def Jvec(self, m, v, f=None):
-        if f is None:
-            f = self.fields(m)
-
-        JvC = range(len(f)-1) # Cell to hold each row of the long vector.
-
-        # This is done via forward substitution.
-        bc = self.getBoundaryConditions(0, f[0])
-        temp, Adiag, B = self.diagsJacobian(m, f[0], f[1], self.timeSteps[0], bc)
-        Adiaginv = self.Solver(Adiag, **self.solverOpts)
-        JvC[0] = Adiaginv * (B*v)
-
-        for ii in range(1,len(f)-1):
-            bc = self.getBoundaryConditions(ii, f[ii])
-            Asub, Adiag, B = self.diagsJacobian(m, f[ii], f[ii+1], self.timeSteps[ii], bc)
-            Adiaginv = self.Solver(Adiag, **self.solverOpts)
-            JvC[ii] = Adiaginv * (B*v - Asub*JvC[ii-1])
-
-        P = self.survey.evalDeriv(f, m)
-        return P * np.concatenate([np.zeros(self.mesh.nC)] + JvC)
-
-    @Utils.timeIt
-    def Jtvec(self, m, v, f=None):
-        if f is None:
-            f = self.field(m)
-
-        P = self.survey.evalDeriv(f, m)
-        PTv = P.T*v
-
-        # This is done via backward substitution.
-        minus = 0
-        BJtv = 0
-        for ii in range(len(f)-1,0,-1):
-            bc = self.getBoundaryConditions(ii-1, f[ii-1])
-            Asub, Adiag, B = self.diagsJacobian(m, f[ii-1], f[ii], self.timeSteps[ii-1], bc)
-            #select the correct part of v
-            vpart = range((ii)*Adiag.shape[0], (ii+1)*Adiag.shape[0])
-            AdiaginvT = self.Solver(Adiag.T, **self.solverOpts)
-            JTvC = AdiaginvT * (PTv[vpart] - minus)
-            minus = Asub.T*JTvC  # this is now the super diagonal.
-            BJtv = BJtv + B.T*JTvC
-
-        return BJtv

SimPEG/FLOW/Richards/__init__.py

@@ -1,2 +0,0 @@
-import Empirical
-from RichardsProblem import *

SimPEG/FLOW/__init__.py

@@ -1 +0,0 @@
-import Richards

SimPEG/InvProblem.py

@@ -66,8 +66,8 @@ class BaseInvProblem(object):
         self.curModel = m0
 
         print """SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.
-                    ***Done using same Solver and solverOpts as the problem***"""
-        self.opt.bfgsH0 = self.prob.Solver(self.reg.eval2Deriv(self.curModel), **self.prob.solverOpts)
+                    ***Done using same solver as the problem***"""
+        self.opt.bfgsH0 = self.prob.Solver(self.reg.eval2Deriv(self.curModel))
 
     @property
     def warmstart(self):
@@ -82,23 +82,23 @@ class BaseInvProblem(object):
         self._warmstart = value
 
     def getFields(self, m, store=False, deleteWarmstart=True):
-        f = None
+        u = None
 
         for mtest, u_ofmtest in self.warmstart:
             if m is mtest:
-                f = u_ofmtest
+                u = u_ofmtest
                 if self.debug: print 'InvProb is Warm Starting!'
                 break
 
-        if f is None:
-            f = self.prob.fields(m)
+        if u is None:
+            u = self.prob.fields(m)
 
         if deleteWarmstart:
             self.warmstart = []
         if store:
-            self.warmstart += [(m,f)]
+            self.warmstart += [(m,u)]
 
-        return f
+        return u
 
     @Utils.timeIt
     def evalFunction(self, m, return_g=True, return_H=True):
@@ -109,21 +109,21 @@ class BaseInvProblem(object):
         gc.collect()
 
         # Store fields if doing a line-search
-        f = self.getFields(m, store=(return_g==False and return_H==False))
+        u = self.getFields(m, store=(return_g==False and return_H==False))
 
-        phi_d = self.dmisfit.eval(m, f=f)
+        phi_d = self.dmisfit.eval(m, u=u)
         phi_m = self.reg.eval(m)
 
-        self.dpred = self.survey.dpred(m, f=f)  # This is a cheap matrix vector calculation.
+        self.dpred = self.survey.dpred(m, u=u)  # This is a cheap matrix vector calculation.
 
         self.phi_d, self.phi_d_last  = phi_d, self.phi_d
         self.phi_m, self.phi_m_last  = phi_m, self.phi_m
 
-        phi = phi_d + self.beta * phi_m
+        f = phi_d + self.beta * phi_m
 
-        out = (phi,)
+        out = (f,)
         if return_g:
-            phi_dDeriv = self.dmisfit.evalDeriv(m, f=f)
+            phi_dDeriv = self.dmisfit.evalDeriv(m, u=u)
             phi_mDeriv = self.reg.evalDeriv(m)
 
             g = phi_dDeriv + self.beta * phi_mDeriv
@@ -131,7 +131,7 @@ class BaseInvProblem(object):
 
         if return_H:
             def H_fun(v):
-                phi_d2Deriv = self.dmisfit.eval2Deriv(m, v, f=f)
+                phi_d2Deriv = self.dmisfit.eval2Deriv(m, v, u=u)
                 phi_m2Deriv = self.reg.eval2Deriv(m, v=v)
 
                 return phi_d2Deriv + self.beta * phi_m2Deriv

SimPEG/Inversion.py

@@ -33,9 +33,7 @@ class BaseInversion(object):
         self._directiveList = value
         self._directiveList.inversion = self
 
-    def __init__(self, invProb, directiveList=None, **kwargs):
-        if directiveList is None:
-            directiveList = []
+    def __init__(self, invProb, directiveList=[], **kwargs):
         self.directiveList = directiveList
         Utils.setKwargs(self, **kwargs)
 

SimPEG/MT/BaseMT.py

@@ -1,132 +0,0 @@
-from SimPEG import SolverLU as SimpegSolver, PropMaps, Utils, mkvc, sp, np
-from SimPEG.EM.FDEM.FDEM import BaseFDEMProblem
-from SurveyMT import Survey, Data
-from FieldsMT import BaseMTFields
-
-
-class BaseMTProblem(BaseFDEMProblem):
-    """
-        Base class for all Natural source problems.
-    """
-
-    def __init__(self, mesh, **kwargs):
-        BaseFDEMProblem.__init__(self, mesh, **kwargs)
-        Utils.setKwargs(self, **kwargs)
-    # Set the default pairs of the problem
-    surveyPair = Survey
-    dataPair = Data
-    fieldsPair = BaseMTFields
-
-    # Set the solver
-    Solver = SimpegSolver
-    solverOpts = {}
-
-    verbose = False
-    # Notes:
-    # Use the forward and devs from BaseFDEMProblem
-    # Might need to add more stuff here.
-
-    ## NEED to clean up the Jvec and Jtvec to use Zero and Identities for None components.
-    def Jvec(self, m, v, f=None):
-        """
-        Function to calculate the data sensitivities dD/dm times a vector.
-
-            :param numpy.ndarray m (nC, 1) - conductive model
-            :param numpy.ndarray v (nC, 1) - random vector
-            :param MTfields object (optional) - MT fields object, if not given it is calculated
-            :rtype: MTdata object
-            :return: Data sensitivities wrt m
-        """
-
-        # Calculate the fields
-        if f is None:
-           f= self.fields(m)
-        # Set current model
-        self.curModel = m
-        # Initiate the Jv object
-        Jv = self.dataPair(self.survey)
-
-        # Loop all the frequenies
-        for freq in self.survey.freqs:
-            dA_du = self.getA(freq) #
-
-            dA_duI = self.Solver(dA_du, **self.solverOpts)
-
-            for src in self.survey.getSrcByFreq(freq):
-                # We need fDeriv_m = df/du*du/dm + df/dm
-                # Construct du/dm, it requires a solve
-                # NOTE: need to account for the 2 polarizations in the derivatives.
-                f_src = f[src,:]
-                # dA_dm and dRHS_dm should be of size nE,2, so that we can multiply by dA_duI. The 2 columns are each of the polarizations.
-                dA_dm = self.getADeriv_m(freq, f_src, v) # Size: nE,2 (u_px,u_py) in the columns.
-                dRHS_dm = self.getRHSDeriv_m(freq, v) # Size: nE,2 (u_px,u_py) in the columns.
-                if dRHS_dm is None:
-                    du_dm = dA_duI * ( -dA_dm )
-                else:
-                    du_dm = dA_duI * ( -dA_dm + dRHS_dm )
-                # Calculate the projection derivatives
-                for rx in src.rxList:
-                    # Get the projection derivative
-                    # v should be of size 2*nE (for 2 polarizations)
-                    PDeriv_u = lambda t: rx.evalDeriv(src, self.mesh, f, t) # wrt u, we don't have have PDeriv wrt m
-                    Jv[src, rx] = PDeriv_u(mkvc(du_dm))
-            dA_duI.clean()
-        # Return the vectorized sensitivities
-        return mkvc(Jv)
-
-    def Jtvec(self, m, v, f=None):
-        """
-        Function to calculate the transpose of the data sensitivities (dD/dm)^T times a vector.
-
-            :param numpy.ndarray m (nC, 1) - conductive model
-            :param numpy.ndarray v (nD, 1) - vector
-            :param MTfields object u (optional) - MT fields object, if not given it is calculated
-            :rtype: MTdata object
-            :return: Data sensitivities wrt m
-        """
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-
-        # Ensure v is a data object.
-        if not isinstance(v, self.dataPair):
-            v = self.dataPair(self.survey, v)
-
-        Jtv = np.zeros(m.size)
-
-        for freq in self.survey.freqs:
-            AT = self.getA(freq).T
-
-            ATinv = self.Solver(AT, **self.solverOpts)
-
-            for src in self.survey.getSrcByFreq(freq):
-                ftype = self._fieldType + 'Solution'
-                f_src = f[src, :]
-
-                for rx in src.rxList:
-                    # Get the adjoint evalDeriv
-                    # PTv needs to be nE,
-                    PTv = rx.evalDeriv(src, self.mesh, f, mkvc(v[src, rx],2), adjoint=True) # wrt u, need possibility wrt m
-                    # Get the
-                    dA_duIT = ATinv * PTv
-                    dA_dmT = self.getADeriv_m(freq, f_src, mkvc(dA_duIT), adjoint=True)
-                    dRHS_dmT = self.getRHSDeriv_m(freq, mkvc(dA_duIT), adjoint=True)
-                    # Make du_dmT
-                    if dRHS_dmT is None:
-                        du_dmT = -dA_dmT
-                    else:
-                        du_dmT = -dA_dmT + dRHS_dmT
-                    # Select the correct component
-                    # du_dmT needs to be of size nC,
-                    real_or_imag = rx.projComp
-                    if real_or_imag == 'real':
-                        Jtv +=  du_dmT.real
-                    elif real_or_imag == 'imag':
-                        Jtv +=  -du_dmT.real
-                    else:
-                        raise Exception('Must be real or imag')
-            # Clean the factorization, clear memory.
-            ATinv.clean()
-        return Jtv

SimPEG/MT/FieldsMT.py

@@ -1,351 +0,0 @@
-from SimPEG import Survey, Utils, Problem, np, sp, mkvc
-from scipy.constants import mu_0
-import sys
-from numpy.lib import recfunctions as recFunc
-from SimPEG.EM.Utils import omega
-
-##############
-### Fields ###
-##############
-class BaseMTFields(Problem.Fields):
-    """Field Storage for a MT survey."""
-    knownFields = {}
-    dtype = complex
-
-
-class Fields1D_e(BaseMTFields):
-    """
-    Fields storage for the 1D MT solution.
-    """
-    knownFields = {'e_1dSolution':'F'}
-    aliasFields = {
-                    'e_1d' : ['e_1dSolution','F','_e'],
-                    'e_1dPrimary' : ['e_1dSolution','F','_ePrimary'],
-                    'e_1dSecondary' : ['e_1dSolution','F','_eSecondary'],
-                    'b_1d' : ['e_1dSolution','E','_b'],
-                    'b_1dPrimary' : ['e_1dSolution','E','_bPrimary'],
-                    'b_1dSecondary' : ['e_1dSolution','E','_bSecondary']
-                  }
-
-    def __init__(self,mesh,survey,**kwargs):
-        BaseMTFields.__init__(self,mesh,survey,**kwargs)
-
-    def _ePrimary(self, eSolution, srcList):
-        ePrimary = np.zeros_like(eSolution)
-        for i, src in enumerate(srcList):
-            ep = src.ePrimary(self.survey.prob)
-            if ep is not None:
-                ePrimary[:,i] = ep[:,-1]
-        return ePrimary
-
-    def _eSecondary(self, eSolution, srcList):
-        return eSolution
-
-    def _e(self, eSolution, srcList):
-        return self._ePrimary(eSolution,srcList) + self._eSecondary(eSolution,srcList)
-
-    def _eDeriv_u(self, src, v, adjoint = False):
-        return v
-
-    def _eDeriv_m(self, src, v, adjoint = False):
-        # assuming primary does not depend on the model
-        return None
-
-    def _bPrimary(self, eSolution, srcList):
-        bPrimary = np.zeros([self.survey.mesh.nE,eSolution.shape[1]], dtype = complex)
-        for i, src in enumerate(srcList):
-            bp = src.bPrimary(self.survey.prob)
-            if bp is not None:
-                bPrimary[:,i] += bp[:,-1]
-        return bPrimary
-
-    def _bSecondary(self, eSolution, srcList):
-        C = self.mesh.nodalGrad
-        b = (C * eSolution)
-        for i, src in enumerate(srcList):
-            b[:,i] *= - 1./(1j*omega(src.freq))
-            # There is no magnetic source in the MT problem
-            # S_m, _ = src.eval(self.survey.prob)
-            # if S_m is not None:
-            #     b[:,i] += 1./(1j*omega(src.freq)) * S_m
-        return b
-
-    def _b(self, eSolution, srcList):
-        return self._bPrimary(eSolution, srcList) + self._bSecondary(eSolution, srcList)
-
-    def _bSecondaryDeriv_u(self, src, v, adjoint = False):
-        C = self.mesh.nodalGrad
-        if adjoint:
-            return - 1./(1j*omega(src.freq)) * (C.T * v)
-        return - 1./(1j*omega(src.freq)) * (C * v)
-
-    def _bSecondaryDeriv_m(self, src, v, adjoint = False):
-        # Doesn't depend on m
-        # _, S_eDeriv = src.evalDeriv(self.survey.prob, adjoint)
-        # S_eDeriv = S_eDeriv(v)
-        # if S_eDeriv is not None:
-        #     return 1./(1j * omega(src.freq)) * S_eDeriv
-        return None
-
-    def _bDeriv_u(self, src, v, adjoint=False):
-        # Primary does not depend on u
-        return self._bSecondaryDeriv_u(src, v, adjoint)
-
-    def _bDeriv_m(self, src, v, adjoint=False):
-        # Assuming the primary does not depend on the model
-        return self._bSecondaryDeriv_m(src, v, adjoint)
-
-    def _fDeriv_u(self, src, v, adjoint=False):
-        """
-        Derivative of the fields object wrt u.
-
-        :param MTsrc src: MT source
-        :param numpy.ndarray v: random vector of f_sol.size
-        This function stacks the fields derivatives appropriately
-
-        return a vector of size (nreEle+nrbEle)
-        """
-
-        de_du = v #Utils.spdiag(np.ones((self.nF,)))
-        db_du = self._bDeriv_u(src, v, adjoint)
-        # Return the stack
-        # This doesn't work...
-        return np.vstack((de_du,db_du))
-
-    def _fDeriv_m(self, src, v, adjoint=False):
-        """
-        Derivative of the fields object wrt m.
-
-        This function stacks the fields derivatives appropriately
-        """
-        return None
-
-class Fields3D_e(BaseMTFields):
-    """
-    Fields storage for the 3D MT solution. Labels polarizations by px and py.
-
-        :param SimPEG object mesh: The solution mesh
-        :param SimPEG object survey: A survey object
-    """
-    # Define the known the alias fields
-    # Assume that the solution of e on the E.
-    ## NOTE: Need to make this more general, to allow for other solutions formats.
-    knownFields = {'e_pxSolution':'E','e_pySolution':'E'}
-    aliasFields = {
-                    'e_px' : ['e_pxSolution','E','_e_px'],
-                    'e_pxPrimary' : ['e_pxSolution','E','_e_pxPrimary'],
-                    'e_pxSecondary' : ['e_pxSolution','E','_e_pxSecondary'],
-                    'e_py' : ['e_pySolution','E','_e_py'],
-                    'e_pyPrimary' : ['e_pySolution','E','_e_pyPrimary'],
-                    'e_pySecondary' : ['e_pySolution','E','_e_pySecondary'],
-                    'b_px' : ['e_pxSolution','F','_b_px'],
-                    'b_pxPrimary' : ['e_pxSolution','F','_b_pxPrimary'],
-                    'b_pxSecondary' : ['e_pxSolution','F','_b_pxSecondary'],
-                    'b_py' : ['e_pySolution','F','_b_py'],
-                    'b_pyPrimary' : ['e_pySolution','F','_b_pyPrimary'],
-                    'b_pySecondary' : ['e_pySolution','F','_b_pySecondary']
-                  }
-
-    def __init__(self,mesh,survey,**kwargs):
-        BaseMTFields.__init__(self,mesh,survey,**kwargs)
-
-    def _e_pxPrimary(self, e_pxSolution, srcList):
-        e_pxPrimary = np.zeros_like(e_pxSolution)
-        for i, src in enumerate(srcList):
-            ep = src.ePrimary(self.survey.prob)
-            if ep is not None:
-                e_pxPrimary[:,i] = ep[:,0]
-        return e_pxPrimary
-
-    def _e_pyPrimary(self, e_pySolution, srcList):
-        e_pyPrimary = np.zeros_like(e_pySolution)
-        for i, src in enumerate(srcList):
-            ep = src.ePrimary(self.survey.prob)
-            if ep is not None:
-                e_pyPrimary[:,i] = ep[:,1]
-        return e_pyPrimary
-
-    def _e_pxSecondary(self, e_pxSolution, srcList):
-        return e_pxSolution
-
-    def _e_pySecondary(self, e_pySolution, srcList):
-        return e_pySolution
-
-    def _e_px(self, e_pxSolution, srcList):
-        return self._e_pxPrimary(e_pxSolution,srcList) + self._e_pxSecondary(e_pxSolution,srcList)
-
-    def _e_py(self, e_pySolution, srcList):
-        return self._e_pyPrimary(e_pySolution,srcList) + self._e_pySecondary(e_pySolution,srcList)
-
-    #NOTE: For e_p?Deriv_u,
-    # v has to be u(2*nE) long for the not adjoint and nE long for adjoint.
-    # Returns nE long for not adjoint and 2*nE long for adjoint
-    def _e_pxDeriv_u(self, src, v, adjoint = False):
-        '''
-        Takes the derivative of e_px wrt u
-        '''
-        if adjoint:
-            # adjoint: returns a 2*nE long vector with zero's for py
-            return np.vstack((v,np.zeros_like(v)))
-        # Not adjoint: return only the px part of the vector
-        return v[:len(v)/2]
-
-    def _e_pyDeriv_u(self, src, v, adjoint = False):
-        '''
-        Takes the derivative of e_py wrt u
-        '''
-        if adjoint:
-            # adjoint: returns a 2*nE long vector with zero's for px
-            return np.vstack((np.zeros_like(v),v))
-        # Not adjoint: return only the px part of the vector
-        return v[len(v)/2::]
-
-    def _e_pxDeriv_m(self, src, v, adjoint = False):
-        # assuming primary does not depend on the model
-        return None
-    def _e_pyDeriv_m(self, src, v, adjoint = False):
-        # assuming primary does not depend on the model
-        return None
-
-    def _b_pxPrimary(self, e_pxSolution, srcList):
-        b_pxPrimary = np.zeros([self.survey.mesh.nF,e_pxSolution.shape[1]], dtype = complex)
-        for i, src in enumerate(srcList):
-            bp = src.bPrimary(self.survey.prob)
-            if bp is not None:
-                b_pxPrimary[:,i] += bp[:,0]
-        return b_pxPrimary
-
-    def _b_pyPrimary(self, e_pySolution, srcList):
-        b_pyPrimary = np.zeros([self.survey.mesh.nF,e_pySolution.shape[1]], dtype = complex)
-        for i, src in enumerate(srcList):
-            bp = src.bPrimary(self.survey.prob)
-            if bp is not None:
-                b_pyPrimary[:,i] += bp[:,1]
-        return b_pyPrimary
-
-    def _b_pxSecondary(self, e_pxSolution, srcList):
-        C = self.mesh.edgeCurl
-        b = (C * e_pxSolution)
-        for i, src in enumerate(srcList):
-            b[:,i] *= - 1./(1j*omega(src.freq))
-            # There is no magnetic source in the MT problem
-            # S_m, _ = src.eval(self.survey.prob)
-            # if S_m is not None:
-            #     b[:,i] += 1./(1j*omega(src.freq)) * S_m
-        return b
-
-    def _b_pySecondary(self, e_pySolution, srcList):
-        C = self.mesh.edgeCurl
-        b = (C * e_pySolution)
-        for i, src in enumerate(srcList):
-            b[:,i] *= - 1./(1j*omega(src.freq))
-            # There is no magnetic source in the MT problem
-            # S_m, _ = src.eval(self.survey.prob)
-            # if S_m is not None:
-            #     b[:,i] += 1./(1j*omega(src.freq)) * S_m
-        return b
-
-    def _b_px(self, eSolution, srcList):
-        return self._b_pxPrimary(eSolution, srcList) + self._b_pxSecondary(eSolution, srcList)
-
-    def _b_py(self, eSolution, srcList):
-        return self._b_pyPrimary(eSolution, srcList) + self._b_pySecondary(eSolution, srcList)
-
-    # NOTE: v needs to be length 2*nE to account for both polarizations
-    def _b_pxSecondaryDeriv_u(self, src, v, adjoint = False):
-        # C = sp.kron(self.mesh.edgeCurl,[[1,0],[0,0]])
-        C = sp.hstack((self.mesh.edgeCurl,Utils.spzeros(self.mesh.nF,self.mesh.nE))) # This works for adjoint = None
-        if adjoint:
-            return - 1./(1j*omega(src.freq)) * (C.T * v)
-        return - 1./(1j*omega(src.freq)) * (C * v)
-
-    def _b_pySecondaryDeriv_u(self, src, v, adjoint = False):
-        # C = sp.kron(self.mesh.edgeCurl,[[0,0],[0,1]])
-        C = sp.hstack((Utils.spzeros(self.mesh.nF,self.mesh.nE),self.mesh.edgeCurl)) # This works for adjoint = None
-        if adjoint:
-            return - 1./(1j*omega(src.freq)) * (C.T * v)
-        return - 1./(1j*omega(src.freq)) * (C * v)
-
-    def _b_pxSecondaryDeriv_m(self, src, v, adjoint = False):
-        # Doesn't depend on m
-        # _, S_eDeriv = src.evalDeriv(self.survey.prob, adjoint)
-        # S_eDeriv = S_eDeriv(v)
-        # if S_eDeriv is not None:
-        #     return 1./(1j * omega(src.freq)) * S_eDeriv
-        return None
-
-    def _b_pySecondaryDeriv_m(self, src, v, adjoint = False):
-        # Doesn't depend on m
-        # _, S_eDeriv = src.evalDeriv(self.survey.prob, adjoint)
-        # S_eDeriv = S_eDeriv(v)
-        # if S_eDeriv is not None:
-        #     return 1./(1j * omega(src.freq)) * S_eDeriv
-        return None
-
-    def _b_pxDeriv_u(self, src, v, adjoint=False):
-        # Primary does not depend on u
-        return self._b_pxSecondaryDeriv_u(src, v, adjoint)
-
-    def _b_pyDeriv_u(self, src, v, adjoint=False):
-        # Primary does not depend on u
-        return self._b_pySecondaryDeriv_u(src, v, adjoint)
-
-    def _b_pxDeriv_m(self, src, v, adjoint=False):
-        # Assuming the primary does not depend on the model
-        return self._b_pxSecondaryDeriv_m(src, v, adjoint)
-
-    def _b_pyDeriv_m(self, src, v, adjoint=False):
-        # Assuming the primary does not depend on the model
-        return self._b_pySecondaryDeriv_m(src, v, adjoint)
-
-    def _f_pxDeriv_u(self, src, v, adjoint=False):
-        """
-        Derivative of the fields object wrt u.
-
-        :param MTsrc src: MT source
-        :param numpy.ndarray v: random vector of f_sol.size
-        This function stacks the fields derivatives appropriately
-
-        return a vector of size (nreEle+nrbEle)
-        """
-
-        de_du = v #Utils.spdiag(np.ones((self.nF,)))
-        db_du = self._b_pxDeriv_u(src, v, adjoint)
-        # Return the stack
-        # This doesn't work...
-        return np.vstack((de_du,db_du))
-
-    def _f_pyDeriv_u(self, src, v, adjoint=False):
-        """
-        Derivative of the fields object wrt u.
-
-        :param MTsrc src: MT source
-        :param numpy.ndarray v: random vector of f_sol.size
-        This function stacks the fields derivatives appropriately
-
-        return a vector of size (nreEle+nrbEle)
-        """
-
-        de_du = v #Utils.spdiag(np.ones((self.nF,)))
-        db_du = self._b_pyDeriv_u(src, v, adjoint)
-        # Return the stack
-        # This doesn't work...
-        return np.vstack((de_du,db_du))
-
-    def _f_pxDeriv_m(self, src, v, adjoint=False):
-        """
-        Derivative of the fields object wrt m.
-
-        This function stacks the fields derivatives appropriately
-        """
-        # The fields have no dependance to the model.
-        return None
-
-    def _f_pyDeriv_m(self, src, v, adjoint=False):
-        """
-        Derivative of the fields object wrt m.
-
-        This function stacks the fields derivatives appropriately
-        """
-        # The fields have no dependance to the model.
-        return None

SimPEG/MT/Problem1D/Probs.py

@@ -1,291 +0,0 @@
-from SimPEG.EM.Utils import omega
-from SimPEG import mkvc
-from scipy.constants import mu_0
-from SimPEG.MT.BaseMT import BaseMTProblem
-from SimPEG.MT.SurveyMT import Survey, Data
-from SimPEG.MT.FieldsMT import Fields1D_e
-from SimPEG.MT.Utils.MT1Danalytic import getEHfields
-import numpy as np
-import multiprocessing, sys, time
-
-
-class eForm_psField(BaseMTProblem):
-    """
-    A MT problem soving a e formulation and primary/secondary fields decomposion.
-
-    By eliminating the magnetic flux density using
-
-        .. math ::
-
-            \mathbf{b} = \\frac{1}{i \omega}\\left(-\mathbf{C} \mathbf{e} \\right)
-
-
-    we can write Maxwell's equations as a second order system in \\\(\\\mathbf{e}\\\) only:
-
-    .. math ::
-        \\left(\mathbf{C}^T \mathbf{M^e_{\mu^{-1}}} \mathbf{C} + i \omega \mathbf{M^f_\sigma}] \mathbf{e}_{s} =& i \omega \mathbf{M^f_{\delta \sigma}} \mathbf{e}_{p}
-    which we solve for \\\(\\\mathbf{e_s}\\\). The total field \\\mathbf{e}\\ = \\\mathbf{e_p}\\ + \\\mathbf{e_s}\\.
-
-    The primary field is estimated from a background model (commonly half space ).
-
-
-    """
-    # From FDEMproblem: Used to project the fields. Currently not used for MTproblem.
-    _fieldType = 'e_1d'
-    _eqLocs    = 'EF'
-    _sigmaPrimary = None
-
-
-    def __init__(self, mesh, **kwargs):
-        BaseMTProblem.__init__(self, mesh, **kwargs)
-        self.fieldsPair = Fields1D_e
-        # self._sigmaPrimary = sigmaPrimary
-    @property
-    def MeMui(self):
-        """
-            Edge inner product matrix
-        """
-        if getattr(self, '_MeMui', None) is None:
-            self._MeMui = self.mesh.getEdgeInnerProduct(1.0/mu_0)
-        return self._MeMui
-
-    @property
-    def MfSigma(self):
-        """
-            Edge inner product matrix
-        """
-        if getattr(self, '_MfSigma', None) is None:
-            self._MfSigma = self.mesh.getFaceInnerProduct(self.curModel.sigma)
-        return self._MfSigma
-
-    @property
-    def sigmaPrimary(self):
-        """
-        A background model, use for the calculation of the primary fields.
-
-        """
-        return self._sigmaPrimary
-
-    @sigmaPrimary.setter
-    def sigmaPrimary(self, val):
-        # Note: TODO add logic for val, make sure it is the correct size.
-        self._sigmaPrimary = val
-
-    def getA(self, freq):
-        """
-            Function to get the A matrix.
-
-            :param float freq: Frequency
-            :rtype: scipy.sparse.csr_matrix
-            :return: A
-        """
-
-        # Note: need to use the code above since in the 1D problem I want
-        # e to live on Faces(nodes) and h on edges(cells). Might need to rethink this
-        # Possible that _fieldType and _eqLocs can fix this
-        MeMui = self.MeMui
-        MfSigma = self.MfSigma
-        C = self.mesh.nodalGrad
-        # Make A
-        A = C.T*MeMui*C + 1j*omega(freq)*MfSigma
-        # Either return full or only the inner part of A
-        return A
-
-    def getADeriv_m(self, freq, u, v, adjoint=False):
-        """
-        The derivative of A wrt sigma
-        """
-
-        dsig_dm = self.curModel.sigmaDeriv
-        MeMui = self.MeMui
-        #
-        u_src = u['e_1dSolution']
-        dMfSigma_dm = self.mesh.getFaceInnerProductDeriv(self.curModel.sigma)(u_src) * self.curModel.sigmaDeriv
-        if adjoint:
-            return 1j * omega(freq) * (  dMfSigma_dm.T * v )
-        # Note: output has to be nN/nF, not nC/nE.
-        # v should be nC
-        return 1j * omega(freq) * ( dMfSigma_dm * v )
-
-    def getRHS(self, freq):
-        """
-            Function to return the right hand side for the system.
-            :param float freq: Frequency
-            :rtype: numpy.ndarray (nF, 1), numpy.ndarray (nF, 1)
-            :return: RHS for 1 polarizations, primary fields
-        """
-
-        # Get sources for the frequncy(polarizations)
-        Src = self.survey.getSrcByFreq(freq)[0]
-        S_e = Src.S_e(self)
-        return -1j * omega(freq) * S_e
-
-    def getRHSDeriv_m(self, freq, v, adjoint=False):
-        """
-        The derivative of the RHS wrt sigma
-        """
-
-        Src = self.survey.getSrcByFreq(freq)[0]
-        S_eDeriv = Src.S_eDeriv_m(self, v, adjoint)
-        return -1j * omega(freq) * S_eDeriv
-
-    def fields(self, m):
-        '''
-        Function to calculate all the fields for the model m.
-
-        :param np.ndarray (nC,) m: Conductivity model
-        '''
-        # Set the current model
-        self.curModel = m
-
-        F = Fields1D_e(self.mesh, self.survey)
-        for freq in self.survey.freqs:
-            if self.verbose:
-                startTime = time.time()
-                print 'Starting work for {:.3e}'.format(freq)
-                sys.stdout.flush()
-            A = self.getA(freq)
-            rhs  = self.getRHS(freq)
-            Ainv = self.Solver(A, **self.solverOpts)
-            e_s = Ainv * rhs
-
-            # Store the fields
-            Src = self.survey.getSrcByFreq(freq)[0]
-            # NOTE: only store the e_solution(secondary), all other components calculated in the fields object
-            F[Src, 'e_1dSolution'] = e_s[:,-1] # Only storing the yx polarization as 1d
-
-            # Note curl e = -iwb so b = -curl e /iw
-            # b = -( self.mesh.nodalGrad * e )/( 1j*omega(freq) )
-            # F[Src, 'b_1d'] = b[:,1]
-            if self.verbose:
-                print 'Ran for {:f} seconds'.format(time.time()-startTime)
-                sys.stdout.flush()
-        return F
-
-# Note this is not fully functional.
-# Missing:
-# Fields class corresponding to the fields
-# Update Jvec and Jtvec to include all the derivatives components
-# Other things ...
-class eForm_TotalField(BaseMTProblem):
-    """
-    A MT problem solving a e formulation and a Total bondary domain decompostion.
-
-    Solves the equation:
-
-    Math:
-
-
-    """
-
-    # From FDEMproblem: Used to project the fields. Currently not used for MTproblem.
-    _fieldType = 'e'
-    _eqLocs    = 'EF'
-
-
-    def __init__(self, mesh, **kwargs):
-        BaseMTProblem.__init__(self, mesh, **kwargs)
-    @property
-    def MeMui(self):
-        """
-            Edge inner product matrix
-        """
-        if getattr(self, '_MeMui', None) is None:
-            self._MeMui = self.mesh.getEdgeInnerProduct(1.0/mu_0)
-        return self._MeMui
-
-    @property
-    def MfSigma(self):
-        """
-            Edge inner product matrix
-        """
-        if getattr(self, '_MfSigma', None) is None:
-            self._MfSigma = self.mesh.getFaceInnerProduct(self.curModel.sigma)
-        return self._MfSigma
-
-    def getA(self, freq, full=False):
-        """
-            Function to get the A matrix.
-
-            :param float freq: Frequency
-            :param logic full: Return full A or the inner part
-            :rtype: scipy.sparse.csr_matrix
-            :return: A
-        """
-
-        MeMui = self.MeMui
-        MfSigma = self.MfSigma
-        # Note: need to use the code above since in the 1D problem I want
-        # e to live on Faces(nodes) and h on edges(cells). Might need to rethink this
-        # Possible that _fieldType and _eqLocs can fix this
-        # MeMui = self.MfMui
-        # MfSigma = self.MfSigma
-        C = self.mesh.nodalGrad
-        # Make A
-        A = C.T*MeMui*C + 1j*omega(freq)*MfSigma
-        # Either return full or only the inner part of A
-        if full:
-            return A
-        else:
-            return A[1:-1,1:-1]
-
-    def getADeriv_m(self, freq, u, v, adjoint=False):
-        raise NotImplementedError('getADeriv is not implemented')
-
-    def getRHS(self, freq):
-        """
-            Function to return the right hand side for the system.
-            :param float freq: Frequency
-            :rtype: numpy.ndarray (nE, 2), numpy.ndarray (nE, 2)
-            :return: RHS for both polarizations, primary fields
-        """
-        # Get sources for the frequency
-        # NOTE: Need to use the source information, doesn't really apply in 1D
-        src = self.survey.getSrcByFreq(freq)
-        # Get the full A
-        A = self.getA(freq,full=True)
-        # Define the outer part of the solution matrix
-        Aio = A[1:-1,[0,-1]]
-        Ed, Eu, Hd, Hu = getEHfields(self.mesh,self.curModel.sigma,freq,self.mesh.vectorNx)
-        Etot = (Ed + Eu)
-        sourceAmp = 1.0
-        Etot = ((Etot/Etot[-1])*sourceAmp) # Scale the fields to be equal to sourceAmp at the top
-        ## Note: The analytic solution is derived with e^iwt
-        eBC = np.r_[Etot[0],Etot[-1]]
-        # The right hand side
-
-        return -Aio*eBC, eBC
-
-    def getRHSderiv_m(self, freq, backSigma, u, v, adjoint=False):
-        raise NotImplementedError('getRHSDeriv not implemented yet')
-        return None
-
-    def fields(self, m):
-        '''
-        Function to calculate all the fields for the model m.
-
-        :param np.ndarray (nC,) m: Conductivity model
-        :param np.ndarray (nC,) m_back: Background conductivity model
-        '''
-        self.curModel = m
-        # RHS, CalcFields = self.getRHS(freq,m_back), self.calcFields
-
-        F = Fields1D_e(self.mesh, self.survey)
-        for freq in self.survey.freqs:
-            if self.verbose:
-                startTime = time.time()
-                print 'Starting work for {:.3e}'.format(freq)
-                sys.stdout.flush()
-            A = self.getA(freq)
-            rhs, e_o = self.getRHS(freq)
-            Ainv = self.Solver(A, **self.solverOpts)
-            e_i = Ainv * rhs
-            e = mkvc(np.r_[e_o[0], e_i, e_o[1]],2)
-            # Store the fields
-            Src = self.survey.getSrcByFreq(freq)
-            # NOTE: only store e fields
-            F[Src, 'e_1dSolution'] = e[:,0]
-            if self.verbose:
-                print 'Ran for {:f} seconds'.format(time.time()-startTime)
-                sys.stdout.flush()
-        return F

SimPEG/MT/Problem1D/__init__.py

@@ -1 +0,0 @@
-from Probs import eForm_TotalField, eForm_psField

SimPEG/MT/Problem2D/__init__.py

@@ -1 +0,0 @@
-pass

SimPEG/MT/Problem3D/Probs.py

@@ -1,138 +0,0 @@
-from SimPEG import Survey, Problem, Utils, Models, np, sp, mkvc, SolverLU as SimpegSolver
-from SimPEG.EM.Utils import omega
-from scipy.constants import mu_0
-from SimPEG.MT.BaseMT import BaseMTProblem
-from SimPEG.MT.SurveyMT import Survey, Data
-from SimPEG.MT.FieldsMT import Fields3D_e
-import multiprocessing, sys, time
-
-
-
-class eForm_ps(BaseMTProblem):
-    """
-    A MT problem solving a e formulation and a primary/secondary fields decompostion.
-
-    By eliminating the magnetic flux density using
-
-        .. math ::
-
-            \mathbf{b} = \\frac{1}{i \omega}\\left(-\mathbf{C} \mathbf{e} \\right)
-
-
-    we can write Maxwell's equations as a second order system in \\\(\\\mathbf{e}\\\) only:
-
-    .. math ::
-        \\left(\mathbf{C}^T \mathbf{M^f_{\mu^{-1}}} \mathbf{C} + i \omega \mathbf{M^e_\sigma}] \mathbf{e}_{s} =& i \omega \mathbf{M^e_{\delta \sigma}} \mathbf{e}_{p}
-    which we solve for \\\(\\\mathbf{e_s}\\\). The total field \\\mathbf{e}\\ = \\\mathbf{e_p}\\ + \\\mathbf{e_s}\\.
-
-    The primary field is estimated from a background model (commonly as a 1D model).
-
-    """
-
-    # From FDEMproblem: Used to project the fields. Currently not used for MTproblem.
-    _fieldType = 'e'
-    _eqLocs    = 'FE'
-    fieldsPair = Fields3D_e
-    _sigmaPrimary = None
-
-    def __init__(self, mesh, **kwargs):
-        BaseMTProblem.__init__(self, mesh, **kwargs)
-
-    @property
-    def sigmaPrimary(self):
-        """
-        A background model, use for the calculation of the primary fields.
-
-        """
-        return self._sigmaPrimary
-    @sigmaPrimary.setter
-    def sigmaPrimary(self, val):
-        # Note: TODO add logic for val, make sure it is the correct size.
-        self._sigmaPrimary = val
-
-    def getA(self, freq):
-        """
-            Function to get the A system.
-
-            :param float freq: Frequency
-            :rtype: scipy.sparse.csr_matrix
-            :return: A
-        """
-        Mmui = self.MfMui
-        Msig = self.MeSigma
-        C = self.mesh.edgeCurl
-
-        return C.T*Mmui*C + 1j*omega(freq)*Msig
-
-    def getADeriv_m(self, freq, u, v, adjoint=False):
-        """
-        Calculate the derivative of A wrt m.
-
-        """
-
-        # This considers both polarizations and returns a nE,2 matrix for each polarization
-        if adjoint:
-            dMe_dsigV = sp.hstack(( self.MeSigmaDeriv( u['e_pxSolution'] ).T, self.MeSigmaDeriv(u['e_pySolution'] ).T ))*v
-        else:
-            # Need a nE,2 matrix to be returned
-            dMe_dsigV = np.hstack(( mkvc(self.MeSigmaDeriv( u['e_pxSolution'] )*v,2), mkvc( self.MeSigmaDeriv(u['e_pySolution'] )*v,2) ))
-        return 1j * omega(freq) * dMe_dsigV
-
-
-    def getRHS(self, freq):
-        """
-        Function to return the right hand side for the system.
-
-            :param float freq: Frequency
-            :rtype: numpy.ndarray (nE, 2), numpy.ndarray (nE, 2)
-            :return: RHS for both polarizations, primary fields
-        """
-
-        # Get sources for the frequncy(polarizations)
-        Src = self.survey.getSrcByFreq(freq)[0]
-        S_e = Src.S_e(self)
-        return -1j * omega(freq) * S_e
-
-    def getRHSDeriv_m(self, freq, v, adjoint=False):
-        """
-        The derivative of the RHS with respect to sigma
-        """
-
-        Src = self.survey.getSrcByFreq(freq)[0]
-        S_eDeriv = Src.S_eDeriv_m(self, v, adjoint)
-        return -1j * omega(freq) * S_eDeriv
-
-    def fields(self, m):
-        '''
-        Function to calculate all the fields for the model m.
-
-        :param np.ndarray (nC,) m: Conductivity model
-        '''
-        # Set the current model
-        self.curModel = m
-
-        F = Fields3D_e(self.mesh, self.survey)
-        for freq in self.survey.freqs:
-            if self.verbose:
-                startTime = time.time()
-                print 'Starting work for {:.3e}'.format(freq)
-                sys.stdout.flush()
-            A = self.getA(freq)
-            rhs  = self.getRHS(freq)
-            # Solve the system
-            Ainv = self.Solver(A, **self.solverOpts)
-            e_s = Ainv * rhs
-
-            # Store the fields
-            Src = self.survey.getSrcByFreq(freq)[0]
-            # Store the fieldss
-            F[Src, 'e_pxSolution'] = e_s[:,0]
-            F[Src, 'e_pySolution'] = e_s[:,1]
-            # Note curl e = -iwb so b = -curl/iw
-
-            if self.verbose:
-                print 'Ran for {:f} seconds'.format(time.time()-startTime)
-                sys.stdout.flush()
-            Ainv.clean()
-        return F
-

SimPEG/MT/Problem3D/__init__.py

@@ -1 +0,0 @@
-from Probs import eForm_ps

SimPEG/MT/SrcMT.py

@@ -1,206 +0,0 @@
-from SimPEG import Utils, Problem, Maps, np, sp, mkvc
-from SimPEG.EM.FDEM.SrcFDEM import BaseSrc as FDEMBaseSrc
-from SimPEG.EM.Utils import omega
-from scipy.constants import mu_0
-from numpy.lib import recfunctions as recFunc
-from Utils.sourceUtils import homo1DModelSource
-from Utils import rec2ndarr
-import sys
-
-#################
-###   Sources ###
-#################
-
-class BaseMTSrc(FDEMBaseSrc):
-    '''
-    Sources for the MT problem.
-    Use the SimPEG BaseSrc, since the source fields share properties with the transmitters.
-
-    :param float freq: The frequency of the source
-    :param list rxList: A list of receivers associated with the source
-    '''
-
-    freq = None #: Frequency (float)
-
-
-    def __init__(self, rxList, freq):
-
-        self.freq = float(freq)
-        FDEMBaseSrc.__init__(self, rxList)
-
-# 1D sources
-class polxy_1DhomotD(BaseMTSrc):
-    """
-    MT source for both polarizations (x and y) for the total Domain.
-
-    It calculates fields calculated based on conditions on the boundary of the domain.
-    """
-    def __init__(self, rxList, freq):
-        BaseMTSrc.__init__(self, rxList, freq)
-
-
-    # TODO: need to add the  primary fields calc and source terms into the problem.
-
-# Need to implement such that it works for all dims.
-class polxy_1Dprimary(BaseMTSrc):
-    """
-    MT source for both polarizations (x and y) given a 1D primary models.
-    It assigns fields calculated from the 1D model as fields in the full space of the problem.
-    """
-    def __init__(self, rxList, freq):
-        # assert mkvc(self.mesh.hz.shape,1) == mkvc(sigma1d.shape,1),'The number of values in the 1D background model does not match the number of vertical cells (hz).'
-        self.sigma1d = None
-        BaseMTSrc.__init__(self, rxList, freq)
-        # Hidden property of the ePrimary
-        self._ePrimary = None
-
-    def ePrimary(self,problem):
-        # Get primary fields for both polarizations
-        if self.sigma1d is None:
-            # Set the sigma1d as the 1st column in the background model
-            if len(problem._sigmaPrimary) == problem.mesh.nC:
-                if problem.mesh.dim == 1:
-                    self.sigma1d = problem.mesh.r(problem._sigmaPrimary,'CC','CC','M')[:]
-                elif problem.mesh.dim == 3:
-                    self.sigma1d = problem.mesh.r(problem._sigmaPrimary,'CC','CC','M')[0,0,:]
-            # Or as the 1D model that matches the vertical cell number
-            elif len(problem._sigmaPrimary) == problem.mesh.nCz:
-                self.sigma1d = problem._sigmaPrimary
-
-        if self._ePrimary is None:
-            self._ePrimary = homo1DModelSource(problem.mesh,self.freq,self.sigma1d)
-        return self._ePrimary
-
-    def bPrimary(self,problem):
-        # Project ePrimary to bPrimary
-        # Satisfies the primary(background) field conditions
-        if problem.mesh.dim == 1:
-            C = problem.mesh.nodalGrad
-        elif problem.mesh.dim == 3:
-            C = problem.mesh.edgeCurl
-        bBG_bp = (- C * self.ePrimary(problem) )*(1/( 1j*omega(self.freq) ))
-        return bBG_bp
-
-    def S_e(self,problem):
-        """
-        Get the electrical field source
-        """
-        e_p = self.ePrimary(problem)
-        Map_sigma_p = Maps.Vertical1DMap(problem.mesh)
-        sigma_p = Map_sigma_p._transform(self.sigma1d)
-        # Make mass matrix
-        # Note: M(sig) - M(sig_p) = M(sig - sig_p)
-        # Need to deal with the edge/face discrepencies between 1d/2d/3d
-        if problem.mesh.dim == 1:
-            Mesigma = problem.mesh.getFaceInnerProduct(problem.curModel.sigma)
-            Mesigma_p = problem.mesh.getFaceInnerProduct(sigma_p)
-        if problem.mesh.dim == 2:
-            pass
-        if problem.mesh.dim == 3:
-            Mesigma = problem.MeSigma
-            Mesigma_p = problem.mesh.getEdgeInnerProduct(sigma_p)
-        return (Mesigma - Mesigma_p) * e_p
-
-    def S_eDeriv_m(self, problem, v, adjoint = False):
-        '''
-        Get the derivative of S_e wrt to sigma (m)
-        '''
-        # Need to deal with
-        if problem.mesh.dim == 1:
-            # Need to use the faceInnerProduct
-            MsigmaDeriv = problem.mesh.getFaceInnerProductDeriv(problem.curModel.sigma)(self.ePrimary(problem)[:,1]) * problem.curModel.sigmaDeriv
-            # MsigmaDeriv = ( MsigmaDeriv * MsigmaDeriv.T)**2
-        if problem.mesh.dim == 2:
-            pass
-        if problem.mesh.dim == 3:
-            # Need to take the derivative of both u_px and u_py
-            ePri = self.ePrimary(problem)
-            # MsigmaDeriv = problem.MeSigmaDeriv(ePri[:,0]) + problem.MeSigmaDeriv(ePri[:,1])
-            # MsigmaDeriv = problem.MeSigmaDeriv(np.sum(ePri,axis=1))
-            if adjoint:
-                return sp.hstack(( problem.MeSigmaDeriv(ePri[:,0]).T, problem.MeSigmaDeriv(ePri[:,1]).T ))*v
-            else:
-                return np.hstack(( mkvc(problem.MeSigmaDeriv(ePri[:,0]) * v,2), mkvc(problem.MeSigmaDeriv(ePri[:,1])*v,2) ))
-        if adjoint:
-            #
-            return MsigmaDeriv.T * v
-        else:
-            # v should be nC size
-            return MsigmaDeriv * v
-
-class polxy_3Dprimary(BaseMTSrc):
-    """
-    MT source for both polarizations (x and y) given a 3D primary model. It assigns fields calculated from the 1D model
-    as fields in the full space of the problem.
-    """
-    def __init__(self, rxList, freq):
-        # assert mkvc(self.mesh.hz.shape,1) == mkvc(sigma1d.shape,1),'The number of values in the 1D background model does not match the number of vertical cells (hz).'
-        self.sigmaPrimary = None
-        BaseMTSrc.__init__(self, rxList, freq)
-        # Hidden property of the ePrimary
-        self._ePrimary = None
-
-    def ePrimary(self,problem):
-        # Get primary fields for both polarizations
-        self.sigmaPrimary = problem._sigmaPrimary
-
-        if self._ePrimary is None:
-            self._ePrimary = homo3DModelSource(problem.mesh,self.sigmaPrimary,self.freq)
-        return self._ePrimary
-
-    def bPrimary(self,problem):
-        # Project ePrimary to bPrimary
-        # Satisfies the primary(background) field conditions
-        if problem.mesh.dim == 1:
-            C = problem.mesh.nodalGrad
-        elif problem.mesh.dim == 3:
-            C = problem.mesh.edgeCurl
-        bBG_bp = (- C * self.ePrimary(problem) )*(1/( 1j*omega(self.freq) ))
-        return bBG_bp
-
-    def S_e(self,problem):
-        """
-        Get the electrical field source
-        """
-        e_p = self.ePrimary(problem)
-        Map_sigma_p = Maps.Vertical1DMap(problem.mesh)
-        sigma_p = Map_sigma_p._transform(self.sigma1d)
-        # Make mass matrix
-        # Note: M(sig) - M(sig_p) = M(sig - sig_p)
-        # Need to deal with the edge/face discrepencies between 1d/2d/3d
-        if problem.mesh.dim == 1:
-            Mesigma = problem.mesh.getFaceInnerProduct(problem.curModel.sigma)
-            Mesigma_p = problem.mesh.getFaceInnerProduct(sigma_p)
-        if problem.mesh.dim == 2:
-            pass
-        if problem.mesh.dim == 3:
-            Mesigma = problem.MeSigma
-            Mesigma_p = problem.mesh.getEdgeInnerProduct(sigma_p)
-        return (Mesigma - Mesigma_p) * e_p
-
-    def S_eDeriv_m(self, problem, v, adjoint = False):
-        '''
-        Get the derivative of S_e wrt to sigma (m)
-        '''
-        # Need to deal with
-        if problem.mesh.dim == 1:
-            # Need to use the faceInnerProduct
-            MsigmaDeriv = problem.mesh.getFaceInnerProductDeriv(problem.curModel.sigma)(self.ePrimary(problem)[:,1]) * problem.curModel.sigmaDeriv
-            # MsigmaDeriv = ( MsigmaDeriv * MsigmaDeriv.T)**2
-        if problem.mesh.dim == 2:
-            pass
-        if problem.mesh.dim == 3:
-            # Need to take the derivative of both u_px and u_py
-            ePri = self.ePrimary(problem)
-            # MsigmaDeriv = problem.MeSigmaDeriv(ePri[:,0]) + problem.MeSigmaDeriv(ePri[:,1])
-            # MsigmaDeriv = problem.MeSigmaDeriv(np.sum(ePri,axis=1))
-            if adjoint:
-                return sp.hstack(( problem.MeSigmaDeriv(ePri[:,0]).T, problem.MeSigmaDeriv(ePri[:,1]).T ))*v
-            else:
-                return np.hstack(( mkvc(problem.MeSigmaDeriv(ePri[:,0]) * v,2), mkvc(problem.MeSigmaDeriv(ePri[:,1])*v,2) ))
-        if adjoint:
-            #
-            return MsigmaDeriv.T * v
-        else:
-            # v should be nC size
-            return MsigmaDeriv * v

SimPEG/MT/SurveyMT.py

@@ -1,562 +0,0 @@
-from SimPEG import Survey as SimPEGsurvey, Utils, Problem, Maps, np, sp, mkvc
-from SimPEG.EM.FDEM.SrcFDEM import BaseSrc as FDEMBaseSrc
-from SimPEG.EM.Utils import omega
-from scipy.constants import mu_0
-from numpy.lib import recfunctions as recFunc
-from Utils import rec2ndarr
-import SrcMT
-import sys
-
-#################
-### Receivers ###
-#################
-class Rx(SimPEGsurvey.BaseRx):
-    """
-        Class that defines natural source receivers.
-
-        See knownRxTypes for types of allowed receivers.
-
-        :param ndArray locs: Locations of the receivers
-        :param str rxType: The type of receiver
-
-    """
-
-    knownRxTypes = {
-                    # 3D impedance
-                    'zxxr':['Z3D', 'real'],
-                    'zxyr':['Z3D', 'real'],
-                    'zyxr':['Z3D', 'real'],
-                    'zyyr':['Z3D', 'real'],
-                    'zxxi':['Z3D', 'imag'],
-                    'zxyi':['Z3D', 'imag'],
-                    'zyxi':['Z3D', 'imag'],
-                    'zyyi':['Z3D', 'imag'],
-                    # 2D impedance
-                    # TODO:
-                    # 1D impedance
-                    'z1dr':['Z1D', 'real'],
-                    'z1di':['Z1D', 'imag'],
-                    # Tipper
-                    'tzxr':['T3D','real'],
-                    'tzxi':['T3D','imag'],
-                    'tzyr':['T3D','real'],
-                    'tzyi':['T3D','imag']
-                   }
-    # TODO: Have locs as single or double coordinates for both or numerator and denominator separately, respectively.
-    def __init__(self, locs, rxType):
-        SimPEGsurvey.BaseRx.__init__(self, locs, rxType)
-
-    @property
-    def projType(self):
-        """
-        Receiver type for projection.
-
-        """
-        return self.knownRxTypes[self.rxType][0]
-
-    @property
-    def projComp(self):
-        """Component projection (real/imag)"""
-        return self.knownRxTypes[self.rxType][1]
-
-    def eval(self, src, mesh, f):
-        '''
-        Project the fields to natural source data.
-
-            :param SrcMT src: The source of the fields to project
-            :param SimPEG.Mesh mesh:
-            :param FieldsMT f: Natural source fields object to project
-        '''
-
-        ## NOTE: Assumes that e is on t
-        if self.projType is 'Z1D':
-            Pex = mesh.getInterpolationMat(self.locs[:,-1],'Fx')
-            Pbx = mesh.getInterpolationMat(self.locs[:,-1],'Ex')
-            ex = Pex*mkvc(f[src,'e_1d'],2)
-            bx = Pbx*mkvc(f[src,'b_1d'],2)/mu_0
-            # Note: Has a minus sign in front, to comply with quadrant calculations.
-            # Can be derived from zyx case for the 3D case.
-            f_part_complex = -ex/bx
-        # elif self.projType is 'Z2D':
-        elif self.projType is 'Z3D':
-            ## NOTE: Assumes that e is on edges and b on the faces. Need to generalize that or use a prop of fields to determine that.
-            if self.locs.ndim == 3:
-                eFLocs = self.locs[:,:,0]
-                bFLocs = self.locs[:,:,1]
-            else:
-                eFLocs = self.locs
-                bFLocs = self.locs
-            # Get the projection
-            Pex = mesh.getInterpolationMat(eFLocs,'Ex')
-            Pey = mesh.getInterpolationMat(eFLocs,'Ey')
-            Pbx = mesh.getInterpolationMat(bFLocs,'Fx')
-            Pby = mesh.getInterpolationMat(bFLocs,'Fy')
-            # Get the fields at location
-            # px: x-polaration and py: y-polaration.
-            ex_px = Pex*f[src,'e_px']
-            ey_px = Pey*f[src,'e_px']
-            ex_py = Pex*f[src,'e_py']
-            ey_py = Pey*f[src,'e_py']
-            hx_px = Pbx*f[src,'b_px']/mu_0
-            hy_px = Pby*f[src,'b_px']/mu_0
-            hx_py = Pbx*f[src,'b_py']/mu_0
-            hy_py = Pby*f[src,'b_py']/mu_0
-            # Make the complex data
-            if 'zxx' in self.rxType:
-                f_part_complex = ( ex_px*hy_py - ex_py*hy_px)/(hx_px*hy_py - hx_py*hy_px)
-            elif 'zxy' in self.rxType:
-                f_part_complex = (-ex_px*hx_py + ex_py*hx_px)/(hx_px*hy_py - hx_py*hy_px)
-            elif 'zyx' in self.rxType:
-                f_part_complex = ( ey_px*hy_py - ey_py*hy_px)/(hx_px*hy_py - hx_py*hy_px)
-            elif 'zyy' in self.rxType:
-                f_part_complex = (-ey_px*hx_py + ey_py*hx_px)/(hx_px*hy_py - hx_py*hy_px)
-        elif self.projType is 'T3D':
-            if self.locs.ndim == 3:
-                horLoc = self.locs[:,:,0]
-                vertLoc = self.locs[:,:,1]
-            else:
-                horLoc = self.locs
-                vertLoc = self.locs
-            Pbx = mesh.getInterpolationMat(horLoc,'Fx')
-            Pby = mesh.getInterpolationMat(horLoc,'Fy')
-            Pbz = mesh.getInterpolationMat(vertLoc,'Fz')
-            bx_px = Pbx*f[src,'b_px']
-            by_px = Pby*f[src,'b_px']
-            bz_px = Pbz*f[src,'b_px']
-            bx_py = Pbx*f[src,'b_py']
-            by_py = Pby*f[src,'b_py']
-            bz_py = Pbz*f[src,'b_py']
-            if 'tzx' in self.rxType:
-                f_part_complex = (- by_px*bz_py + by_py*bz_px)/(bx_px*by_py - bx_py*by_px)
-            if 'tzy' in self.rxType:
-                f_part_complex = (  bx_px*bz_py - bx_py*bz_px)/(bx_px*by_py - bx_py*by_px)
-
-        else:
-            NotImplementedError('Projection of {:s} receiver type is not implemented.'.format(self.rxType))
-        # Get the real or imag component
-        real_or_imag = self.projComp
-        f_part = getattr(f_part_complex, real_or_imag)
-        # print f_part
-        return f_part
-
-    def evalDeriv(self, src, mesh, f, v, adjoint=False):
-        """
-        The derivative of the projection wrt u
-
-        :param MTsrc src: MT source
-        :param TensorMesh mesh: Mesh defining the topology of the problem
-        :param MTfields f: MT fields object of the source
-        :param numpy.ndarray v: Random vector of size
-        """
-
-        real_or_imag = self.projComp
-
-        if not adjoint:
-            if self.projType is 'Z1D':
-                Pex = mesh.getInterpolationMat(self.locs[:,-1],'Fx')
-                Pbx = mesh.getInterpolationMat(self.locs[:,-1],'Ex')
-                # ex = Pex*mkvc(f[src,'e_1d'],2)
-                # bx = Pbx*mkvc(f[src,'b_1d'],2)/mu_0
-                dP_de = -mkvc(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))*(Pex*v),2)
-                dP_db = mkvc( Utils.sdiag(Pex*mkvc(f[src,'e_1d'],2))*(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)).T*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)))*(Pbx*f._bDeriv_u(src,v)/mu_0),2)
-                PDeriv_complex = np.sum(np.hstack((dP_de,dP_db)),1)
-            elif self.projType is 'Z2D':
-                raise NotImplementedError('Has not been implement for 2D impedance tensor')
-            elif self.projType is 'Z3D':
-                if self.locs.ndim == 3:
-                    eFLocs = self.locs[:,:,0]
-                    bFLocs = self.locs[:,:,1]
-                else:
-                    eFLocs = self.locs
-                    bFLocs = self.locs
-                # Get the projection
-                Pex = mesh.getInterpolationMat(eFLocs,'Ex')
-                Pey = mesh.getInterpolationMat(eFLocs,'Ey')
-                Pbx = mesh.getInterpolationMat(bFLocs,'Fx')
-                Pby = mesh.getInterpolationMat(bFLocs,'Fy')
-                # Get the fields at location
-                # px: x-polaration and py: y-polaration.
-                ex_px = Pex*f[src,'e_px']
-                ey_px = Pey*f[src,'e_px']
-                ex_py = Pex*f[src,'e_py']
-                ey_py = Pey*f[src,'e_py']
-                hx_px = Pbx*f[src,'b_px']/mu_0
-                hy_px = Pby*f[src,'b_px']/mu_0
-                hx_py = Pbx*f[src,'b_py']/mu_0
-                hy_py = Pby*f[src,'b_py']/mu_0
-                # Derivatives as lambda functions
-                # The size of the diratives should be nD,nU
-                ex_px_u = lambda vec: Pex*f._e_pxDeriv_u(src,vec)
-                ey_px_u = lambda vec: Pey*f._e_pxDeriv_u(src,vec)
-                ex_py_u = lambda vec: Pex*f._e_pyDeriv_u(src,vec)
-                ey_py_u = lambda vec: Pey*f._e_pyDeriv_u(src,vec)
-                # NOTE: Think b_p?Deriv_u should return a 2*nF size matrix
-                hx_px_u = lambda vec: Pbx*f._b_pxDeriv_u(src,vec)/mu_0
-                hy_px_u = lambda vec: Pby*f._b_pxDeriv_u(src,vec)/mu_0
-                hx_py_u = lambda vec: Pbx*f._b_pyDeriv_u(src,vec)/mu_0
-                hy_py_u = lambda vec: Pby*f._b_pyDeriv_u(src,vec)/mu_0
-                # Update the input vector
-                sDiag = lambda t: Utils.sdiag(mkvc(t,2))
-                # Define the components of the derivative
-                Hd = sDiag(1./(sDiag(hx_px)*hy_py - sDiag(hx_py)*hy_px))
-                Hd_uV = sDiag(hy_py)*hx_px_u(v) + sDiag(hx_px)*hy_py_u(v) - sDiag(hx_py)*hy_px_u(v) - sDiag(hy_px)*hx_py_u(v)
-                # Calculate components
-                if 'zxx' in self.rxType:
-                    Zij = sDiag(Hd*( sDiag(ex_px)*hy_py - sDiag(ex_py)*hy_px ))
-                    ZijN_uV =  sDiag(hy_py)*ex_px_u(v) + sDiag(ex_px)*hy_py_u(v) - sDiag(ex_py)*hy_px_u(v) - sDiag(hy_px)*ex_py_u(v)
-                elif 'zxy' in self.rxType:
-                    Zij = sDiag(Hd*(-sDiag(ex_px)*hx_py + sDiag(ex_py)*hx_px ))
-                    ZijN_uV = -sDiag(hx_py)*ex_px_u(v) - sDiag(ex_px)*hx_py_u(v) + sDiag(ex_py)*hx_px_u(v) + sDiag(hx_px)*ex_py_u(v)
-                elif 'zyx' in self.rxType:
-                    Zij = sDiag(Hd*( sDiag(ey_px)*hy_py - sDiag(ey_py)*hy_px ))
-                    ZijN_uV =  sDiag(hy_py)*ey_px_u(v) + sDiag(ey_px)*hy_py_u(v) - sDiag(ey_py)*hy_px_u(v) - sDiag(hy_px)*ey_py_u(v)
-                elif 'zyy' in self.rxType:
-                    Zij = sDiag(Hd*(-sDiag(ey_px)*hx_py + sDiag(ey_py)*hx_px ))
-                    ZijN_uV = -sDiag(hx_py)*ey_px_u(v) - sDiag(ey_px)*hx_py_u(v) + sDiag(ey_py)*hx_px_u(v) + sDiag(hx_px)*ey_py_u(v)
-
-                # Calculate the complex derivative
-                PDeriv_complex = Hd * (ZijN_uV - Zij * Hd_uV )
-            elif self.projType is 'T3D':
-                if self.locs.ndim == 3:
-                    eFLocs = self.locs[:,:,0]
-                    bFLocs = self.locs[:,:,1]
-                else:
-                    eFLocs = self.locs
-                    bFLocs = self.locs
-                # Get the projection
-                Pbx = mesh.getInterpolationMat(bFLocs,'Fx')
-                Pby = mesh.getInterpolationMat(bFLocs,'Fy')
-                Pbz = mesh.getInterpolationMat(bFLocs,'Fz')
-
-                # Get the fields at location
-                # px: x-polaration and py: y-polaration.
-                bx_px = Pbx*f[src,'b_px']
-                by_px = Pby*f[src,'b_px']
-                bz_px = Pbz*f[src,'b_px']
-                bx_py = Pbx*f[src,'b_py']
-                by_py = Pby*f[src,'b_py']
-                bz_py = Pbz*f[src,'b_py']
-                # Derivatives as lambda functions
-                # NOTE: Think b_p?Deriv_u should return a 2*nF size matrix
-                bx_px_u = lambda vec: Pbx*f._b_pxDeriv_u(src,vec)
-                by_px_u = lambda vec: Pby*f._b_pxDeriv_u(src,vec)
-                bz_px_u = lambda vec: Pbz*f._b_pxDeriv_u(src,vec)
-                bx_py_u = lambda vec: Pbx*f._b_pyDeriv_u(src,vec)
-                by_py_u = lambda vec: Pby*f._b_pyDeriv_u(src,vec)
-                bz_py_u = lambda vec: Pbz*f._b_pyDeriv_u(src,vec)
-                # Update the input vector
-                sDiag = lambda t: Utils.sdiag(mkvc(t,2))
-                # Define the components of the derivative
-                Hd = sDiag(1./(sDiag(bx_px)*by_py - sDiag(bx_py)*by_px))
-                Hd_uV = sDiag(by_py)*bx_px_u(v) + sDiag(bx_px)*by_py_u(v) - sDiag(bx_py)*by_px_u(v) - sDiag(by_px)*bx_py_u(v)
-                if 'tzx' in self.rxType:
-                    Tij = sDiag(Hd*( - sDiag(by_px)*bz_py + sDiag(by_py)*bz_px ))
-                    TijN_uV = -sDiag(by_px)*bz_py_u(v) - sDiag(bz_py)*by_px_u(v) + sDiag(by_py)*bz_px_u(v) + sDiag(bz_px)*by_py_u(v)
-                elif 'tzy' in self.rxType:
-                    Tij = sDiag(Hd*( sDiag(bx_px)*bz_py - sDiag(bx_py)*bz_px ))
-                    TijN_uV =  sDiag(bz_py)*bx_px_u(v) + sDiag(bx_px)*bz_py_u(v) - sDiag(bx_py)*bz_px_u(v) - sDiag(bz_px)*bx_py_u(v)
-                # Calculate the complex derivative
-                PDeriv_complex = Hd * (TijN_uV - Tij * Hd_uV )
-
-            # Extract the real number for the real/imag components.
-            Pv = np.array(getattr(PDeriv_complex, real_or_imag))
-        elif adjoint:
-            # Note: The v vector is real and the return should be complex
-            if self.projType is 'Z1D':
-                Pex = mesh.getInterpolationMat(self.locs[:,-1],'Fx')
-                Pbx = mesh.getInterpolationMat(self.locs[:,-1],'Ex')
-                # ex = Pex*mkvc(f[src,'e_1d'],2)
-                # bx = Pbx*mkvc(f[src,'b_1d'],2)/mu_0
-                dP_deTv = -mkvc(Pex.T*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)).T*v,2)
-                db_duv = Pbx.T/mu_0*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))*(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))).T*Utils.sdiag(Pex*mkvc(f[src,'e_1d'],2)).T*v
-                dP_dbTv = mkvc(f._bDeriv_u(src,db_duv,adjoint=True),2)
-                PDeriv_real = np.sum(np.hstack((dP_deTv,dP_dbTv)),1)
-            elif self.projType is 'Z2D':
-                raise NotImplementedError('Has not be implement for 2D impedance tensor')
-            elif self.projType is 'Z3D':
-                if self.locs.ndim == 3:
-                    eFLocs = self.locs[:,:,0]
-                    bFLocs = self.locs[:,:,1]
-                else:
-                    eFLocs = self.locs
-                    bFLocs = self.locs
-                # Get the projection
-                Pex = mesh.getInterpolationMat(eFLocs,'Ex')
-                Pey = mesh.getInterpolationMat(eFLocs,'Ey')
-                Pbx = mesh.getInterpolationMat(bFLocs,'Fx')
-                Pby = mesh.getInterpolationMat(bFLocs,'Fy')
-                # Get the fields at location
-                # px: x-polaration and py: y-polaration.
-                aex_px = mkvc(mkvc(f[src,'e_px'],2).T*Pex.T)
-                aey_px = mkvc(mkvc(f[src,'e_px'],2).T*Pey.T)
-                aex_py = mkvc(mkvc(f[src,'e_py'],2).T*Pex.T)
-                aey_py = mkvc(mkvc(f[src,'e_py'],2).T*Pey.T)
-                ahx_px = mkvc(mkvc(f[src,'b_px'],2).T/mu_0*Pbx.T)
-                ahy_px = mkvc(mkvc(f[src,'b_px'],2).T/mu_0*Pby.T)
-                ahx_py = mkvc(mkvc(f[src,'b_py'],2).T/mu_0*Pbx.T)
-                ahy_py = mkvc(mkvc(f[src,'b_py'],2).T/mu_0*Pby.T)
-                # Derivatives as lambda functions
-                aex_px_u = lambda vec: f._e_pxDeriv_u(src,Pex.T*vec,adjoint=True)
-                aey_px_u = lambda vec: f._e_pxDeriv_u(src,Pey.T*vec,adjoint=True)
-                aex_py_u = lambda vec: f._e_pyDeriv_u(src,Pex.T*vec,adjoint=True)
-                aey_py_u = lambda vec: f._e_pyDeriv_u(src,Pey.T*vec,adjoint=True)
-                ahx_px_u = lambda vec: f._b_pxDeriv_u(src,Pbx.T*vec,adjoint=True)/mu_0
-                ahy_px_u = lambda vec: f._b_pxDeriv_u(src,Pby.T*vec,adjoint=True)/mu_0
-                ahx_py_u = lambda vec: f._b_pyDeriv_u(src,Pbx.T*vec,adjoint=True)/mu_0
-                ahy_py_u = lambda vec: f._b_pyDeriv_u(src,Pby.T*vec,adjoint=True)/mu_0
-
-                # Update the input vector
-                # Define shortcuts
-                sDiag = lambda t: Utils.sdiag(mkvc(t,2))
-                sVec = lambda t: Utils.sp.csr_matrix(mkvc(t,2))
-                # Define the components of the derivative
-                aHd = sDiag(1./(sDiag(ahx_px)*ahy_py - sDiag(ahx_py)*ahy_px))
-                aHd_uV = lambda x: ahx_px_u(sDiag(ahy_py)*x) + ahx_px_u(sDiag(ahy_py)*x) - ahy_px_u(sDiag(ahx_py)*x) - ahx_py_u(sDiag(ahy_px)*x)
-                # Need to fix this to reflect the adjoint
-                if 'zxx' in self.rxType:
-                    Zij = sDiag(aHd*( sDiag(ahy_py)*aex_px - sDiag(ahy_px)*aex_py))
-                    ZijN_uV = lambda x: aex_px_u(sDiag(ahy_py)*x) + ahy_py_u(sDiag(aex_px)*x) - ahy_px_u(sDiag(aex_py)*x) - aex_py_u(sDiag(ahy_px)*x)
-                elif 'zxy' in self.rxType:
-                    Zij = sDiag(aHd*(-sDiag(ahx_py)*aex_px + sDiag(ahx_px)*aex_py))
-                    ZijN_uV = lambda x:-aex_px_u(sDiag(ahx_py)*x) - ahx_py_u(sDiag(aex_px)*x) + ahx_px_u(sDiag(aex_py)*x) + aex_py_u(sDiag(ahx_px)*x)
-                elif 'zyx' in self.rxType:
-                    Zij = sDiag(aHd*( sDiag(ahy_py)*aey_px - sDiag(ahy_px)*aey_py))
-                    ZijN_uV = lambda x: aey_px_u(sDiag(ahy_py)*x) + ahy_py_u(sDiag(aey_px)*x) - ahy_px_u(sDiag(aey_py)*x) - aey_py_u(sDiag(ahy_px)*x)
-                elif 'zyy' in self.rxType:
-                    Zij = sDiag(aHd*(-sDiag(ahx_py)*aey_px + sDiag(ahx_px)*aey_py))
-                    ZijN_uV = lambda x:-aey_px_u(sDiag(ahx_py)*x) - ahx_py_u(sDiag(aey_px)*x) + ahx_px_u(sDiag(aey_py)*x) + aey_py_u(sDiag(ahx_px)*x)
-
-                # Calculate the complex derivative
-                PDeriv_real = ZijN_uV(aHd*v) - aHd_uV(Zij.T*aHd*v)#
-                # NOTE: Need to reshape the output to go from 2*nU array to a (nU,2) matrix for each polarization
-                # PDeriv_real = np.hstack((mkvc(PDeriv_real[:len(PDeriv_real)/2],2),mkvc(PDeriv_real[len(PDeriv_real)/2::],2)))
-                PDeriv_real = PDeriv_real.reshape((2,mesh.nE)).T
-
-            elif self.projType is 'T3D':
-                if self.locs.ndim == 3:
-                    bFLocs = self.locs[:,:,1]
-                else:
-                    bFLocs = self.locs
-                # Get the projection
-                Pbx = mesh.getInterpolationMat(bFLocs,'Fx')
-                Pby = mesh.getInterpolationMat(bFLocs,'Fy')
-                Pbz = mesh.getInterpolationMat(bFLocs,'Fz')
-                # Get the fields at location
-                # px: x-polaration and py: y-polaration.
-                abx_px = mkvc(mkvc(f[src,'b_px'],2).T*Pbx.T)
-                aby_px = mkvc(mkvc(f[src,'b_px'],2).T*Pby.T)
-                abz_px = mkvc(mkvc(f[src,'b_px'],2).T*Pbz.T)
-                abx_py = mkvc(mkvc(f[src,'b_py'],2).T*Pbx.T)
-                aby_py = mkvc(mkvc(f[src,'b_py'],2).T*Pby.T)
-                abz_py = mkvc(mkvc(f[src,'b_py'],2).T*Pbz.T)
-                # Derivatives as lambda functions
-                abx_px_u = lambda vec: f._b_pxDeriv_u(src,Pbx.T*vec,adjoint=True)
-                aby_px_u = lambda vec: f._b_pxDeriv_u(src,Pby.T*vec,adjoint=True)
-                abz_px_u = lambda vec: f._b_pxDeriv_u(src,Pbz.T*vec,adjoint=True)
-                abx_py_u = lambda vec: f._b_pyDeriv_u(src,Pbx.T*vec,adjoint=True)
-                aby_py_u = lambda vec: f._b_pyDeriv_u(src,Pby.T*vec,adjoint=True)
-                abz_py_u = lambda vec: f._b_pyDeriv_u(src,Pbz.T*vec,adjoint=True)
-
-                # Update the input vector
-                # Define shortcuts
-                sDiag = lambda t: Utils.sdiag(mkvc(t,2))
-                sVec = lambda t: Utils.sp.csr_matrix(mkvc(t,2))
-                # Define the components of the derivative
-                aHd = sDiag(1./(sDiag(abx_px)*aby_py - sDiag(abx_py)*aby_px))
-                aHd_uV = lambda x: abx_px_u(sDiag(aby_py)*x) + abx_px_u(sDiag(aby_py)*x) - aby_px_u(sDiag(abx_py)*x) - abx_py_u(sDiag(aby_px)*x)
-                # Need to fix this to reflect the adjoint
-                if 'tzx' in self.rxType:
-                    Tij = sDiag(aHd*( -sDiag(abz_py)*aby_px + sDiag(abz_px)*aby_py))
-                    TijN_uV = lambda x: -abz_py_u(sDiag(aby_px)*x) - aby_px_u(sDiag(abz_py)*x) + aby_py_u(sDiag(abz_px)*x) + abz_px_u(sDiag(aby_py)*x)
-                elif 'tzy' in self.rxType:
-                    Tij = sDiag(aHd*( sDiag(abz_py)*abx_px - sDiag(abz_px)*abx_py))
-                    TijN_uV = lambda x: abx_px_u(sDiag(abz_py)*x) + abz_py_u(sDiag(abx_px)*x) - abx_py_u(sDiag(abz_px)*x) - abz_px_u(sDiag(abx_py)*x)
-                # Calculate the complex derivative
-                PDeriv_real = TijN_uV(aHd*v) - aHd_uV(Tij.T*aHd*v)#
-                # NOTE: Need to reshape the output to go from 2*nU array to a (nU,2) matrix for each polarization
-                # PDeriv_real = np.hstack((mkvc(PDeriv_real[:len(PDeriv_real)/2],2),mkvc(PDeriv_real[len(PDeriv_real)/2::],2)))
-                PDeriv_real = PDeriv_real.reshape((2,mesh.nE)).T
-            # Extract the data
-            if real_or_imag == 'imag':
-                Pv = 1j*PDeriv_real
-            elif real_or_imag == 'real':
-                Pv = PDeriv_real.astype(complex)
-
-
-        return Pv
-
-#################
-###  Survey   ###
-#################
-class Survey(SimPEGsurvey.BaseSurvey):
-    """
-        Survey class for MT. Contains all the sources associated with the survey.
-
-        :param list srcList: List of sources associated with the survey
-
-    """
-    srcPair = SrcMT.BaseMTSrc
-
-    def __init__(self, srcList, **kwargs):
-        # Sort these by frequency
-        self.srcList = srcList
-        SimPEGsurvey.BaseSurvey.__init__(self, **kwargs)
-
-        _freqDict = {}
-        for src in srcList:
-            if src.freq not in _freqDict:
-                _freqDict[src.freq] = []
-            _freqDict[src.freq] += [src]
-
-        self._freqDict = _freqDict
-        self._freqs = sorted([f for f in self._freqDict])
-
-    @property
-    def freqs(self):
-        """Frequencies"""
-        return self._freqs
-
-    @property
-    def nFreq(self):
-        """Number of frequencies"""
-        return len(self._freqDict)
-
-    # TODO: Rename to getSources
-    def getSrcByFreq(self, freq):
-        """Returns the sources associated with a specific frequency."""
-        assert freq in self._freqDict, "The requested frequency is not in this survey."
-        return self._freqDict[freq]
-
-    def eval(self, f):
-        data = Data(self)
-        for src in self.srcList:
-            sys.stdout.flush()
-            for rx in src.rxList:
-                data[src, rx] = rx.eval(src, self.mesh, f)
-        return data
-
-    def evalDeriv(self, f):
-        raise Exception('Use Transmitters to project fields deriv.')
-
-#################
-###   Data    ###
-#################
-class Data(SimPEGsurvey.Data):
-    '''
-    Data class for MTdata. Stores the data vector indexed by the survey.
-
-    :param SimPEG survey object survey:
-    :param v vector of the data in order matching of the survey
-
-
-    '''
-    def __init__(self, survey, v=None):
-        # Pass the variables to the "parent" method
-        SimPEGsurvey.Data.__init__(self, survey, v)
-
-    # # Import data
-    # @classmethod
-    # def fromEDIFiles():
-    #     pass
-
-    def toRecArray(self,returnType='RealImag'):
-        '''
-        Function that returns a numpy.recarray for a SimpegMT impedance data object.
-
-        :param str returnType: Switches between returning a rec array where the impedance is split to real and imaginary ('RealImag') or is a complex ('Complex')
-
-        '''
-
-        # Define the record fields
-        dtRI = [('freq',float),('x',float),('y',float),('z',float),('zxxr',float),('zxxi',float),('zxyr',float),('zxyi',float),
-        ('zyxr',float),('zyxi',float),('zyyr',float),('zyyi',float),('tzxr',float),('tzxi',float),('tzyr',float),('tzyi',float)]
-        dtCP = [('freq',float),('x',float),('y',float),('z',float),('zxx',complex),('zxy',complex),('zyx',complex),('zyy',complex),('tzx',complex),('tzy',complex)]
-        impList = ['zxxr','zxxi','zxyr','zxyi','zyxr','zyxi','zyyr','zyyi']
-        for src in self.survey.srcList:
-            # Temp array for all the receivers of the source.
-            # Note: needs to be written more generally, using diffterent rxTypes and not all the data at the locaitons
-            # Assume the same locs for all RX
-            locs = src.rxList[0].locs
-            if locs.shape[1] == 1:
-                locs = np.hstack((np.array([[0.0,0.0]]),locs))
-            elif locs.shape[1] == 2:
-                locs = np.hstack((np.array([[0.0]]),locs))
-            tArrRec = np.concatenate((src.freq*np.ones((locs.shape[0],1)),locs,np.nan*np.ones((locs.shape[0],12))),axis=1).view(dtRI)
-            # np.array([(src.freq,rx.locs[0,0],rx.locs[0,1],rx.locs[0,2],np.nan ,np.nan ,np.nan ,np.nan ,np.nan ,np.nan ,np.nan ,np.nan ) for rx in src.rxList],dtype=dtRI)
-            # Get the type and the value for the DataMT object as a list
-            typeList = [[rx.rxType.replace('z1d','zyx'),self[src,rx]] for rx in src.rxList]
-            # Insert the values to the temp array
-            for nr,(key,val) in enumerate(typeList):
-                tArrRec[key] = mkvc(val,2)
-            # Masked array
-            mArrRec = np.ma.MaskedArray(rec2ndarr(tArrRec),mask=np.isnan(rec2ndarr(tArrRec))).view(dtype=tArrRec.dtype)
-            # Unique freq and loc of the masked array
-            uniFLmarr = np.unique(mArrRec[['freq','x','y','z']]).copy()
-
-            try:
-                outTemp = recFunc.stack_arrays((outTemp,mArrRec))
-                #outTemp = np.concatenate((outTemp,dataBlock),axis=0)
-            except NameError as e:
-                outTemp = mArrRec
-
-            if 'RealImag' in returnType:
-                outArr = outTemp
-            elif 'Complex' in returnType:
-                # Add the real and imaginary to a complex number
-                outArr = np.empty(outTemp.shape,dtype=dtCP)
-                for comp in ['freq','x','y','z']:
-                    outArr[comp] = outTemp[comp].copy()
-                for comp in ['zxx','zxy','zyx','zyy','tzx','tzy']:
-                    outArr[comp] = outTemp[comp+'r'].copy() + 1j*outTemp[comp+'i'].copy()
-            else:
-                raise NotImplementedError('{:s} is not implemented, as to be RealImag or Complex.')
-
-        # Return
-        return outArr
-
-    @classmethod
-    def fromRecArray(cls, recArray, srcType='primary'):
-        """
-        Class method that reads in a numpy record array to MTdata object.
-
-        Only imports the impedance data.
-
-        """
-        if srcType=='primary':
-            src = SrcMT.polxy_1Dprimary
-        elif srcType=='total':
-            src = SrcMT.polxy_1DhomotD
-        else:
-            raise NotImplementedError('{:s} is not a valid source type for MTdata')
-
-        # Find all the frequencies in recArray
-        uniFreq = np.unique(recArray['freq'])
-        srcList = []
-        dataList = []
-        for freq in uniFreq:
-            # Initiate rxList
-            rxList = []
-            # Find that data for freq
-            dFreq = recArray[recArray['freq'] == freq].copy()
-            # Find the impedance rxTypes in the recArray.
-            rxTypes = [ comp for comp in recArray.dtype.names if (len(comp)==4 or len(comp)==3) and 'z' in comp]
-            for rxType in rxTypes:
-                # Find index of not nan values in rxType
-                notNaNind = ~np.isnan(dFreq[rxType])
-                if np.any(notNaNind): # Make sure that there is any data to add.
-                    locs = rec2ndarr(dFreq[['x','y','z']][notNaNind].copy())
-                    if dFreq[rxType].dtype.name in 'complex128':
-                        rxList.append(Rx(locs,rxType+'r'))
-                        dataList.append(dFreq[rxType][notNaNind].real.copy())
-                        rxList.append(Rx(locs,rxType+'i'))
-                        dataList.append(dFreq[rxType][notNaNind].imag.copy())
-                    else:
-                        rxList.append(Rx(locs,rxType))
-                        dataList.append(dFreq[rxType][notNaNind].copy())
-            srcList.append(src(rxList,freq))
-
-        # Make a survey
-        survey = Survey(srcList)
-        dataVec = np.hstack(dataList)
-        return cls(survey,dataVec)
-

SimPEG/MT/Utils/MT1Danalytic.py

@@ -1,108 +0,0 @@
-# Analytic solution of EM fields due to a plane wave
-
-import numpy as np, SimPEG as simpeg
-from scipy.constants import mu_0, epsilon_0 as eps_0
-
-def getEHfields(m1d,sigma,freq,zd,scaleUD=True):
-    '''Analytic solution for MT 1D layered earth. Returns E and H fields.
-
-    :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information.
-    :param numpy.array, vector sigma: Physical property of conductivity corresponding with the mesh.
-    :param float, freq: Frequency to calculate data at.
-    :param numpy array, vector zd: location to calculate EH fields at
-    :param bollean, scaleUD: scales the output to be 1 at the top, increases numeracal stability.
-
-    Assumes a halfspace with the same conductive as the last cell below.
-
-    '''
-    # Note add an error check for the mesh and sigma are the same size.
-
-    # Constants: Assume constant
-    mu = mu_0*np.ones((m1d.nC+1))
-    eps = eps_0*np.ones((m1d.nC+1))
-    # Angular freq
-    w = 2*np.pi*freq
-    # Add the halfspace value to the property
-    sig = np.concatenate((np.array([sigma[0]]),sigma))
-    # Calculate the wave number
-    k = np.sqrt(eps*mu*w**2-1j*mu*sig*w)
-
-    # Initiate the propagation matrix, in the order down up.
-    UDp = np.zeros((2,m1d.nC+1),dtype=complex)
-    UDp[1,0] = 1. # Set the wave amplitude as 1 into the half-space at the bottom of the mesh
-    # Loop over all the layers, starting at the bottom layer
-    for lnr, h in enumerate(m1d.hx): # lnr-number of layer, h-thickness of the layer
-        # Calculate
-        yp1 = k[lnr]/(w*mu[lnr]) # Admittance of the layer below the current layer
-        zp = (w*mu[lnr+1])/k[lnr+1] # Impedance in the current layer
-        # Build the propagation matrix
-
-        # Convert fields to down/up going components in layer below current layer
-        Pj1 = np.array([[1,1],[yp1,-yp1]])
-        # Convert fields to down/up going components in current layer
-        Pjinv = 1./2*np.array([[1,zp],[1,-zp]])
-        # Propagate down and up components through the current layer
-        elamh = np.array([[np.exp(-1j*k[lnr+1]*h),0],[0,np.exp(1j*k[lnr+1]*h)]])
-
-        # The down and up component in current layer.
-        UDp[:,lnr+1] = elamh.dot(Pjinv.dot(Pj1)).dot(UDp[:,lnr])
-
-        if scaleUD:
-             UDp[:,lnr+1::-1] = UDp[:,lnr+1::-1]/UDp[1,lnr+1]
-
-    # Calculate the fields
-    Ed = np.empty((zd.size,),dtype=complex)
-    Eu = np.empty((zd.size,),dtype=complex)
-    Hd = np.empty((zd.size,),dtype=complex)
-    Hu = np.empty((zd.size,),dtype=complex)
-
-    # Loop over the layers and calculate the fields
-    # In the halfspace below the mesh
-    dup = m1d.vectorNx[0]
-    dind = dup >= zd
-    Ed[dind] = UDp[1,0]*np.exp(-1j*k[0]*(dup-zd[dind]))
-    Eu[dind] = UDp[0,0]*np.exp(1j*k[0]*(dup-zd[dind]))
-    Hd[dind] = (k[0]/(w*mu[0]))*UDp[1,0]*np.exp(-1j*k[0]*(dup-zd[dind]))
-    Hu[dind] = -(k[0]/(w*mu[0]))*UDp[0,0]*np.exp(1j*k[0]*(dup-zd[dind]))
-    for ki,mui,epsi,dlow,dup,Up,Dp in zip(k[1::],mu[1::],eps[1::],m1d.vectorNx[:-1],m1d.vectorNx[1::],UDp[0,1::],UDp[1,1::]):
-        dind = np.logical_and(dup >= zd, zd > dlow)
-        Ed[dind] = Dp*np.exp(-1j*ki*(dup-zd[dind]))
-        Eu[dind] = Up*np.exp(1j*ki*(dup-zd[dind]))
-        Hd[dind] = (ki/(w*mui))*Dp*np.exp(-1j*ki*(dup-zd[dind]))
-        Hu[dind] = -(ki/(w*mui))*Up*np.exp(1j*ki*(dup-zd[dind]))
-
-    # Return return the fields
-    return Ed, Eu, Hd, Hu
-
-def getImpedance(m1d,sigma,freq):
-    """Analytic solution for MT 1D layered earth. Returns the impedance at the surface.
-
-    :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information.
-    :param numpy.array, vector sigma: Physical property corresponding with the mesh.
-    :param numpy.array, vector freq: Frequencies to calculate data at.
-
-
-    """
-
-    # Initiate the impedances
-    Z1d = np.empty(len(freq) , dtype='complex')
-    h = m1d.hx   #vectorNx[:-1]
-    # Start the process
-    for nrFr, fr in enumerate(freq):
-        om = 2*np.pi*fr
-        Zall = np.empty(len(h)+1,dtype='complex')
-        # Calculate the impedance for the bottom layer
-        Zall[0] = (mu_0*om)/np.sqrt(mu_0*eps_0*(om)**2 - 1j*mu_0*sigma[0]*om)
-
-        for nr,hi in enumerate(h):
-            # Calculate the wave number
-            # print nr,sigma[nr]
-            k = np.sqrt(mu_0*eps_0*om**2 - 1j*mu_0*sigma[nr]*om)
-            Z = (mu_0*om)/k
-
-            Zall[nr+1] = Z *((Zall[nr] + Z*np.tanh(1j*k*hi))/(Z + Zall[nr]*np.tanh(1j*k*hi)))
-
-        #pdb.set_trace()
-        Z1d[nrFr] = Zall[-1]
-
-    return Z1d

SimPEG/MT/Utils/MT1Dsolutions.py

@@ -1,45 +0,0 @@
-import numpy as np, SimPEG as simpeg
-from MT1Danalytic import getEHfields
-from scipy.constants import mu_0
-
-def get1DEfields(m1d,sigma,freq,sourceAmp=1.0):
-    """Function to get 1D electrical fields"""
-
-    # Get the gradient
-    G = m1d.nodalGrad
-    # Mass matrices
-    # Magnetic permeability
-    Mmu = simpeg.Utils.sdiag(m1d.vol*(1.0/mu_0))
-    # Conductivity
-    Msig = m1d.getFaceInnerProduct(sigma)
-    # Set up the solution matrix
-    A = G.T*Mmu*G + 1j*2.*np.pi*freq*Msig
-    # Define the inner part of the solution matrix
-    Aii = A[1:-1,1:-1]
-    # Define the outer part of the solution matrix
-    Aio = A[1:-1,[0,-1]]
-
-    # Set the boundary conditions
-    Ed, Eu, Hd, Hu = getEHfields(m1d,sigma,freq,m1d.vectorNx)
-    Etot = (Ed + Eu)
-    if sourceAmp is not None:
-        Etot = ((Etot/Etot[-1])*sourceAmp) # Scale the fields to be equal to sourceAmp at the top
-    ## Note: The analytic solution is derived with e^iwt
-    bc = np.r_[Etot[0],Etot[-1]]
-    # The right hand side
-    rhs = Aio*bc
-    # Solve the system
-    Aii_inv = simpeg.Solver(Aii)
-    eii = Aii_inv*rhs
-    # Assign the boundary conditions
-    e = np.r_[bc[0],eii,bc[1]]
-    # Return the electrical fields
-    return e
-
-
-if __name__ == '__main__':
-
-    hz = [(100.,18)]
-    M = simpeg.Mesh.TensorMesh([hz],'C')
-    sig = np.zeros(M.nC) + 1e-8
-    sig[M.vectorCCx<=0] = sigHalf

SimPEG/MT/Utils/__init__.py

@@ -1,4 +0,0 @@
-from MT1Dsolutions import *  # Add the names of the functions
-from MT1Danalytic import *
-from dataUtils import *
-from ediFilesUtils import *

SimPEG/MT/Utils/dataUtils.py

@@ -1,245 +0,0 @@
-# Utils used for the data,
-import numpy as np, matplotlib.pyplot as plt, sys
-import SimPEG as simpeg
-import numpy.lib.recfunctions as recFunc
-from scipy.constants import mu_0
-from scipy import interpolate as sciint
-
-def getAppRes(MTdata):
-    # Make impedance
-    zList = []
-    for src in MTdata.survey.srcList:
-        zc = [src.freq]
-        for rx in src.rxList:
-            if 'i' in rx.rxType:
-                m=1j
-            else:
-                m = 1
-            zc.append(m*MTdata[src,rx])
-        zList.append(zc)
-    return [appResPhs(zList[i][0],np.sum(zList[i][1:3])) for i in np.arange(len(zList))]
-
-def rotateData(MTdata,rotAngle):
-    '''
-    Function that rotates clockwist by rotAngle (- negative for a counter-clockwise rotation)
-    '''
-    recData = MTdata.toRecArray('Complex')
-    impData = rec2ndarr(recData[['zxx','zxy','zyx','zyy']],complex)
-    # Make the rotation matrix
-    # c,s,zxx,zxy,zyx,zyy = sympy.symbols('c,s,zxx,zxy,zyx,zyy')
-    # rotM = sympy.Matrix([[c,-s],[s, c]])
-    # zM = sympy.Matrix([[zxx,zxy],[zyx,zyy]])
-    # rotM*zM*rotM.T
-    # [c*(c*zxx - s*zyx) - s*(c*zxy - s*zyy), c*(c*zxy - s*zyy) + s*(c*zxx - s*zyx)],
-    # [c*(c*zyx + s*zxx) - s*(c*zyy + s*zxy), c*(c*zyy + s*zxy) + s*(c*zyx + s*zxx)]])
-    s = np.sin(-np.deg2rad(rotAngle))
-    c = np.cos(-np.deg2rad(rotAngle))
-    rotMat = np.array([[c,-s],[s,c]])
-    rotData = (rotMat.dot(impData.reshape(-1,2,2).dot(rotMat.T))).transpose(1,0,2).reshape(-1,4)
-    outRec = recData.copy()
-    for nr,comp in enumerate(['zxx','zxy','zyx','zyy']):
-        outRec[comp] = rotData[:,nr]
-
-    from SimPEG import MT
-    return MT.Data.fromRecArray(outRec)
-
-
-def appResPhs(freq,z):
-    app_res = ((1./(8e-7*np.pi**2))/freq)*np.abs(z)**2
-    app_phs = np.arctan2(z.imag,z.real)*(180/np.pi)
-    return app_res, app_phs
-
-def skindepth(rho,freq):
-    ''' Function to calculate the skindepth of EM waves'''
-    return np.sqrt( (rho*((1/(freq * mu_0 * np.pi )))))
-
-def rec2ndarr(x,dt=float):
-    return x.view((dt, len(x.dtype.names)))
-
-def makeAnalyticSolution(mesh,model,elev,freqs):
-    from SimPEG import MT
-    data1D = []
-    for freq in freqs:
-        anaEd, anaEu, anaHd, anaHu = MT.Utils.MT1Danalytic.getEHfields(mesh,model,freq,elev)
-        anaE = anaEd+anaEu
-        anaH = anaHd+anaHu
-
-        anaZ = anaE/anaH
-        # Add to the list
-        data1D.append((freq,0,0,elev,anaZ[0]))
-    dataRec = np.array(data1D,dtype=[('freq',float),('x',float),('y',float),('z',float),('zyx',complex)])
-    return dataRec
-
-def plotMT1DModelData(problem,models,symList=None):
-    from SimPEG import MT
-    # Setup the figure
-    fontSize = 15
-
-    fig = plt.figure(figsize=[9,7])
-    axM = fig.add_axes([0.075,.1,.25,.875])
-    axM.set_xlabel('Resistivity [Ohm*m]',fontsize=fontSize)
-    axM.set_xlim(1e-1,1e5)
-    axM.set_ylim(-10000,5000)
-    axM.set_ylabel('Depth [km]',fontsize=fontSize)
-    axR = fig.add_axes([0.42,.575,.5,.4])
-    axR.set_xscale('log')
-    axR.set_yscale('log')
-    axR.invert_xaxis()
-    # axR.set_xlabel('Frequency [Hz]')
-    axR.set_ylabel('Apparent resistivity [Ohm m]',fontsize=fontSize)
-
-    axP = fig.add_axes([0.42,.1,.5,.4])
-    axP.set_xscale('log')
-    axP.invert_xaxis()
-    axP.set_ylim(0,90)
-    axP.set_xlabel('Frequency [Hz]',fontsize=fontSize)
-    axP.set_ylabel('Apparent phase [deg]',fontsize=fontSize)
-
-    # if not symList:
-    #   symList = ['x']*len(models)
-    import plotDataTypes as pDt
-    # Loop through the models.
-    modelList = [problem.survey.mtrue]
-    modelList.extend(models)
-    if False:
-        modelList = [problem.mapping.sigmaMap*mod for mod in modelList]
-    for nr, model in enumerate(modelList):
-        # Calculate the data
-        if nr==0:
-            data1D = problem.dataPair(problem.survey,problem.survey.dobs).toRecArray('Complex')
-        else:
-            data1D = problem.dataPair(problem.survey,problem.survey.dpred(model)).toRecArray('Complex')
-        # Plot the data and the model
-        colRat = nr/((len(modelList)-1.999)*1.)
-        if colRat > 1.:
-            col = 'k'
-        else:
-            col = plt.cm.seismic(1-colRat)
-        # The model - make the pts to plot
-        meshPts = np.concatenate((problem.mesh.gridN[0:1],np.kron(problem.mesh.gridN[1::],np.ones(2))[:-1]))
-        modelPts = np.kron(1./(problem.mapping.sigmaMap*model),np.ones(2,))
-        axM.semilogx(modelPts,meshPts,color=col)
-
-        ## Data
-        # Appres
-        pDt.plotIsoStaImpedance(axR,np.array([0,0]),data1D,'zyx','res',pColor=col)
-        # Appphs
-        pDt.plotIsoStaImpedance(axP,np.array([0,0]),data1D,'zyx','phs',pColor=col)
-        try:
-            allData = np.concatenate((allData,simpeg.mkvc(data1D['zyx'],2)),1)
-        except:
-            allData = simpeg.mkvc(data1D['zyx'],2)
-    freq = simpeg.mkvc(data1D['freq'],2)
-    res, phs = appResPhs(freq,allData)
-
-    stdCol = 'gray'
-    axRtw = axR.twinx()
-    axRtw.set_ylabel('Std of log10',color=stdCol)
-    [(t.set_color(stdCol), t.set_rotation(-45)) for t in axRtw.get_yticklabels()]
-    axPtw = axP.twinx()
-    axPtw.set_ylabel('Std ',color=stdCol)
-    [t.set_color(stdCol) for t in axPtw.get_yticklabels()]
-    axRtw.plot(freq, np.std(np.log10(res),1),'--',color=stdCol)
-    axPtw.plot(freq, np.std(phs,1),'--',color=stdCol)
-
-    # Fix labels and ticks
-
-    yMtick = [l/1000 for l in axM.get_yticks().tolist()]
-    axM.set_yticklabels(yMtick)
-    [ l.set_rotation(90) for l in axM.get_yticklabels()]
-    [ l.set_rotation(90) for l in axR.get_yticklabels()]
-    [(t.set_color(stdCol), t.set_rotation(-45)) for t in axRtw.get_yticklabels()]
-    [t.set_color(stdCol) for t in axPtw.get_yticklabels()]
-    for ax in [axM,axR,axP]:
-        ax.xaxis.set_tick_params(labelsize=fontSize)
-        ax.yaxis.set_tick_params(labelsize=fontSize)
-    return fig
-
-def printTime():
-    import time
-    print time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime())
-
-def convert3Dto1Dobject(MTdata,rxType3D='zyx'):
-    from SimPEG import MT
-    # Find the unique locations
-    # Need to find the locations
-    recDataTemp = MTdata.toRecArray()
-    # Check if survey.std has been assigned.
-    ## NEED TO: write this...
-    # Calculte and add the DET of the tensor to the recArray
-    if 'det' in rxType3D:
-        Zon = (recDataTemp['zxxr']+1j*recDataTemp['zxxi'])*(recDataTemp['zyyr']+1j*recDataTemp['zyyi'])
-        Zoff = (recDataTemp['zxyr']+1j*recDataTemp['zxyi'])*(recDataTemp['zyxr']+1j*recDataTemp['zyxi'])
-        det = np.sqrt(Zon.data - Zoff.data)
-        recData = recFunc.append_fields(recDataTemp,['zdetr','zdeti'],[det.real,det.imag] )
-    else:
-        recData = recDataTemp
-
-    uniLocs = rec2ndarr(np.unique(recData[['x','y','z']])).data
-    mtData1DList = []
-    if 'zxy' in rxType3D:
-        corr = -1 # Shift the data to comply with the quadtrature of the 1d problem
-    else:
-        corr = 1
-    for loc in uniLocs:
-        # Make the receiver list
-        rx1DList = []
-        for rxType in ['z1dr','z1di']:
-            rx1DList.append(MT.Rx(simpeg.mkvc(loc,2).T,rxType))
-        # Source list
-        locrecData = recData[np.sqrt(np.sum( (rec2ndarr(recData[['x','y','z']]).data - loc )**2,axis=1)) < 1e-5]
-        dat1DList = []
-        src1DList = []
-        for freq in locrecData['freq']:
-            src1DList.append(MT.SrcMT.src_polxy_1Dprimary(rx1DList,freq))
-            for comp  in ['r','i']:
-                dat1DList.append( corr * locrecData[rxType3D+comp][locrecData['freq']== freq].data )
-
-        # Make the survey
-        sur1D = MT.Survey(src1DList)
-
-        # Make the data
-        dataVec = np.hstack(dat1DList)
-        dat1D = MT.Data(sur1D,dataVec)
-        sur1D.dobs = dataVec
-        # Need to take MTdata.survey.std and split it as well.
-        std=0.05
-        sur1D.std =  np.abs(sur1D.dobs*std) #+ 0.01*np.linalg.norm(sur1D.dobs)
-        mtData1DList.append(dat1D)
-
-    # Return the the list of data.
-    return mtData1DList
-
-def resampleMTdataAtFreq(MTdata,freqs):
-    """
-    Function to resample MTdata at set of frequencies
-
-    """
-    from SimPEG import MT
-    # Make a rec array
-    MTrec = MTdata.toRecArray().data
-
-    # Find unique locations
-    uniLoc = np.unique(MTrec[['x','y','z']])
-    uniFreq = MTdata.survey.freqs
-    # Get the comps
-    dNames = MTrec.dtype
-
-    # Loop over all the locations and interpolate
-    for loc in uniLoc:
-        # Find the index of the station
-        ind = np.sqrt(np.sum((rec2ndarr(MTrec[['x','y','z']]) - rec2ndarr(loc))**2,axis=1)) < 1. # Find dist of 1 m accuracy
-        # Make a temporary recArray and interpolate all the components
-        tArrRec = np.concatenate((simpeg.mkvc(freqs,2),np.ones((len(freqs),1))*rec2ndarr(loc),np.nan*np.ones((len(freqs),12))),axis=1).view(dNames)
-        for comp in ['zxxr','zxxi','zxyr','zxyi','zyxr','zyxi','zyyr','zyyi','tzxr','tzxi','tzyr','tzyi']:
-            int1d = sciint.interp1d(MTrec[ind]['freq'],MTrec[ind][comp],bounds_error=False)
-            tArrRec[comp] = simpeg.mkvc(int1d(freqs),2)
-
-        # Join together
-        try:
-            outRecArr = recFunc.stack_arrays((outRecArr,tArrRec))
-        except NameError as e:
-            outRecArr = tArrRec
-
-    # Make the MTdata and return
-    return MT.Data.fromRecArray(outRecArr)

SimPEG/MT/Utils/ediFilesUtils.py

@@ -1,180 +0,0 @@
-# Functions to import and export MT EDI files.
-from SimPEG import mkvc
-from scipy.constants import mu_0
-from numpy.lib import recfunctions as recFunc
-from SimPEG.MT.Utils.dataUtils import rec2ndarr
-
-# Import modules
-import numpy as np
-import os, sys, re
-
-
-class EDIimporter:
-    """
-    A class to import EDIfiles.
-
-    """
-
-
-    # Define data converters
-    _impUnitEDI2SI = 4*np.pi*1e-4 # Convert Z[mV/km/nT] (as in EDI)to Z[V/A] SI unit
-    _impUnitSI2EDI = 1./_impUnitEDI2SI # ConvertZ[V/A] SI unit to Z[mV/km/nT] (as in EDI)
-
-    # Properties
-    filesList = None
-    comps = None
-
-    # Hidden properties
-    _outEPSG = None # Project info
-    _2out = None    # The projection operator
-
-
-    def __init__(self, EDIfilesList, compList=None, outEPSG=None):
-
-        # Set the fileList
-        self.filesList = EDIfilesList
-        # Set the components to import
-        if compList is None:
-            self.comps = ['ZXXR','ZXYR','ZYXR','ZYYR','ZXXI','ZXYI','ZYXI','ZYYI','ZXX.VAR','ZXY.VAR','ZYX.VAR','ZYY.VAR']
-        else:
-            self.comps = compList
-        if outEPSG is not None:
-            self._outEPSG = outEPSG
-
-    def __call__(self,comps=None):
-
-        if comps is None:
-            return self._data
-
-        return self._data[comps]
-
-    def importFiles(self):
-        """
-        Function to import EDI files into a object.
-
-
-        """
-
-        # Constants that are needed for convertion of units
-
-        # Temp lists
-        tmpStaList = []
-
-        tmpCompList = ['freq','x','y','z']
-        tmpCompList.extend(self.comps)
-        # Make the outarray
-        dtRI = [(compS.lower().replace('.',''),float) for compS in tmpCompList]
-        # Loop through all the files
-        for nrEDI, EDIfile in enumerate(self.filesList):
-            # Read the file into a list of the lines
-            with open(EDIfile,'r') as fid:
-                EDIlines = fid.readlines()
-            # Find the location
-            latD, longD, elevM = _findLatLong(EDIlines)
-            # Transfrom coordinates
-            transCoord = self._transfromPoints(longD,latD)
-            # Extract the name of the file (station)
-            EDIname = EDIfile.split(os.sep)[-1].split('.')[0]
-            # Arrange the data
-            staList = [EDIname, EDIfile, transCoord[0], transCoord[1], elevM[0]]
-            # Add to the station list
-            tmpStaList.extend(staList)
-
-            # Read the frequency data
-            freq = _findEDIcomp('>FREQ',EDIlines)
-            # Make the temporary rec array.
-            tArrRec = ( np.nan*np.ones( (len(freq),len(dtRI)) ) ).view(dtRI)     #np.concatenate((freq*np.ones((locs.shape[0],1)),locs,np.nan*np.ones((locs.shape[0],8))),axis=1).view(dtRI)
-            # Add data to the array
-            tArrRec['freq'] = mkvc(freq,2)
-            tArrRec['x'] = mkvc(np.ones((len(freq),1))*transCoord[0],2)
-            tArrRec['y'] = mkvc(np.ones((len(freq),1))*transCoord[1],2)
-            tArrRec['z'] = mkvc(np.ones((len(freq),1))*elevM[0],2)
-            for comp in self.comps:
-                # Deal with converting units of the impedance tensor
-                if 'Z' in comp:
-                    unitConvert = self._impUnitEDI2SI
-                else:
-                    unitConvert = 1
-                # Rotate the data since EDI x is *north, y *east but Simpeg uses x *east, y *north (* means internal reference frame)
-                key = [comp.lower().replace('.','').replace(s,t) for s,t in [['xx','yy'],['xy','yx'],['yx','xy'],['yy','xx']] if s in comp.lower()][0]
-                tArrRec[key] = mkvc(unitConvert*_findEDIcomp('>'+comp,EDIlines),2)
-            # Make a masked array
-            mArrRec = np.ma.MaskedArray(rec2ndarr(tArrRec),mask=np.isnan(rec2ndarr(tArrRec))).view(dtype=tArrRec.dtype)
-            try:
-                outTemp = recFunc.stack_arrays((outTemp,mArrRec))
-            except NameError as e:
-                outTemp = mArrRec
-
-        # Assign the data
-        self._data = outTemp
-
-    # % Assign the data to the obj
-    # nOutData=length(obj.data);
-    # obj.data(nOutData+1:nOutData+length(TEMP.data),:) = TEMP.data;
-    def _transfromPoints(self,longD,latD):
-        # Import the coordinate projections
-        try:
-            import osr
-        except ImportError as e:
-            print 'Could not import osr, missing the gdal package\nCan not project coordinates'
-            raise e
-        # Coordinates convertor
-        if self._2out is None:
-            src = osr.SpatialReference()
-            src.ImportFromEPSG(4326)
-            out = osr.SpatialReference()
-            if self._outEPSG is None:
-                # Find the UTM EPSG number
-                Nnr =  700 if latD < 0.0 else 600
-                utmZ = int(1+(longD+180.0)/6.0)
-                self._outEPSG = 32000 + Nnr + utmZ
-            out.ImportFromEPSG(self._outEPSG)
-            self._2out = osr.CoordinateTransformation(src,out)
-        # Return the transfrom
-        return self._2out.TransformPoint(longD,latD)
-
-# Hidden functions
-def _findLatLong(fileLines):
-    latDMS = np.array(fileLines[_findLine('LAT=',fileLines)[0]].split('=')[1].split()[0].split(':'),float)
-    longDMS = np.array(fileLines[_findLine('LONG=',fileLines)[0]].split('=')[1].split()[0].split(':'),float)
-    elevM = np.array([fileLines[_findLine('ELEV=',fileLines)[0]].split('=')[1].split()[0]],float)
-    # Convert to D.ddddd values
-    latS = np.sign(latDMS[0])
-    longS = np.sign(longDMS[0])
-    latD = latDMS[0] + latS*latDMS[1]/60 + latS*latDMS[2]/3600
-    longD = longDMS[0] + longS*longDMS[1]/60 + longS*longDMS[2]/3600
-    return latD, longD, elevM
-
-def _findLine(comp,fileLines):
-    """ Find a line number in the file"""
-    # Line counter
-    c = 0
-    # List of indices for found lines
-    found = []
-    # Loop through all the lines
-    for line in fileLines:
-        if comp in line:
-            # Append if found
-            found.append(c)
-        # Increse the counter
-        c += 1
-    # Return the found indices
-    return found
-
-def _findEDIcomp(comp,fileLines,dt=float):
-    """
-    Extract the data vector.
-
-    Returns a list of the data.
-    """
-    # Find the data
-    headLine, indHead = [(st,nr) for nr,st in enumerate(fileLines) if re.search(comp,st)][0]
-    # Extract the data
-    nrVec = int(headLine.split()[-1])
-    c = 0
-    dataList = []
-    while c < nrVec:
-        indHead += 1
-        dataList.extend(fileLines[indHead].split())
-        c = len(dataList)
-    return np.array(dataList,dt)

SimPEG/MT/Utils/plotDataTypes.py

@@ -1,416 +0,0 @@
-from matplotlib import pyplot as plt, colors, numpy as np
-
-
-def rec2nd(structArray):
-	""" Converts a structured/record array to ndarray to do operations on."""
-	return structArray.view((np.float,len(structArray.dtype.names)))
-
-def plotIsoFreqNSimpedance(ax,freq,array,flag,par='abs',colorbar=True,colorNorm='SymLog',cLevel=True,contour=True):
-
-	indUniFreq = np.where(freq==array['freq'])
-
-
-	x, y = array['x'][indUniFreq],array['y'][indUniFreq]
-	if par == 'abs':
-		zPlot = np.abs(array[flag][indUniFreq])
-		cmap = plt.get_cmap('OrRd_r')#seismic')
-		level = np.logspace(0,-5,31)
-		clevel = np.logspace(0,-4,5)
-		plotNorm = colors.LogNorm()
-	elif par == 'real':
-		zPlot = np.real(array[flag][indUniFreq])
-		cmap = plt.get_cmap('RdYlBu')
-		if cLevel:
-			level = np.concatenate((-np.logspace(0,-10,31),np.logspace(-10,0,31)))
-			clevel = np.concatenate((-np.logspace(0,-8,5),np.logspace(-8,0,5)))
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-		if colorNorm=='SymLog':
-			plotNorm = colors.SymLogNorm(1e-10,linscale=2)
-		else:
-			plotNorm = colors.Normalize()
-	elif par == 'imag':
-		zPlot = np.imag(array[flag][indUniFreq])
-		cmap = plt.get_cmap('RdYlBu')
-		level = np.concatenate((-np.logspace(0,-10,31),np.logspace(-10,0,31)))
-		clevel = np.concatenate((-np.logspace(0,-8,5),np.logspace(-8,0,5)))
-		plotNorm = colors.SymLogNorm(1e-10,linscale=2)		
-		if cLevel:
-			level = np.concatenate((-np.logspace(0,-10,31),np.logspace(-10,0,31)))
-			clevel = np.concatenate((-np.logspace(0,-8,5),np.logspace(-8,0,5)))
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-		if colorNorm=='SymLog':
-			plotNorm = colors.SymLogNorm(1e-10,linscale=2)
-		elif colorNorm=='Lin':
-			plotNorm = colors.Normalize()
-	if contour:
-		cs = ax.tricontourf(x,y,zPlot,levels=level,cmap=cmap,norm=plotNorm)#,extend='both')
-	else:
-		uniX,uniY = np.unique(x),np.unique(y)
-		X,Y = np.meshgrid(np.append(uniX-25,uniX[-1]+25),np.append(uniY-25,uniY[-1]+25))
-		cs = ax.pcolor(X,Y,np.reshape(zPlot,(len(uniY),len(uniX))),cmap=cmap,norm=plotNorm)
-	if colorbar:
-		plt.colorbar(cs,cax=ax.cax,ticks=clevel,format='%1.2e')
-		ax.set_title(flag+' '+par,fontsize=8)
-	return cs
-
-def plotIsoFreqNSDiff(ax,freq,arrayList,flag,par='abs',colorbar=True,cLevel=True,mask=None,contourLine=True,useLog=False):
-
-	indUniFreq0 = np.where(freq==arrayList[0]['freq'])
-	indUniFreq1 = np.where(freq==arrayList[1]['freq'])
-	seicmap = plt.get_cmap('RdYlBu')#seismic')
-	x, y = arrayList[0]['x'][indUniFreq0],arrayList[0]['y'][indUniFreq0]
-	if par == 'abs':
-		if useLog:
-			zPlot = (np.log10(np.abs(arrayList[0][flag][indUniFreq0])) - np.log10(np.abs(arrayList[1][flag][indUniFreq1])))/np.log10(np.abs(arrayList[1][flag][indUniFreq1]))
-		else:
-			zPlot = (np.abs(arrayList[0][flag][indUniFreq0]) - np.abs(arrayList[1][flag][indUniFreq1]))/np.abs(arrayList[1][flag][indUniFreq1])
-		if mask:
-			maskInd = np.logical_or(np.abs(arrayList[0][flag][indUniFreq0])< 1e-3,np.abs(arrayList[1][flag][indUniFreq1]) < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		if cLevel:
-			level = np.arange(-200,201,10) 
-			clevel = np.arange(-200,201,25)
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-	elif par == 'real':
-		if useLog:
-			zPlot = (np.log10(np.real(arrayList[0][flag][indUniFreq0])) -np.log10(np.real(arrayList[1][flag][indUniFreq1])))/np.log10(np.abs((np.real(arrayList[1][flag][indUniFreq1]))))
-		else:
-			zPlot = (np.real(arrayList[0][flag][indUniFreq0]) -np.real(arrayList[1][flag][indUniFreq1]))/np.abs((np.real(arrayList[1][flag][indUniFreq1])))
-		if mask:
-			maskInd = np.logical_or(np.abs(np.real(arrayList[0][flag][indUniFreq0])) < 1e-3,np.abs(np.real(arrayList[1][flag][indUniFreq1])) < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		if cLevel:
-			level = np.arange(-200,201,10) 
-			clevel = np.arange(-200,201,25)
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-	elif par == 'imag':
-		if useLog:
-			zPlot = (np.log10(np.imag(arrayList[0][flag][indUniFreq0])) -np.log10(np.imag(arrayList[1][flag][indUniFreq1])))/np.log10(np.abs((np.imag(arrayList[1][flag][indUniFreq1]))))
-		else:
-			zPlot = (np.imag(arrayList[0][flag][indUniFreq0]) -np.imag(arrayList[1][flag][indUniFreq1]))/np.abs((np.imag(arrayList[1][flag][indUniFreq1])))
-		if mask:
-			maskInd = np.logical_or(np.abs(np.imag(arrayList[0][flag][indUniFreq0])) < 1e-3,np.abs(np.imag(arrayList[1][flag][indUniFreq1])) < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		if cLevel:
-			level = np.arange(-200,201,10) 
-			clevel = np.arange(-200,201,25)
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-	cs = ax.tricontourf(x,y,zPlot*100,levels=level*100,cmap=seicmap,extend='both') #,norm=colors.SymLogNorm(1e-2,linscale=2))
-	if contourLine:
-		csl = ax.tricontour(x,y,zPlot*100,levels=clevel*100,colors='k')
-		plt.clabel(csl, fontsize=7, inline=1,fmt='%1.1e',inline_spacing=10)
-	if colorbar:
-		cb = plt.colorbar(cs,cax=ax.cax,ticks=clevel*100,format='%1.1e')
-		for t in cb.ax.get_yticklabels():
-			t.set_rotation(60)
-			t.set_fontsize(8)
-
-	ax.set_title(flag+' '+par,fontsize=8)
-
-def plotIsoFreqNStipper(ax,freq,array,flag,par='abs',colorbar=True,colorNorm='SymLog',cLevel=True,contour=True):
-
-	indUniFreq = np.where(freq==array['freq'])
-
-	x, y = array['x'][indUniFreq],array['y'][indUniFreq]
-	if par == 'abs':
-		cmap = plt.get_cmap('OrRd_r')#seismic')
-		zPlot = np.abs(array[flag][indUniFreq])
-		if cLevel:
-			level = np.logspace(-4,0,33)
-			clevel = np.logspace(-4,0,5)
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-		if colorNorm=='SymLog':
-			plotNorm = colors.LogNorm()
-		else:
-			plotNorm = colors.Normalize()
-	elif par == 'real':
-		cmap = plt.get_cmap('RdYlBu')
-		zPlot = np.real(array[flag][indUniFreq])
-		if cLevel:
-			level = np.concatenate((-np.logspace(0,-4,33),np.logspace(-4,0,33)))
-			clevel = np.concatenate((-np.logspace(0,-4,5),np.logspace(-4,0,5)))
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-		if colorNorm=='SymLog':
-			plotNorm = colors.SymLogNorm(1e-4,linscale=2)
-		else:
-			plotNorm = colors.Normalize()
-	elif par == 'imag':
-		cmap = plt.get_cmap('RdYlBu')
-		zPlot = np.imag(array[flag][indUniFreq])
-		if cLevel:
-			level = np.concatenate((-np.logspace(0,-4,33),np.logspace(-4,0,33)))
-			clevel = np.concatenate((-np.logspace(0,-4,5),np.logspace(-4,0,5)))
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10)
-		if colorNorm=='SymLog':
-			plotNorm = colors.SymLogNorm(1e-4,linscale=2)
-		else:
-			plotNorm = colors.Normalize()
-	if contour:
-		cs = ax.tricontourf(x,y,zPlot,levels=level,cmap=cmap,norm=plotNorm)#,extend='both')
-	else:
-		uniX,uniY = np.unique(x),np.unique(y)
-		X,Y = np.meshgrid(np.append(uniX-25,uniX[-1]+25),np.append(uniY-25,uniY[-1]+25))
-		cs = ax.pcolor(X,Y,np.reshape(zPlot,(len(uniY),len(uniX))),levels=level,cmap=cmap,norm=plotNorm,edgecolors='k', linewidths=0.5)
-	if colorbar:
-		plt.colorbar(cs,cax=ax.cax,ticks=clevel,format='%1.2e')
-	ax.set_title(flag+' '+par,fontsize=8)
-
-def plotIsoStaImpedance(ax,loc,array,flag,par='abs',pSym='s',pColor=None):	
-	
-	appResFact = 1/(8*np.pi**2*10**(-7))
-	treshold = 1.0 # 1 meter
-	indUniSta = np.sqrt(np.sum((rec2nd(array[['x','y']])-loc)**2,axis=1)) < treshold
-	freq = array['freq'][indUniSta]
-	
-	if par == 'abs':
-		zPlot = np.abs(array[flag][indUniSta])
-	elif par == 'real':
-		zPlot = np.real(array[flag][indUniSta])
-	elif par == 'imag':
-		zPlot = np.imag(array[flag][indUniSta])
-	elif par == 'res':
-		zPlot = (appResFact/freq)*np.abs(array[flag][indUniSta])**2
-	elif par == 'phs':
-		zPlot = np.arctan2(array[flag][indUniSta].imag,array[flag][indUniSta].real)*(180/np.pi)
-
-	if not pColor:
-		if 'xx' in flag:
-			lab = 'XX'
-			pColor = 'g'
-		elif 'xy' in flag:
-			lab = 'XY'
-			pColor = 'r'	
-		elif 'yx' in flag:
-			lab = 'YX'
-			pColor = 'b'
-		elif 'yy' in flag:
-			lab = 'YY'
-			pColor = 'y'
-
-	ax.plot(freq,zPlot,color=pColor,marker=pSym,label=flag)
-	
-
-def plotPsudoSectNSimpedance(ax,sectDict,array,flag,par='abs',colorbar=True,colorNorm='None',cLevel=None,contour=True):
-
-	indSect = np.where(sectDict.values()[0]==array[sectDict.keys()[0]])
-
-	# Define the plot axes
-	if 'x' in sectDict.keys()[0]:
-		x = array['y'][indSect]
-	else:
-		x = array['x'][indSect]
-	y = array['freq'][indSect]
-
-	if par == 'abs':
-		zPlot = np.abs(array[flag][indSect])
-		cmap = plt.get_cmap('OrRd_r')#seismic')
-		if cLevel:
-			level = np.logspace(0,-5,31,endpoint=True)
-			clevel = np.logspace(0,-4,5,endpoint=True)
-		else:
-			level = np.linspace(zPlot.min(),zPlot.max(),100,endpoint=True)
-			clevel = np.linspace(zPlot.min(),zPlot.max(),10,endpoint=True)
-		
-	elif par == 'ares':	
-		zPlot = np.abs(array[flag][indSect])**2/(8*np.pi**2*10**(-7)*array['freq'][indSect])
-		cmap = plt.get_cmap('RdYlBu')#seismic)
-		if cLevel:
-			zMax = np.log10(cLevel[1])
-			zMin = np.log10(cLevel[0])
-		else:
-			zMax = (np.ceil(np.log10(np.abs(zPlot).max())))
-			zMin = (np.floor(np.log10(np.abs(zPlot).min())))
-		level = np.logspace(zMin,zMax,(zMax-zMin)*8+1,endpoint=True)
-		clevel = np.logspace(zMin,zMax,(zMax-zMin)*2+1,endpoint=True)
-		plotNorm = colors.LogNorm()
-
-	elif par == 'aphs':
-		zPlot = np.arctan2(array[flag][indSect].imag,array[flag][indSect].real)*(180/np.pi)
-		cmap = plt.get_cmap('RdYlBu')#seismic)
-		if cLevel:
-			zMax = cLevel[1]
-			zMin = cLevel[0]
-		else:
-			zMax = (np.ceil(zPlot).max())
-			zMin = (np.floor(zPlot).min())
-		level = np.arange(zMin,zMax+.1,1)
-		clevel = np.arange(zMin,zMax+.1,10)
-		plotNorm = colors.Normalize()
-
-	elif par == 'real':
-		zPlot = np.real(array[flag][indSect])
-		cmap = plt.get_cmap('Spectral') #('RdYlBu')
-		if cLevel:
-			zMax = np.log10(cLevel[1])
-			zMin = np.log10(cLevel[0])
-		else:
-			zMax = (np.ceil(np.log10(np.abs(zPlot).max())))
-			zMin = (np.floor(np.log10(np.abs(zPlot).min())))
-		level = np.concatenate((-np.logspace(zMax,zMin-.125,(zMax-zMin)*8+1,endpoint=True),np.logspace(zMin-.125,zMax,(zMax-zMin)*8+1,endpoint=True)))
-		clevel = np.concatenate((-np.logspace(zMax,zMin,(zMax-zMin)*1+1,endpoint=True),np.logspace(zMin,zMax,(zMax-zMin)*1+1,endpoint=True)))
-		plotNorm = colors.SymLogNorm(np.abs(level).min(),linscale=0.1)
-	elif par == 'imag':
-		zPlot = np.imag(array[flag][indSect])
-		cmap = plt.get_cmap('Spectral') #('RdYlBu')
-		
-		if cLevel:
-			zMax = np.log10(cLevel[1])
-			zMin = np.log10(cLevel[0])
-		else:
-			zMax = (np.ceil(np.log10(np.abs(zPlot).max())))
-			zMin = (np.floor(np.log10(np.abs(zPlot).min())))
-		level = np.concatenate((-np.logspace(zMax,zMin-.125,(zMax-zMin)*8+1,endpoint=True),np.logspace(zMin-.125,zMax,(zMax-zMin)*8+1,endpoint=True)))
-		clevel = np.concatenate((-np.logspace(zMax,zMin,(zMax-zMin)*1+1,endpoint=True),np.logspace(zMin,zMax,(zMax-zMin)*1+1,endpoint=True)))
-		plotNorm = colors.SymLogNorm(np.abs(level).min(),linscale=0.1)
-	
-	if colorNorm=='SymLog':
-		plotNorm = colors.SymLogNorm(np.abs(level).min(),linscale=0.1)
-	elif colorNorm=='Lin':
-		plotNorm = colors.Normalize()
-	elif colorNorm=='Log':
-		plotNorm = colors.LogNorm()
-	if contour:
-		cs = ax.tricontourf(x,y,zPlot,levels=level,cmap=cmap,norm=plotNorm)#,extend='both')
-	else:
-		uniX,uniY = np.unique(x),np.unique(y)
-		X,Y = np.meshgrid(np.append(uniX-25,uniX[-1]+25),np.append(uniY-25,uniY[-1]+25))
-		cs = ax.pcolor(X,Y,np.reshape(zPlot,(len(uniY),len(uniX))),cmap=cmap,norm=plotNorm)
-	if colorbar:
-		csB = plt.colorbar(cs,cax=ax.cax,ticks=clevel,format='%1.2e')
-		# csB.on_mappable_changed(cs)
-		ax.set_title(flag+' '+par,fontsize=8)
-		return cs, csB
-	return cs,None
-
-
-def plotPsudoSectNSDiff(ax,sectDict,arrayList,flag,par='abs',colorbar=True,colorNorm='SymLog',cLevel=None,contour=True,mask=None,useLog=False):
-
-	def sortInArr(arr):
-		return np.sort(arr,order=['freq','x','y','z'])
-	# Find the index for the slice
-	indSect0 = np.where(sectDict.values()[0]==arrayList[0][sectDict.keys()[0]])
-	indSect1 = np.where(sectDict.values()[0]==arrayList[1][sectDict.keys()[0]])
-	# Extract and sort the mats
-	arr0 = sortInArr(arrayList[0][indSect0])
-	arr1 = sortInArr(arrayList[1][indSect1])
-
-	# Define the plot axes
-	if 'x' in sectDict.keys()[0]:
-		x0 = arr0['y']
-		x1 = arr1['y']
-	else:
-		x0 = arr0['x']
-		x1 = arr1['x']
-	y0 = arr0['freq']
-	y1 = arr1['freq']
-	
-
-	if par == 'abs':
-		if useLog:
-			zPlot = (np.log10(np.abs(arr0[flag])) - np.log10(np.abs(arr1[flag])))/np.log10(np.abs(arr1[flag]))
-		else:
-			zPlot = (np.abs(arr0[flag]) - np.abs(arr1[flag]))/np.abs(arr1[flag])
-		if mask:
-			maskInd = np.logical_or(np.abs(arr0[flag])< 1e-3,np.abs(arr1[flag]) < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		cmap = plt.get_cmap('RdYlBu')#seismic)
-	elif par == 'ares':
-		arF = 1/(8*np.pi**2*10**(-7))		
-		if useLog:
-			zPlot = (np.log10((arF/arr0['freq'])*np.abs(arr0[flag])**2) - np.log10((arF/arr1['freq'])*np.abs(arr1[flag])**2))/np.log10((arF/arr1['freq'])*np.abs(arr1[flag])**2)
-		else:
-			zPlot = ((arF/arr0['freq'])*np.abs(arr0[flag])**2 - (arF/arr1['freq'])*np.abs(arr1[flag])**2)/((arF/arr1['freq'])*np.abs(arr1[flag])**2)
-		if mask:
-			maskInd = np.logical_or(np.abs(arr0[flag])< 1e-3,np.abs(arr1[flag]) < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		cmap = plt.get_cmap('Spectral')#seismic)
-	
-	elif par == 'aphs':
-		if useLog:
-			zPlot = (np.log10(np.arctan2(arr0[flag].imag,arr0[flag].real)*(180/np.pi)) - np.log10(np.arctan2(arr1[flag].imag,arr1[flag].real)*(180/np.pi)) )/np.log10(np.arctan2(arr1[flag].imag,arr1[flag].real)*(180/np.pi))
-		else:
-			zPlot = ( np.arctan2(arr0[flag].imag,arr0[flag].real)*(180/np.pi) - np.arctan2(arr1[flag].imag,arr1[flag].real)*(180/np.pi) )/(np.arctan2(arr1[flag].imag,arr1[flag].real)*(180/np.pi))
-		if mask:
-			maskInd = np.logical_or(np.abs(arr0[flag])< 1e-3,np.abs(arr1[flag]) < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		cmap = plt.get_cmap('Spectral')#seismic)
-	elif par == 'real':
-		if useLog:
-			zPlot = (np.log10(arr0[flag].real) - np.log10(arr1[flag].real))/np.log10(arr1[flag].real)
-		else:
-			zPlot = (arr0[flag].real - arr1[flag].real)/arr1[flag].real
-		if mask:
-			maskInd = np.logical_or(arr0[flag].real< 1e-3,arr1[flag].real < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		cmap = plt.get_cmap('Spectral') #('Spectral')
-		
-	elif par == 'imag':
-		if useLog:
-			zPlot = (np.log10(arr0[flag].imag) - np.log10(arr1[flag].imag))/np.log10(arr1[flag].imag)
-		else:
-			zPlot = (arr0[flag].imag - arr1[flag].imag)/arr1[flag].imag
-		if mask:
-			maskInd = np.logical_or(arr0[flag].imag< 1e-3,arr1[flag].imag < 1e-3)
-			zPlot = np.ma.array(zPlot)
-			zPlot[maskInd] = mask
-		cmap = plt.get_cmap('Spectral') #('RdYlBu')
-		
-	if cLevel:
-		zMax = np.log10(cLevel[1])
-		zMin = np.log10(cLevel[0])
-	else:
-		zMax = (np.ceil(np.log10(np.abs(zPlot).max())))
-		zMin = (np.floor(np.log10(np.abs(zPlot).min())))
-
-	
-	if colorNorm=='SymLog':
-		level = np.concatenate((-np.logspace(zMax,zMin-.125,(zMax-zMin)*8+1,endpoint=True),np.logspace(zMin-.125,zMax,(zMax-zMin)*8+1,endpoint=True)))
-		clevel = np.concatenate((-np.logspace(zMax,zMin,(zMax-zMin)*1+1,endpoint=True),np.logspace(zMin,zMax,(zMax-zMin)*1+1,endpoint=True)))
-		plotNorm = colors.SymLogNorm(np.abs(level).min(),linscale=0.1)
-	elif colorNorm=='Lin':
-		if cLevel:
-			level = np.arange(cLevel[0],cLevel[1]+.1,(cLevel[1] - cLevel[0])/50.) 
-			clevel = np.arange(cLevel[0],cLevel[1]+.1,(cLevel[1] - cLevel[0])/10.)
-		else:
-			level = np.arange(zPlot.min(),zPlot.max(),(zPlot.max() - zPlot.min())/50.)
-			clevel = np.arange(zPlot.min(),zPlot.max(),(zPlot.max() - zPlot.min())/10.)
-		plotNorm = colors.Normalize()
-	elif colorNorm=='Log':
-		level = np.logspace(zMin-.125,zMax,(zMax-zMin)*8+1,endpoint=True)
-		clevel = np.logspace(zMin,zMax,(zMax-zMin)*2+1,endpoint=True)
-		plotNorm = colors.LogNorm()
-	if contour:
-		cs = ax.tricontourf(x0,y0,zPlot*100,levels=level*100,cmap=cmap,norm=plotNorm,extend='both')#,extend='both')
-	else:
-		uniX,uniY = np.unique(x0),np.unique(y0)
-		X,Y = np.meshgrid(np.append(uniX-25,uniX[-1]+25),np.append(uniY-25,uniY[-1]+25))
-		cs = ax.pcolor(X,Y,np.reshape(zPlot,(len(uniY),len(uniX))),cmap=cmap,norm=plotNorm)
-	if colorbar:
-		csB = plt.colorbar(cs,cax=ax.cax,ticks=clevel*100,format='%1.2e')
-		# csB.on_mappable_changed(cs)
-		ax.set_title(flag+' '+par + ' diff',fontsize=8)
-		return cs, csB
-	return cs,None

SimPEG/MT/Utils/sourceUtils.py

@@ -1,178 +0,0 @@
-import SimPEG as simpeg, numpy as np
-
-def homo1DModelSource(mesh,freq,sigma_1d):
-    '''
-        Function that calculates and return background fields
-
-        :param Simpeg mesh object mesh: Holds information on the discretization
-        :param float freq: The frequency to solve at
-        :param np.array sigma_1d: Background model of conductivity to base the calculations on, 1d model.
-        :rtype: numpy.ndarray (mesh.nE,2)
-        :return: eBG_bp, E fields for the background model at both polarizations.
-
-    '''
-    # import
-    from SimPEG.MT.Utils import get1DEfields
-    # Get a 1d solution for a halfspace background
-    if mesh.dim == 1:
-        mesh1d = mesh
-    elif mesh.dim == 2:
-        mesh1d = simpeg.Mesh.TensorMesh([mesh.hy],np.array([mesh.x0[1]]))
-    elif mesh.dim == 3:
-        mesh1d = simpeg.Mesh.TensorMesh([mesh.hz],np.array([mesh.x0[2]]))
-
-    # # Note: Everything is using e^iwt
-    e0_1d = get1DEfields(mesh1d,sigma_1d,freq)
-    if mesh.dim == 1:
-        eBG_px = simpeg.mkvc(e0_1d,2)
-        eBG_py = -simpeg.mkvc(e0_1d,2) # added a minus to make the results in the correct quadrents.
-    elif mesh.dim == 2:
-        ex_px = np.zeros(mesh.vnEx,dtype=complex)
-        ey_px = np.zeros((mesh.nEy,1),dtype=complex)
-        for i in np.arange(mesh.vnEx[0]):
-            ex_px[i,:] = -e0_1d
-        eBG_px = np.vstack((simpeg.Utils.mkvc(ex_px,2),ey_px))
-        # Setup y (north) polarization (_py)
-        ex_py = np.zeros((mesh.nEx,1), dtype='complex128')
-        ey_py = np.zeros(mesh.vnEy, dtype='complex128')
-        # Assign the source to ey_py
-        for i in np.arange(mesh.vnEy[0]):
-            ey_py[i,:] = e0_1d
-        # ey_py[1:-1,1:-1,1:-1] = 0
-        eBG_py = np.vstack((ex_py,simpeg.Utils.mkvc(ey_py,2),ez_py))
-    elif mesh.dim == 3:
-        # Setup x (east) polarization (_x)
-        ex_px = np.zeros(mesh.vnEx,dtype=complex)
-        ey_px = np.zeros((mesh.nEy,1),dtype=complex)
-        ez_px = np.zeros((mesh.nEz,1),dtype=complex)
-        # Assign the source to ex_x
-        for i in np.arange(mesh.vnEx[0]):
-            for j in np.arange(mesh.vnEx[1]):
-                ex_px[i,j,:] = -e0_1d
-        eBG_px = np.vstack((simpeg.Utils.mkvc(ex_px,2),ey_px,ez_px))
-        # Setup y (north) polarization (_py)
-        ex_py = np.zeros((mesh.nEx,1), dtype='complex128')
-        ey_py = np.zeros(mesh.vnEy, dtype='complex128')
-        ez_py = np.zeros((mesh.nEz,1), dtype='complex128')
-        # Assign the source to ey_py
-        for i in np.arange(mesh.vnEy[0]):
-            for j in np.arange(mesh.vnEy[1]):
-                ey_py[i,j,:] = e0_1d
-        # ey_py[1:-1,1:-1,1:-1] = 0
-        eBG_py = np.vstack((ex_py,simpeg.Utils.mkvc(ey_py,2),ez_py))
-
-    # Return the electric fields
-    eBG_bp = np.hstack((eBG_px,eBG_py))
-    return eBG_bp
-
-def analytic1DModelSource(mesh,freq,sigma_1d):
-    '''
-        Function that calculates and return background fields
-
-        :param Simpeg mesh object mesh: Holds information on the discretization
-        :param float freq: The frequency to solve at
-        :param np.array sigma_1d: Background model of conductivity to base the calculations on, 1d model.
-        :rtype: numpy.ndarray (mesh.nE,2)
-        :return: eBG_bp, E fields for the background model at both polarizations.
-
-    '''
-    # import
-    from SimPEG.MT.Utils import getEHfields
-    # Get a 1d solution for a halfspace background
-    if mesh.dim == 1:
-        mesh1d = mesh
-    elif mesh.dim == 2:
-        mesh1d = simpeg.Mesh.TensorMesh([mesh.hy],np.array([mesh.x0[1]]))
-    elif mesh.dim == 3:
-        mesh1d = simpeg.Mesh.TensorMesh([mesh.hz],np.array([mesh.x0[2]]))
-
-    # # Note: Everything is using e^iwt
-    Eu, Ed, _, _ = getEHfields(mesh1d,sigma_1d,freq,mesh.vectorNz)
-    # Make the fields into a dictionary of location and the fields
-    e0_1d = Eu+Ed
-    E1dFieldDict = dict(zip(mesh.vectorNz,e0_1d))
-    if mesh.dim == 1:
-        eBG_px = simpeg.mkvc(e0_1d,2)
-        eBG_py = -simpeg.mkvc(e0_1d,2) # added a minus to make the results in the correct quadrents.
-    elif mesh.dim == 2:
-        ex_px = np.zeros(mesh.vnEx,dtype=complex)
-        ey_px = np.zeros((mesh.nEy,1),dtype=complex)
-        for i in np.arange(mesh.vnEx[0]):
-            ex_px[i,:] = -e0_1d
-        eBG_px = np.vstack((simpeg.Utils.mkvc(ex_px,2),ey_px))
-        # Setup y (north) polarization (_py)
-        ex_py = np.zeros((mesh.nEx,1), dtype='complex128')
-        ey_py = np.zeros(mesh.vnEy, dtype='complex128')
-        # Assign the source to ey_py
-        for i in np.arange(mesh.vnEy[0]):
-            ey_py[i,:] = e0_1d
-        # ey_py[1:-1,1:-1,1:-1] = 0
-        eBG_py = np.vstack((ex_py,simpeg.Utils.mkvc(ey_py,2),ez_py))
-    elif mesh.dim == 3:
-        # Setup x (east) polarization (_x)
-        ex_px = -np.array([E1dFieldDict[i] for i in mesh.gridEx[:,2]]).reshape(-1,1)
-        ey_px = np.zeros((mesh.nEy,1),dtype=complex)
-        ez_px = np.zeros((mesh.nEz,1),dtype=complex)
-        # Construct the full fields
-        eBG_px = np.vstack((ex_px,ey_px,ez_px))
-        # Setup y (north) polarization (_py)
-        ex_py = np.zeros((mesh.nEx,1), dtype='complex128')
-        ey_py = np.array([E1dFieldDict[i] for i in mesh.gridEy[:,2]]).reshape(-1,1)
-        ez_py = np.zeros((mesh.nEz,1), dtype='complex128')
-        # Construct the full fields
-        eBG_py = np.vstack((ex_py,simpeg.Utils.mkvc(ey_py,2),ez_py))
-
-    # Return the electric fields
-    eBG_bp = np.hstack((eBG_px,eBG_py))
-    return eBG_bp
-
-# def homo3DModelSource(mesh,model,freq):
-#     '''
-#         Function that estimates 1D analytic background fields from a 3D model.
-
-#         :param Simpeg mesh object mesh: Holds information on the discretization
-#         :param float freq: The frequency to solve at
-#         :param np.array sigma_1d: Background model of conductivity to base the calculations on, 1d model.
-#         :rtype: numpy.ndarray (mesh.nE,2)
-#         :return: eBG_bp, E fields for the background model at both polarizations.
-
-#     '''
-
-#     if mesh.dim < 3:
-#         raise IOError('Input mesh has to have 3 dimensions.')
-
-
-#     # Get the locations
-#     a = mesh.gridCC[:,0:2].copy()
-#     unixy = np.unique(a.view(a.dtype.descr * a.shape[1])).view(float).reshape(-1,2)
-#     uniz = np.unique(mesh.gridCC[:,2])
-#     # # Note: Everything is using e^iwt
-#     # Need to loop thourgh the xy locations, assess the model and calculate the fields at the phusdo cell centers.
-#     # Then interpolate the cc fields to the edges.
-
-#     e0_1d = get1DEfields(mesh1d,sigma_1d,freq)
-
-#     elif mesh.dim == 3:
-#         # Setup x (east) polarization (_x)
-#         ex_px = np.zeros(mesh.vnEx,dtype=complex)
-#         ey_px = np.zeros((mesh.nEy,1),dtype=complex)
-#         ez_px = np.zeros((mesh.nEz,1),dtype=complex)
-#         # Assign the source to ex_x
-#         for i in np.arange(mesh.vnEx[0]):
-#             for j in np.arange(mesh.vnEx[1]):
-#                 ex_px[i,j,:] = -e0_1d
-#         eBG_px = np.vstack((simpeg.Utils.mkvc(ex_px,2),ey_px,ez_px))
-#         # Setup y (north) polarization (_py)
-#         ex_py = np.zeros((mesh.nEx,1), dtype='complex128')
-#         ey_py = np.zeros(mesh.vnEy, dtype='complex128')
-#         ez_py = np.zeros((mesh.nEz,1), dtype='complex128')
-#         # Assign the source to ey_py
-#         for i in np.arange(mesh.vnEy[0]):
-#             for j in np.arange(mesh.vnEy[1]):
-#                 ey_py[i,j,:] = e0_1d
-#         # ey_py[1:-1,1:-1,1:-1] = 0
-#         eBG_py = np.vstack((ex_py,simpeg.Utils.mkvc(ey_py,2),ez_py))
-
-#     # Return the electric fields
-#     eBG_bp = np.hstack((eBG_px,eBG_py))
-#     return eBG_bp

SimPEG/MT/Utils/srcUtils.py

@@ -1,46 +0,0 @@
-import SimPEG as simpeg, numpy as np
-
-def homo1DModelSource(mesh,freq,m_back):
-    '''
-        Function that calculates and return background fields for a 3D mesh and model.
-        The calculuations use 1D field solution for a vertical slice throught model (south-western most column),
-        which is assigned at the fields everywhere for the respective polarizations.2
-
-        :param Simpeg mesh object mesh: Holds information on the discretization
-        :param float freq: The frequency to solve at
-        :param np.array m_back: Background model of conductivity to base the calculations on.
-        :rtype: numpy.ndarray (mesh.nE,2)
-        :return: eBG_bp, E fields for the background model at both polarizations.
-
-    '''
-
-    # import
-    from SimPEG.MT.Utils import get1DEfields
-    # Get a 1d solution for a halfspace background
-    mesh1d = simpeg.Mesh.TensorMesh([mesh.hz],np.array([mesh.x0[2]]))
-    # Note: Everything is using e^iwt
-    e0_1d = get1DEfields(mesh1d,mesh.r(m_back,'CC','CC','M')[0,0,:],freq)
-    # Setup x (east) polarization (_x)
-    ex_px = np.zeros(mesh.vnEx,dtype=complex)
-    ey_px = np.zeros((mesh.nEy,1),dtype=complex)
-    ez_px = np.zeros((mesh.nEz,1),dtype=complex)
-    # Assign the source to ex_x
-    for i in np.arange(mesh.vnEx[0]):
-        for j in np.arange(mesh.vnEx[1]):
-            ex_px[i,j,:] = -e0_1d
-    eBG_px = np.vstack((simpeg.Utils.mkvc(ex_px,2),ey_px,ez_px))
-    # Setup y (north) polarization (_py)
-    ex_py = np.zeros((mesh.nEx,1), dtype='complex128')
-    ey_py = np.zeros(mesh.vnEy, dtype='complex128')
-    ez_py = np.zeros((mesh.nEz,1), dtype='complex128')
-    # Assign the source to ey_py
-
-    for i in np.arange(mesh.vnEy[0]):
-        for j in np.arange(mesh.vnEy[1]):
-            ey_py[i,j,:] = e0_1d
-    # ey_py[1:-1,1:-1,1:-1] = 0
-    eBG_py = np.vstack((ex_py,simpeg.Utils.mkvc(ey_py,2),ez_py))
-
-    # Return the electric fields
-    eBG_bp = np.hstack((eBG_px,eBG_py))
-    return eBG_bp

SimPEG/MT/__init__.py

@@ -1,5 +0,0 @@
-import Utils
-from SurveyMT import Rx, Survey, Data
-from FieldsMT import Fields1D_e, Fields3D_e
-import Problem1D, Problem2D, Problem3D
-import SrcMT

SimPEG/Maps.py

@@ -1,35 +1,28 @@
 import Utils, numpy as np, scipy.sparse as sp
-from scipy.sparse.linalg import LinearOperator
 from Tests import checkDerivative
 from PropMaps import PropMap, Property
-from numpy.polynomial import polynomial
-from scipy.interpolate import UnivariateSpline
-import warnings
+
 
 class IdentityMap(object):
     """
     SimPEG Map
 
     """
+
     __metaclass__ = Utils.SimPEGMetaClass
 
-    def __init__(self, mesh=None, nP=None, **kwargs):
+    mesh = None      #: A SimPEG Mesh
+
+    def __init__(self, mesh, **kwargs):
         Utils.setKwargs(self, **kwargs)
-
-        if nP is not None:
-            assert type(nP) in [int, long], ' Number of parameters must be an integer.'
-
         self.mesh = mesh
-        self._nP  = nP
 
     @property
     def nP(self):
         """
             :rtype: int
-            :return: number of parameters that the mapping accepts
+            :return: number of parameters in the model
         """
-        if self._nP is not None:
-            return self._nP
         if self.mesh is None:
             return '*'
         return self.mesh.nC
@@ -37,15 +30,11 @@ class IdentityMap(object):
     @property
     def shape(self):
         """
-            The default shape is (mesh.nC, nP) if the mesh is defined.
-            If this is a meshless mapping (i.e. nP is defined independently)
-            the shape will be the the shape (nP,nP).
+            The default shape is (mesh.nC, nP).
 
             :rtype: (int,int)
             :return: shape of the operator as a tuple
         """
-        if self._nP is not None:
-            return (self.nP, self.nP)
         if self.mesh is None:
             return ('*', self.nP)
         return (self.mesh.nC, self.nP)
@@ -127,7 +116,6 @@ class IdentityMap(object):
     def __str__(self):
         return "%s(%s,%s)" % (self.__class__.__name__, self.shape[0], self.shape[1])
 
-
 class ComboMap(IdentityMap):
     """Combination of various maps."""
 
@@ -297,11 +285,11 @@ class LogMap(IdentityMap):
     def inverse(self, m):
         return np.exp(Utils.mkvc(m))
 
-class SurjectFull(IdentityMap):
+class FullMap(IdentityMap):
     """
-    SurjectFull
+    FullMap
 
-    Given a scalar, the SurjectFull maps the value to the
+    Given a scalar, the FullMap maps the value to the 
     full model space.
     """
 
@@ -326,17 +314,11 @@ class SurjectFull(IdentityMap):
             :rtype: numpy.array
             :return: derivative of transformed model
         """
-        return np.ones([self.mesh.nC,1])
+        return np.ones([self.mesh.nC,1])     
+      
 
-class FullMap(SurjectFull):
-    def __init__(self,mesh,**kwargs):
-        warnings.warn(
-            "`FullMap` is deprecated and will be removed in future versions. Use `SurjectFull` instead",
-            FutureWarning)
-        SurjectFull.__init__(self,mesh,**kwargs)
-
-class SurjectVertical1D(IdentityMap):
-    """SurjectVertical1DMap
+class Vertical1DMap(IdentityMap):
+    """Vertical1DMap
 
         Given a 1D vector through the last dimension
         of the mesh, this will extend to the full
@@ -376,14 +358,8 @@ class SurjectVertical1D(IdentityMap):
                     ), shape=(repNum, 1))
         return sp.kron(sp.identity(self.nP), repVec)
 
-class Vertical1DMap(SurjectVertical1D):
-    def __init__(self,mesh,**kwargs):
-        warnings.warn(
-            "`Vertical1DMap` is deprecated and will be removed in future versions. Use `SurjectVertical1D` instead",
-            FutureWarning)
-        SurjectVertical1D.__init__(self,mesh,**kwargs)
 
-class Surject2Dto3D(IdentityMap):
+class Map2Dto3D(IdentityMap):
     """Map2Dto3D
 
         Given a 2D vector, this will extend to the full
@@ -438,13 +414,6 @@ class Surject2Dto3D(IdentityMap):
                 ), shape=(nC, nP))
         return P
 
-class Map2Dto3D(Surject2Dto3D):
-    def __init__(self,mesh,**kwargs):
-        warnings.warn(
-            "`Map2Dto3D` is deprecated and will be removed in future versions. Use `Surject2Dto3D` instead",
-            FutureWarning)
-        Surject2Dto3D.__init__(self,mesh,**kwargs)
-
 class Mesh2Mesh(IdentityMap):
     """
         Takes a model on one mesh are translates it to another mesh.
@@ -478,7 +447,7 @@ class Mesh2Mesh(IdentityMap):
         return self.P
 
 
-class InjectActiveCells(IdentityMap):
+class ActiveCells(IdentityMap):
     """
         Active model parameters.
 
@@ -500,10 +469,10 @@ class InjectActiveCells(IdentityMap):
         self.indActive = indActive
         self.indInactive = np.logical_not(indActive)
         if Utils.isScalar(valInactive):
-            self.valInactive = np.ones(self.nC)*float(valInactive)
-        else:
-            self.valInactive = valInactive.copy()
-        self.valInactive[self.indActive] = 0
+            valInactive = np.ones(self.nC)*float(valInactive)
+
+        valInactive[self.indActive] = 0
+        self.valInactive = valInactive
 
         inds = np.nonzero(self.indActive)[0]
         self.P = sp.csr_matrix((np.ones(inds.size),(inds, range(inds.size))), shape=(self.nC, self.nP))
@@ -526,14 +495,7 @@ class InjectActiveCells(IdentityMap):
     def deriv(self, m):
         return self.P
 
-class ActiveCells(InjectActiveCells):
-    def __init__(self, mesh, indActive, valInactive, nC=None):
-        warnings.warn(
-            "`ActiveCells` is deprecated and will be removed in future versions. Use `InjectActiveCells` instead",
-            FutureWarning)
-        InjectActiveCells.__init__(self, mesh, indActive, valInactive, nC)
-
-class InjectActiveCellsTopo(IdentityMap):
+class ActiveCellsTopo(IdentityMap):
     """
         Active model parameters. Extend for cells on topography to air cell (only works for tensor mesh)
 
@@ -604,12 +566,6 @@ class InjectActiveCellsTopo(IdentityMap):
     def deriv(self, m):
         return self.P
 
-class ActiveCellsTopo(InjectActiveCellsTopo):
-    def __init__(self, mesh, indActive, valInactive, nC=None):
-        warnings.warn(
-            "`ActiveCellsTopo` is deprecated and will be removed in future versions. Use `InjectActiveCellsTopo` instead",
-            FutureWarning)
-        InjectActiveCellsTopo.__init__(self, mesh, indActive, valInactive, nC)
 
 class Weighting(IdentityMap):
     """
@@ -683,7 +639,7 @@ class ComplexMap(IdentityMap):
             return v[:nC] + v[nC:]*1j
         def adj(v):
             return np.r_[v.real,v.imag]
-        return LinearOperator(shp,matvec=fwd,rmatvec=adj)
+        return Utils.SimPEGLinearOperator(shp,fwd,adj)
 
     inverse = deriv
 
@@ -740,319 +696,4 @@ class CircleMap(IdentityMap):
         g3 = a*(-X + x)*(-sig1 + sig2)/(np.pi*(a**2*(-r + np.sqrt((X - x)**2 + (Y - y)**2))**2 + 1)*np.sqrt((X - x)**2 + (Y - y)**2))
         g4 = a*(-Y + y)*(-sig1 + sig2)/(np.pi*(a**2*(-r + np.sqrt((X - x)**2 + (Y - y)**2))**2 + 1)*np.sqrt((X - x)**2 + (Y - y)**2))
         g5 = -a*(-sig1 + sig2)/(np.pi*(a**2*(-r + np.sqrt((X - x)**2 + (Y - y)**2))**2 + 1))
-        return sp.csr_matrix(np.c_[g1,g2,g3,g4,g5])
-
-
-class PolyMap(IdentityMap):
-
-    """PolyMap
-
-        Parameterize the model space using a polynomials in a wholespace.
-
-        ..math::
-
-            y = \mathbf{V} c
-
-        Define the model as:
-
-        ..math::
-
-            m = [\sigma_1, \sigma_2, c]
-
-        Can take in an actInd vector to account for topography.
-
-    """
-    def __init__(self, mesh, order, logSigma=True, normal='X', actInd = None):
-        IdentityMap.__init__(self, mesh)
-        self.logSigma = logSigma
-        self.order = order
-        self.normal = normal
-        self.actInd = actInd
-
-        if getattr(self, 'actInd', None) is None:
-            self.actInd = range(self.mesh.nC)
-            self.nC = self.mesh.nC
-
-        else:
-            self.nC = len(self.actInd)
-
-    slope = 1e4
-
-    @property
-    def shape(self):
-        return (self.nC, self.nP)
-
-    @property
-    def nP(self):
-        if np.isscalar(self.order):
-            nP = self.order+3
-        else:
-            nP =(self.order[0]+1)*(self.order[1]+1)+2
-        return nP
-
-    def _transform(self, m):
-        # Set model parameters
-        alpha = self.slope
-        sig1,sig2 = m[0],m[1]
-        c = m[2:]
-        if self.logSigma:
-            sig1, sig2 = np.exp(sig1), np.exp(sig2)
-        #2D
-        if self.mesh.dim == 2:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
-            if self.normal =='X':
-                f = polynomial.polyval(Y, c) - X
-            elif self.normal =='Y':
-                f = polynomial.polyval(X, c) - Y
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-        #3D
-        elif self.mesh.dim == 3:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
-            Z = self.mesh.gridCC[self.actInd,2]
-            if self.normal =='X':
-                f = polynomial.polyval2d(Y, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - X
-            elif self.normal =='Y':
-                f = polynomial.polyval2d(X, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - Y
-            elif self.normal =='Z':
-                f = polynomial.polyval2d(X, Y, c.reshape((self.order[0]+1,self.order[1]+1))) - Z
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-
-        else:
-            raise(Exception("Only supports 2D"))
-
-
-        return sig1+(sig2-sig1)*(np.arctan(alpha*f)/np.pi+0.5)
-
-    def deriv(self, m):
-        alpha = self.slope
-        sig1,sig2, c = m[0],m[1],m[2:]
-        if self.logSigma:
-            sig1, sig2 = np.exp(sig1), np.exp(sig2)
-        #2D
-        if self.mesh.dim == 2:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
-
-            if self.normal =='X':
-                f = polynomial.polyval(Y, c) - X
-                V = polynomial.polyvander(Y, len(c)-1)
-            elif self.normal =='Y':
-                f = polynomial.polyval(X, c) - Y
-                V = polynomial.polyvander(X, len(c)-1)
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-        #3D
-        elif self.mesh.dim == 3:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
-            Z = self.mesh.gridCC[self.actInd,2]
-
-            if self.normal =='X':
-                f = polynomial.polyval2d(Y, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - X
-                V = polynomial.polyvander2d(Y, Z, self.order)
-            elif self.normal =='Y':
-                f = polynomial.polyval2d(X, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - Y
-                V = polynomial.polyvander2d(X, Z, self.order)
-            elif self.normal =='Z':
-                f = polynomial.polyval2d(X, Y, c.reshape((self.order[0]+1,self.order[1]+1))) - Z
-                V = polynomial.polyvander2d(X, Y, self.order)
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-
-        if self.logSigma:
-            g1 = -(np.arctan(alpha*f)/np.pi + 0.5)*sig1 + sig1
-            g2 = (np.arctan(alpha*f)/np.pi + 0.5)*sig2
-        else:
-            g1 = -(np.arctan(alpha*f)/np.pi + 0.5) + 1.0
-            g2 = (np.arctan(alpha*f)/np.pi + 0.5)
-
-        g3 = Utils.sdiag(alpha*(sig2-sig1)/(1.+(alpha*f)**2)/np.pi)*V
-
-        return sp.csr_matrix(np.c_[g1,g2,g3])
-
-class SplineMap(IdentityMap):
-
-    """SplineMap
-
-        Parameterize the boundary of two geological units using a spline interpolation
-
-        ..math::
-
-            g = f(x)-y
-
-        Define the model as:
-
-        ..math::
-
-            m = [\sigma_1, \sigma_2, y]
-
-    """
-    def __init__(self, mesh, pts, ptsv=None,order=3, logSigma=True, normal='X'):
-        IdentityMap.__init__(self, mesh)
-        self.logSigma = logSigma
-        self.order = order
-        self.normal = normal
-        self.pts= pts
-        self.npts = np.size(pts)
-        self.ptsv = ptsv
-        self.spl = None
-
-    slope = 1e4
-    @property
-    def nP(self):
-        if self.mesh.dim == 2:
-            return np.size(self.pts)+2
-        elif self.mesh.dim == 3:
-            return np.size(self.pts)*2+2
-        else:
-            raise(Exception("Only supports 2D and 3D"))
-
-    def _transform(self, m):
-        # Set model parameters
-        alpha = self.slope
-        sig1,sig2 = m[0],m[1]
-        c = m[2:]
-        if self.logSigma:
-            sig1, sig2 = np.exp(sig1), np.exp(sig2)
-        #2D
-        if self.mesh.dim == 2:
-            X = self.mesh.gridCC[:,0]
-            Y = self.mesh.gridCC[:,1]
-            self.spl = UnivariateSpline(self.pts, c, k=self.order, s=0)
-            if self.normal =='X':
-                f = self.spl(Y) - X
-            elif self.normal =='Y':
-                f = self.spl(X) - Y
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-
-        # 3D:
-        # Comments:
-        # Make two spline functions and link them using linear interpolation.
-        # This is not quite direct extension of 2D to 3D case
-        # Using 2D interpolation  is possible
-
-        elif self.mesh.dim == 3:
-            X = self.mesh.gridCC[:,0]
-            Y = self.mesh.gridCC[:,1]
-            Z = self.mesh.gridCC[:,2]
-
-            npts = np.size(self.pts)
-            if np.mod(c.size, 2):
-                raise(Exception("Put even points!"))
-
-            self.spl = {"splb":UnivariateSpline(self.pts, c[:npts], k=self.order, s=0),
-                        "splt":UnivariateSpline(self.pts, c[npts:], k=self.order, s=0)}
-
-            if self.normal =='X':
-                zb = self.ptsv[0]
-                zt = self.ptsv[1]
-                flines = (self.spl["splt"](Y)-self.spl["splb"](Y))*(Z-zb)/(zt-zb) + self.spl["splb"](Y)
-                f = flines - X
-            # elif self.normal =='Y':
-            # elif self.normal =='Z':
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-        else:
-            raise(Exception("Only supports 2D and 3D"))
-
-
-        return sig1+(sig2-sig1)*(np.arctan(alpha*f)/np.pi+0.5)
-
-    def deriv(self, m):
-        alpha = self.slope
-        sig1,sig2, c = m[0],m[1],m[2:]
-        if self.logSigma:
-            sig1, sig2 = np.exp(sig1), np.exp(sig2)
-        #2D
-        if self.mesh.dim == 2:
-            X = self.mesh.gridCC[:,0]
-            Y = self.mesh.gridCC[:,1]
-
-            if self.normal =='X':
-                f = self.spl(Y) - X
-            elif self.normal =='Y':
-                f = self.spl(X) - Y
-            else:
-                raise(Exception("Input for normal = X or Y or Z"))
-        #3D
-        elif self.mesh.dim == 3:
-            X = self.mesh.gridCC[:,0]
-            Y = self.mesh.gridCC[:,1]
-            Z = self.mesh.gridCC[:,2]
-            if self.normal =='X':
-                zb = self.ptsv[0]
-                zt = self.ptsv[1]
-                flines = (self.spl["splt"](Y)-self.spl["splb"](Y))*(Z-zb)/(zt-zb) + self.spl["splb"](Y)
-                f = flines - X
-            # elif self.normal =='Y':
-            # elif self.normal =='Z':
-            else:
-                raise(Exception("Not Implemented for Y and Z, your turn :)"))
-
-        if self.logSigma:
-            g1 = -(np.arctan(alpha*f)/np.pi + 0.5)*sig1 + sig1
-            g2 = (np.arctan(alpha*f)/np.pi + 0.5)*sig2
-        else:
-            g1 = -(np.arctan(alpha*f)/np.pi + 0.5) + 1.0
-            g2 = (np.arctan(alpha*f)/np.pi + 0.5)
-
-
-        if self.mesh.dim ==2:
-            g3 = np.zeros((self.mesh.nC, self.npts))
-            if self.normal =='Y':
-                # Here we use perturbation to compute sensitivity
-                # TODO: bit more generalization of this ...
-                # Modfications for X and Z directions ...
-                for i in range(np.size(self.pts)):
-                    ctemp = c[i]
-                    ind = np.argmin(abs(self.mesh.vectorCCy-ctemp))
-                    ca = c.copy()
-                    cb = c.copy()
-                    dy = self.mesh.hy[ind]*1.5
-                    ca[i] = ctemp+dy
-                    cb[i] = ctemp-dy
-                    spla = UnivariateSpline(self.pts, ca, k=self.order, s=0)
-                    splb = UnivariateSpline(self.pts, cb, k=self.order, s=0)
-                    fderiv = (spla(X)-splb(X))/(2*dy)
-                    g3[:,i] = Utils.sdiag(alpha*(sig2-sig1)/(1.+(alpha*f)**2)/np.pi)*fderiv
-
-        elif self.mesh.dim==3:
-            g3 = np.zeros((self.mesh.nC, self.npts*2))
-            if self.normal =='X':
-                # Here we use perturbation to compute sensitivity
-                for i in range(self.npts*2):
-                    ctemp = c[i]
-                    ind = np.argmin(abs(self.mesh.vectorCCy-ctemp))
-                    ca = c.copy()
-                    cb = c.copy()
-                    dy = self.mesh.hy[ind]*1.5
-                    ca[i] = ctemp+dy
-                    cb[i] = ctemp-dy
-                    #treat bottom boundary
-                    if i< self.npts:
-                        splba = UnivariateSpline(self.pts, ca[:self.npts], k=self.order, s=0)
-                        splbb = UnivariateSpline(self.pts, cb[:self.npts], k=self.order, s=0)
-                        flinesa = (self.spl["splt"](Y)-splba(Y))*(Z-zb)/(zt-zb) + splba(Y) - X
-                        flinesb = (self.spl["splt"](Y)-splbb(Y))*(Z-zb)/(zt-zb) + splbb(Y) - X
-                    #treat top boundary
-                    else:
-                        splta = UnivariateSpline(self.pts, ca[self.npts:], k=self.order, s=0)
-                        spltb = UnivariateSpline(self.pts, ca[self.npts:], k=self.order, s=0)
-                        flinesa = (self.spl["splt"](Y)-splta(Y))*(Z-zb)/(zt-zb) + splta(Y) - X
-                        flinesb = (self.spl["splt"](Y)-spltb(Y))*(Z-zb)/(zt-zb) + spltb(Y) - X
-                    fderiv = (flinesa-flinesb)/(2*dy)
-                    g3[:,i] = Utils.sdiag(alpha*(sig2-sig1)/(1.+(alpha*f)**2)/np.pi)*fderiv
-        else :
-            raise(Exception("Not Implemented for Y and Z, your turn :)"))
-        return sp.csr_matrix(np.c_[g1,g2,g3])
-
-
-
-
-
-
+        return np.c_[g1,g2,g3,g4,g5]

SimPEG/Mesh/BaseMesh.py

@@ -27,7 +27,6 @@ class BaseMesh(object):
         # Ensure x0 & n are 1D vectors
         self._n = np.array(n, dtype=int).ravel()
         self._x0 = np.array(x0, dtype=float).ravel()
-        self._dim = len(self._x0)
 
     @property
     def x0(self):
@@ -47,7 +46,7 @@ class BaseMesh(object):
         :rtype: int
         :return: dim
         """
-        return self._dim
+        return len(self._n)
 
     @property
     def nC(self):

SimPEG/Mesh/CylMesh.py

@@ -2,12 +2,12 @@ import numpy as np
 import scipy.sparse as sp
 from scipy.constants import pi
 from SimPEG.Utils import mkvc, ndgrid, sdiag, kron3, speye, spzeros, ddx, av, avExtrap
-from TensorMesh import BaseTensorMesh, BaseRectangularMesh
+from TensorMesh import BaseTensorMesh
 from InnerProducts import InnerProducts
 from View import CylView
 
 
-class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
+class CylMesh(BaseTensorMesh, InnerProducts, CylView):
     """
         CylMesh is a mesh class for cylindrical problems
 

SimPEG/Mesh/DiffOperators.py

@@ -307,28 +307,24 @@ class DiffOperators(object):
         return BC
     _cellGradBC_list = 'neumann'
 
-    def _cellGradStencil(self):
-        BC = self.setCellGradBC(self._cellGradBC_list)
-        n = self.vnC
-        if(self.dim == 1):
-            G = ddxCellGrad(n[0], BC[0])
-        elif(self.dim == 2):
-            G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC[0]))
-            G2 = sp.kron(ddxCellGrad(n[1], BC[1]), speye(n[0]))
-            G = sp.vstack((G1, G2), format="csr")
-        elif(self.dim == 3):
-            G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC[0]))
-            G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC[1]), speye(n[0]))
-            G3 = kron3(ddxCellGrad(n[2], BC[2]), speye(n[1]), speye(n[0]))
-            G = sp.vstack((G1, G2, G3), format="csr")
-        return G
-
     def cellGrad():
         doc = "The cell centered Gradient, takes you to cell faces."
 
         def fget(self):
             if(self._cellGrad is None):
-                G = self._cellGradStencil()
+                BC = self.setCellGradBC(self._cellGradBC_list)
+                n = self.vnC
+                if(self.dim == 1):
+                    G = ddxCellGrad(n[0], BC[0])
+                elif(self.dim == 2):
+                    G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC[0]))
+                    G2 = sp.kron(ddxCellGrad(n[1], BC[1]), speye(n[0]))
+                    G = sp.vstack((G1, G2), format="csr")
+                elif(self.dim == 3):
+                    G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC[0]))
+                    G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC[1]), speye(n[0]))
+                    G3 = kron3(ddxCellGrad(n[2], BC[2]), speye(n[1]), speye(n[0]))
+                    G = sp.vstack((G1, G2, G3), format="csr")
                 # Compute areas of cell faces & volumes
                 S = self.area
                 V = self.aveCC2F*self.vol  # Average volume between adjacent cells
@@ -365,24 +361,19 @@ class DiffOperators(object):
     _cellGradBC = None
     cellGradBC = property(**cellGradBC())
 
-    def _cellGradxStencil(self):
-        BC = ['neumann', 'neumann']
-        n = self.vnC
-        if(self.dim == 1):
-            G1 = ddxCellGrad(n[0], BC)
-        elif(self.dim == 2):
-            G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC))
-        elif(self.dim == 3):
-            G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC))
-        return G1
-
-
     def cellGradx():
         doc = "Cell centered Gradient in the x dimension. Has neumann boundary conditions."
 
         def fget(self):
             if getattr(self, '_cellGradx', None) is None:
-                G1 = self._cellGradxStencil()
+                BC = ['neumann', 'neumann']
+                n = self.vnC
+                if(self.dim == 1):
+                    G1 = ddxCellGrad(n[0], BC)
+                elif(self.dim == 2):
+                    G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC))
+                elif(self.dim == 3):
+                    G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC))
                 # Compute areas of cell faces & volumes
                 V = self.aveCC2F*self.vol
                 L = self.r(self.area/V, 'F','Fx', 'V')
@@ -391,22 +382,17 @@ class DiffOperators(object):
         return locals()
     cellGradx = property(**cellGradx())
 
-    def _cellGradyStencil(self):
-        if self.dim < 2: return None
-        BC = ['neumann', 'neumann']
-        n = self.vnC
-        if(self.dim == 2):
-            G2 = sp.kron(ddxCellGrad(n[1], BC), speye(n[0]))
-        elif(self.dim == 3):
-            G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC), speye(n[0]))
-        return G2
-
     def cellGrady():
         doc = "Cell centered Gradient in the x dimension. Has neumann boundary conditions."
         def fget(self):
             if self.dim < 2: return None
             if getattr(self, '_cellGrady', None) is None:
-                G2 = self._cellGradyStencil()
+                BC = ['neumann', 'neumann']
+                n = self.vnC
+                if(self.dim == 2):
+                    G2 = sp.kron(ddxCellGrad(n[1], BC), speye(n[0]))
+                elif(self.dim == 3):
+                    G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC), speye(n[0]))
                 # Compute areas of cell faces & volumes
                 V = self.aveCC2F*self.vol
                 L = self.r(self.area/V, 'F','Fy', 'V')
@@ -415,19 +401,14 @@ class DiffOperators(object):
         return locals()
     cellGrady = property(**cellGrady())
 
-    def _cellGradzStencil(self):
-        if self.dim < 3: return None
-        BC = ['neumann', 'neumann']
-        n = self.vnC
-        G3 = kron3(ddxCellGrad(n[2], BC), speye(n[1]), speye(n[0]))
-        return G3
-
     def cellGradz():
         doc = "Cell centered Gradient in the x dimension. Has neumann boundary conditions."
         def fget(self):
             if self.dim < 3: return None
             if getattr(self, '_cellGradz', None) is None:
-                G3 = self._cellGradzStencil()
+                BC = ['neumann', 'neumann']
+                n = self.vnC
+                G3 = kron3(ddxCellGrad(n[2], BC), speye(n[1]), speye(n[0]))
                 # Compute areas of cell faces & volumes
                 V = self.aveCC2F*self.vol
                 L = self.r(self.area/V, 'F','Fz', 'V')
@@ -765,3 +746,4 @@ class DiffOperators(object):
                                           kron3(av(n[2]), speye(n[1]+1), av(n[0])),
                                           kron3(speye(n[2]+1), av(n[1]), av(n[0]))), format="csr")
         return self._aveN2F
+

SimPEG/Mesh/MeshIO.py

@@ -1,415 +0,0 @@
-import numpy as np, os
-from SimPEG import Utils
-
-class TensorMeshIO(object):
-
-    @classmethod
-    def readUBC(TensorMesh, fileName):
-        """
-            Read UBC GIF 3DTensor mesh and generate 3D Tensor mesh in simpegTD
-
-            Input:
-            :param fileName, path to the UBC GIF mesh file
-
-            Output:
-            :param SimPEG TensorMesh object
-        """
-
-        # Interal function to read cell size lines for the UBC mesh files.
-        def readCellLine(line):
-            for seg in line.split():
-                if '*' in seg:
-                    st = seg
-                    sp = seg.split('*')
-                    re = int(sp[0])*(' ' + sp[1])
-                    line = line.replace(st,re.strip())
-            return np.array(line.split(),dtype=float)
-        # Read the file as line strings, remove lines with comment = !
-        msh = np.genfromtxt(fileName,delimiter='\n',dtype=np.str,comments='!')
-
-        # Fist line is the size of the model
-        sizeM = np.array(msh[0].split(),dtype=float)
-        # Second line is the South-West-Top corner coordinates.
-        x0 = np.array(msh[1].split(),dtype=float)
-        # Read the cell sizes
-        h1 = readCellLine(msh[2])
-        h2 = readCellLine(msh[3])
-        h3temp = readCellLine(msh[4])
-        h3 = h3temp[::-1] # Invert the indexing of the vector to start from the bottom.
-        # Adjust the reference point to the bottom south west corner
-        x0[2] = x0[2] - np.sum(h3)
-        # Make the mesh
-        tensMsh = TensorMesh([h1,h2,h3],x0)
-        return tensMsh
-
-    @classmethod
-    def readVTK(TensorMesh, fileName):
-        """
-            Read VTK Rectilinear (vtr xml file) and return SimPEG Tensor mesh and model
-
-            Input:
-            :param vtrFileName, path to the vtr model file to write to
-
-            Output:
-            :return SimPEG TensorMesh object
-            :return SimPEG model dictionary
-
-        """
-        # Import
-        from vtk import vtkXMLRectilinearGridReader as vtrFileReader
-        from vtk.util.numpy_support import vtk_to_numpy
-
-        # Read the file
-        vtrReader = vtrFileReader()
-        vtrReader.SetFileName(fileName)
-        vtrReader.Update()
-        vtrGrid = vtrReader.GetOutput()
-        # Sort information
-        hx = np.abs(np.diff(vtk_to_numpy(vtrGrid.GetXCoordinates())))
-        xR = vtk_to_numpy(vtrGrid.GetXCoordinates())[0]
-        hy = np.abs(np.diff(vtk_to_numpy(vtrGrid.GetYCoordinates())))
-        yR = vtk_to_numpy(vtrGrid.GetYCoordinates())[0]
-        zD = np.diff(vtk_to_numpy(vtrGrid.GetZCoordinates()))
-        # Check the direction of hz
-        if np.all(zD < 0):
-            hz = np.abs(zD[::-1])
-            zR = vtk_to_numpy(vtrGrid.GetZCoordinates())[-1]
-        else:
-            hz = np.abs(zD)
-            zR = vtk_to_numpy(vtrGrid.GetZCoordinates())[0]
-        x0 = np.array([xR,yR,zR])
-
-        # Make the SimPEG object
-        tensMsh = TensorMesh([hx,hy,hz],x0)
-
-        # Grap the models
-        models = {}
-        for i in np.arange(vtrGrid.GetCellData().GetNumberOfArrays()):
-            modelName = vtrGrid.GetCellData().GetArrayName(i)
-            if np.all(zD < 0):
-                modFlip = vtk_to_numpy(vtrGrid.GetCellData().GetArray(i))
-                tM = tensMsh.r(modFlip,'CC','CC','M')
-                modArr = tensMsh.r(tM[:,:,::-1],'CC','CC','V')
-            else:
-                modArr = vtk_to_numpy(vtrGrid.GetCellData().GetArray(i))
-            models[modelName] = modArr
-
-        # Return the data
-        return tensMsh, models
-
-    def writeVTK(mesh, fileName, models=None):
-        """
-        Makes and saves a VTK rectilinear file (vtr) for a simpeg Tensor mesh and model.
-
-        Input:
-        :param str, path to the output vtk file
-        :param mesh, SimPEG TensorMesh object - mesh to be transfer to VTK
-        :param models, dictionary of numpy.array - Name('s) and array('s). Match number of cells
-
-        """
-        # Import
-        from vtk import vtkRectilinearGrid as rectGrid, vtkXMLRectilinearGridWriter as rectWriter, VTK_VERSION
-        from vtk.util.numpy_support import numpy_to_vtk
-
-        # Deal with dimensionalities
-        if mesh.dim >= 1:
-            vX = mesh.vectorNx
-            xD = mesh.nNx
-            yD,zD = 1,1
-            vY, vZ = np.array([0,0])
-        if mesh.dim >= 2:
-            vY = mesh.vectorNy
-            yD = mesh.nNy
-        if mesh.dim == 3:
-            vZ = mesh.vectorNz
-            zD = mesh.nNz
-        # Use rectilinear VTK grid.
-        # Assign the spatial information.
-        vtkObj = rectGrid()
-        vtkObj.SetDimensions(xD,yD,zD)
-        vtkObj.SetXCoordinates(numpy_to_vtk(vX,deep=1))
-        vtkObj.SetYCoordinates(numpy_to_vtk(vY,deep=1))
-        vtkObj.SetZCoordinates(numpy_to_vtk(vZ,deep=1))
-
-        # Assign the model('s) to the object
-        if models is not None:
-            for item in models.iteritems():
-                # Convert numpy array
-                vtkDoubleArr = numpy_to_vtk(item[1],deep=1)
-                vtkDoubleArr.SetName(item[0])
-                vtkObj.GetCellData().AddArray(vtkDoubleArr)
-            # Set the active scalar
-            vtkObj.GetCellData().SetActiveScalars(models.keys()[0])
-        # vtkObj.Update()
-
-        # Check the extension of the fileName
-        ext = os.path.splitext(fileName)[1]
-        if ext is '':
-            fileName = fileName + '.vtr'
-        elif ext not in '.vtr':
-            raise IOError('{:s} is an incorrect extension, has to be .vtr')
-        # Write the file.
-        vtrWriteFilter = rectWriter()
-        if float(VTK_VERSION.split('.')[0]) >=6:
-            vtrWriteFilter.SetInputData(vtkObj)
-        else:
-            vtuWriteFilter.SetInput(vtuObj)
-        vtrWriteFilter.SetFileName(fileName)
-        vtrWriteFilter.Update()
-
-
-    def readModelUBC(mesh, fileName):
-        """
-            Read UBC 3DTensor mesh model and generate 3D Tensor mesh model in simpeg
-
-            Input:
-            :param fileName, path to the UBC GIF mesh file to read
-            :param mesh, TensorMesh object, mesh that coresponds to the model
-
-            Output:
-            :return numpy array, model with TensorMesh ordered
-        """
-        f = open(fileName, 'r')
-        model = np.array(map(float, f.readlines()))
-        f.close()
-        model = np.reshape(model, (mesh.nCz, mesh.nCx, mesh.nCy), order = 'F')
-        model = model[::-1,:,:]
-        model = np.transpose(model, (1, 2, 0))
-        model = Utils.mkvc(model)
-        return model
-
-    def writeModelUBC(mesh, fileName, model):
-        """
-            Writes a model associated with a SimPEG TensorMesh
-            to a UBC-GIF format model file.
-
-            :param str fileName: File to write to
-            :param simpeg.Mesh.TensorMesh mesh: The mesh
-            :param numpy.ndarray model: The model
-        """
-
-        # Reshape model to a matrix
-        modelMat = mesh.r(model,'CC','CC','M')
-        # Transpose the axes
-        modelMatT = modelMat.transpose((2,0,1))
-        # Flip z to positive down
-        modelMatTR = Utils.mkvc(modelMatT[::-1,:,:])
-
-        np.savetxt(fileName, modelMatTR.ravel())
-
-    def writeUBC(mesh, fileName, models=None):
-        """
-            Writes a SimPEG TensorMesh to a UBC-GIF format mesh file.
-
-            :param str fileName: File to write to
-            :param simpeg.Mesh.TensorMesh mesh: The mesh
-
-        """
-        assert mesh.dim == 3
-        s = ''
-        s += '%i %i %i\n' %tuple(mesh.vnC)
-        origin = mesh.x0 + np.array([0,0,mesh.hz.sum()]) # Have to it in the same operation or use mesh.x0.copy(), otherwise the mesh.x0 is updated.
-        origin.dtype = float
-
-        s += '%.2f %.2f %.2f\n' %tuple(origin)
-        s += ('%.2f '*mesh.nCx+'\n')%tuple(mesh.hx)
-        s += ('%.2f '*mesh.nCy+'\n')%tuple(mesh.hy)
-        s += ('%.2f '*mesh.nCz+'\n')%tuple(mesh.hz[::-1])
-        f = open(fileName, 'w')
-        f.write(s)
-        f.close()
-
-        if models is None: return
-        assert type(models) is dict, 'models must be a dict'
-        for key in models:
-            assert type(key) is str, 'The dict key is a file name'
-            mesh.writeModelUBC(key, models[key])
-
-class TreeMeshIO(object):
-
-    def writeUBC(mesh, fileName, models=None):
-        """
-            Write UBC ocTree mesh and model files from a simpeg ocTree mesh and model.
-
-            :param str fileName: File to write to
-            :param simpeg.Mesh.TreeMesh mesh: The mesh
-            :param dictionary models: The models in a dictionary, where the keys is the name of the of the model file
-        """
-
-        # Calculate information to write in the file.
-        # Number of cells in the underlying mesh
-        nCunderMesh = np.array([h.size for h in mesh.h],dtype=np.int64)
-        # The top-south-west most corner of the mesh
-        tswCorn = mesh.x0 + np.array([0,0,np.sum(mesh.h[2])])
-        # Smallest cell size
-        smallCell = np.array([h.min() for h in mesh.h])
-        # Number of cells
-        nrCells = mesh.nC
-
-        ## Extract iformation about the cells.
-        # cell pointers
-        cellPointers = np.array([c._pointer for c in mesh])
-        # cell with
-        cellW = np.array([ mesh._levelWidth(i) for i in cellPointers[:,-1] ])
-        # Need to shift the pointers to work with UBC indexing
-        # UBC Octree indexes always the top-left-close (top-south-west) corner first and orders the cells in z(top-down),x,y vs x,y,z(bottom-up).
-        # Shift index up by 1
-        ubcCellPt = cellPointers[:,0:-1].copy() + np.array([1.,1.,1.])
-        # Need reindex the z index to be from the top-left-close corner and to be from the global top.
-        ubcCellPt[:,2] = ( nCunderMesh[-1] + 2) - (ubcCellPt[:,2] + cellW)
-
-        # Reorder the ubcCellPt
-        ubcReorder = np.argsort(ubcCellPt.view(','.join(3*['float'])),axis=0,order=['f2','f1','f0'])[:,0]
-        # Make a array with the pointers and the withs, that are order in the ubc ordering
-        indArr = np.concatenate((ubcCellPt[ubcReorder,:],cellW[ubcReorder].reshape((-1,1)) ),axis=1)
-
-        ## Write the UBC octree mesh file
-        with open(fileName,'w') as mshOut:
-            mshOut.write('{:.0f} {:.0f} {:.0f}\n'.format(nCunderMesh[0],nCunderMesh[1],nCunderMesh[2]))
-            mshOut.write('{:.4f} {:.4f} {:.4f}\n'.format(tswCorn[0],tswCorn[1],tswCorn[2]))
-            mshOut.write('{:.3f} {:.3f} {:.3f}\n'.format(smallCell[0],smallCell[1],smallCell[2]))
-            mshOut.write('{:.0f} \n'.format(nrCells))
-            np.savetxt(mshOut,indArr,fmt='%i')
-
-        ## Print the models
-        # Assign the model('s) to the object
-        if models is not None:
-            # indUBCvector = np.argsort(cX0[np.argsort(np.concatenate((cX0[:,0:2],cX0[:,2:3].max() - cX0[:,2:3]),axis=1).view(','.join(3*['float'])),axis=0,order=('f2','f1','f0'))[:,0]].view(','.join(3*['float'])),axis=0,order=('f2','f1','f0'))[:,0]
-            for item in models.iteritems():
-                # Save the data
-                np.savetxt(item[0],item[1][ubcReorder],fmt='%3.5e')
-
-    @classmethod
-    def readUBC(TreeMesh, meshFile):
-        """
-            Read UBC 3D OcTree mesh and/or modelFiles
-
-            Input:
-            :param str meshFile: path to the UBC GIF OcTree mesh file to read
-
-            Output:
-            :return SimPEG.Mesh.TreeMesh mesh: The octree mesh
-            :return list of ndarray's: models as a list of numpy array's
-        """
-
-        ## Read the file lines
-        fileLines = np.genfromtxt(meshFile,dtype=str,delimiter='\n')
-        # Extract the data
-        nCunderMesh = np.array(fileLines[0].split(),dtype=float)
-        # I think this is the case?
-        if np.unique(nCunderMesh).size >1:
-            raise Exception('SimPEG TreeMeshes have the same number of cell in all directions')
-        tswCorn = np.array(fileLines[1].split(),dtype=float)
-        smallCell = np.array(fileLines[2].split(),dtype=float)
-        nrCells = np.array(fileLines[3].split(),dtype=float)
-        # Read the index array
-        indArr = np.genfromtxt(fileLines[4::],dtype=np.int)
-
-        ## Calculate simpeg parameters
-        h1,h2,h3 = [np.ones(nr)*sz for nr,sz in zip(nCunderMesh,smallCell)]
-        x0 = tswCorn - np.array([0,0,np.sum(h3)])
-        # Need to convert the index array to a points list that complies with SimPEG TreeMesh.
-        # Shift to start at 0
-        simpegCellPt = indArr[:,0:-1].copy()
-        simpegCellPt[:,2] = ( nCunderMesh[-1] + 2) - (simpegCellPt[:,2] + indArr[:,3])
-        # Need reindex the z index to be from the bottom-left-close corner and to be from the global bottom.
-        simpegCellPt = simpegCellPt - np.array([1.,1.,1.])
-
-        # Calculate the cell level
-        simpegLevel = np.log2(np.min(nCunderMesh)) - np.log2(indArr[:,3])
-        # Make a pointer matrix
-        simpegPointers = np.concatenate((simpegCellPt,simpegLevel.reshape((-1,1))),axis=1)
-
-        ## Make the tree mesh
-        mesh = TreeMesh([h1,h2,h3],x0)
-        mesh._cells = set([mesh._index(p) for p in simpegPointers.tolist()])
-
-        # Figure out the reordering
-        mesh._simpegReorderUBC = np.argsort(np.array([mesh._index(i) for i in simpegPointers.tolist()]))
-        # mesh._simpegReorderUBC = np.argsort((np.array([[1,1,1,-1]])*simpegPointers).view(','.join(4*['float'])),axis=0,order=['f3','f2','f1','f0'])[:,0]
-
-        return mesh
-
-
-    def readModelUBC(mesh, fileName):
-        """
-            Read UBC OcTree model and get vector
-
-            Input:
-            :param fileName, path to the UBC GIF model file to read
-
-            Output:
-            :return numpy array, OcTree model
-        """
-
-        if type(fileName) is list:
-            out = {}
-            for f in fileName:
-                out[f] = mesh.readModelUBC(f)
-            return out
-
-        assert hasattr(mesh, '_simpegReorderUBC'), 'The file must have been loaded from a UBC format.'
-        assert mesh.dim == 3
-
-        modList = []
-        modArr = np.loadtxt(fileName)
-        if len(modArr.shape) == 1:
-            modList.append(modArr[mesh._simpegReorderUBC])
-        else:
-            modList.append(modArr[mesh._simpegReorderUBC,:])
-        return modList
-
-    def writeVTK(mesh, fileName, models=None):
-        """
-        Function to write a VTU file from a SimPEG TreeMesh and model.
-        """
-        import vtk
-        from vtk import vtkXMLUnstructuredGridWriter as Writer, VTK_VERSION
-        from vtk.util.numpy_support import numpy_to_vtk, numpy_to_vtkIdTypeArray
-
-        if str(type(mesh)).split()[-1][1:-2] not in 'SimPEG.Mesh.TreeMesh.TreeMesh':
-            raise IOError('mesh is not a SimPEG TreeMesh.')
-
-        # Make the data parts for the vtu object
-        # Points
-        mesh.number()
-        ptsMat = mesh._gridN + mesh.x0
-
-        vtkPts = vtk.vtkPoints()
-        vtkPts.SetData(numpy_to_vtk(ptsMat,deep=True))
-        # Cells
-        cellConn = np.array([c.nodes for c in mesh],dtype=np.int64)
-
-        cellsMat = np.concatenate((np.ones((cellConn.shape[0],1),dtype=np.int64)*cellConn.shape[1],cellConn),axis=1).ravel()
-        cellsArr = vtk.vtkCellArray()
-        cellsArr.SetNumberOfCells(cellConn.shape[0])
-        cellsArr.SetCells(cellConn.shape[0],numpy_to_vtkIdTypeArray(cellsMat,deep=True))
-
-        # Make the object
-        vtuObj = vtk.vtkUnstructuredGrid()
-        vtuObj.SetPoints(vtkPts)
-        vtuObj.SetCells(vtk.VTK_VOXEL,cellsArr)
-        # Add the level of refinement as a cell array
-        cellSides = np.array([np.array(vtuObj.GetCell(i).GetBounds()).reshape((3,2)).dot(np.array([-1, 1])) for i in np.arange(vtuObj.GetNumberOfCells())])
-        uniqueLevel, indLevel = np.unique(np.prod(cellSides,axis=1),return_inverse=True)
-        refineLevelArr = numpy_to_vtk(indLevel.max() - indLevel,deep=1)
-        refineLevelArr.SetName('octreeLevel')
-        vtuObj.GetCellData().AddArray(refineLevelArr)
-        # Assign the model('s) to the object
-        if models is not None:
-            for item in models.iteritems():
-                # Convert numpy array
-                vtkDoubleArr = numpy_to_vtk(item[1],deep=1)
-                vtkDoubleArr.SetName(item[0])
-                vtuObj.GetCellData().AddArray(vtkDoubleArr)
-
-        # Make the writer
-        vtuWriteFilter = Writer()
-        if float(VTK_VERSION.split('.')[0]) >=6:
-            vtuWriteFilter.SetInputData(vtuObj)
-        else:
-            vtuWriteFilter.SetInput(vtuObj)
-        vtuWriteFilter.SetFileName(fileName)
-        # Write the file
-        vtuWriteFilter.Update()
-

SimPEG/Mesh/TreeUtils.pyx

@@ -1,85 +0,0 @@
-# from __future__ import division
-# import numpy as np
-# cimport numpy as np
-# from libcpp.vector cimport vector
-
-
-"""
-    The Z-order curve is generated by interleaving the bits of an offset.
-
-    See also:
-
-        https://github.com/cortesi/scurve
-        Aldo Cortesi <aldo@corte.si>
-
-"""
-
-def bitrange(long x, int width, int start, int end):
-    """
-        Extract a bit range as an integer.
-        (start, end) is inclusive lower bound, exclusive upper bound.
-    """
-    return x >> (width-end) & ((2**(end-start))-1)
-
-def index(int dimension, int bits, int levelBits, list p, int level):
-    cdef long idx = 0
-    cdef int iwidth
-    cdef int i
-    cdef long b
-    cdef int bitoff
-
-    p = [_ for _ in p]
-
-    p.reverse()
-    iwidth = bits * dimension
-    for i in range(iwidth):
-        bitoff = bits-(i/dimension)-1
-        poff = dimension-(i%dimension)-1
-        b = bitrange(p[poff], bits, bitoff, bitoff+1) << i
-        idx |= b
-
-    return (idx << levelBits) + level
-
-def point(int dimension, int bits, int levelBits, long idx):
-    cdef list p
-    cdef int iwidth
-    cdef int i, n
-    cdef long b
-
-    n   = idx & (2**levelBits-1)
-    idx = idx >> levelBits
-
-    p = [0]*dimension
-    iwidth = bits * dimension
-    for i in range(iwidth):
-        b = bitrange(idx, iwidth, i, i+1) << (iwidth-i-1)/dimension
-        p[i%dimension] |= b
-    p.reverse()
-    return p + [n]
-
-
-# def _refineCell(int dimension, int bits, self, pointer):
-#     self._structureChange()
-#     pointer = self._asPointer(pointer)
-#     ind = self._asIndex(pointer)
-#     assert ind in self
-#     h = self._levelWidth(pointer[-1])/2 # halfWidth
-#     nL = pointer[-1] + 1 # new level
-#     add = lambda p:p[0]+p[1]
-#     added = []
-#     def addCell(p):
-#         i = self._index(p+[nL])
-#         self._treeInds.add(i)
-#         added.append(i)
-
-#     addCell(map(add, zip(pointer[:-1], [0,0,0])))
-#     addCell(map(add, zip(pointer[:-1], [h,0,0])))
-#     addCell(map(add, zip(pointer[:-1], [0,h,0])))
-#     addCell(map(add, zip(pointer[:-1], [h,h,0])))
-#     if self.dim == 3:
-#         addCell(map(add, zip(pointer[:-1], [0,0,h])))
-#         addCell(map(add, zip(pointer[:-1], [h,0,h])))
-#         addCell(map(add, zip(pointer[:-1], [0,h,h])))
-#         addCell(map(add, zip(pointer[:-1], [h,h,h])))
-#     self._treeInds.remove(ind)
-#     return added

SimPEG/Mesh/View.py

@@ -1,11 +1,8 @@
 import numpy as np
-from SimPEG.Utils import mkvc
-try:
-    import matplotlib.pyplot as plt
-    import matplotlib
-    from mpl_toolkits.mplot3d import Axes3D
-except ImportError, e:
-    print 'Trouble importing matplotlib.'
+import matplotlib.pyplot as plt
+import matplotlib
+from mpl_toolkits.mplot3d import Axes3D
+from SimPEG.Utils import mkvc, animate
 
 
 class TensorView(object):
@@ -42,9 +39,9 @@ class TensorView(object):
 
     def plotImage(self, v, vType='CC', grid=False, view='real',
               ax=None, clim=None, showIt=False,
-              pcolorOpts=None,
-              streamOpts=None,
-              gridOpts=None,
+              pcolorOpts={},
+              streamOpts={'color':'k'},
+              gridOpts={'color':'k'},
               numbering=True, annotationColor='w'
               ):
         """
@@ -84,12 +81,6 @@ class TensorView(object):
             M.plotImage(v, annotationColor='k', showIt=True)
 
         """
-        if pcolorOpts is None:
-            pcolorOpts = {}
-        if streamOpts is None:
-            streamOpts = {'color':'k'}
-        if gridOpts is None:
-            gridOpts = {'color':'k'}
 
         if ax is None:
             fig = plt.figure()
@@ -180,9 +171,9 @@ class TensorView(object):
     def plotSlice(self, v, vType='CC',
                   normal='Z', ind=None, grid=False, view='real',
                   ax=None, clim=None, showIt=False,
-                  pcolorOpts=None,
-                  streamOpts=None,
-                  gridOpts=None
+                  pcolorOpts={},
+                  streamOpts={'color':'k'},
+                  gridOpts={'color':'k'}
                   ):
 
         """
@@ -203,12 +194,6 @@ class TensorView(object):
             M.plotSlice(M.cellGrad*b, 'F', view='vec', grid=True, showIt=True, pcolorOpts={'alpha':0.8})
 
         """
-        if pcolorOpts is None:
-            pcolorOpts = {}
-        if streamOpts is None:
-            streamOpts = {'color':'k'}
-        if gridOpts is None:
-            gridOpts = {'color':'k', 'alpha':0.5}
         if type(vType) in [list, tuple]:
             assert ax is None, "cannot specify an axis to plot on with this function."
             fig, axs = plt.subplots(1,len(vType))
@@ -231,7 +216,6 @@ class TensorView(object):
         if ind is None: ind = int(szSliceDim/2)
         assert type(ind) in [int, long], 'ind must be an integer'
 
-        assert not (v.dtype == complex and view == 'vec'), 'Can not plot a complex vector.'
         # The slicing and plotting code!!
 
         def getIndSlice(v):
@@ -301,17 +285,11 @@ class TensorView(object):
 
     def _plotImage2D(self, v, vType='CC', grid=False, view='real',
               ax=None, clim=None, showIt=False,
-              pcolorOpts=None,
-              streamOpts=None,
-              gridOpts=None
+              pcolorOpts={},
+              streamOpts={'color':'k'},
+              gridOpts={'color':'k'}
               ):
 
-        if pcolorOpts is None:
-            pcolorOpts = {}
-        if streamOpts is None:
-            streamOpts = {'color':'k'}
-        if gridOpts is None:
-            gridOpts = {'color':'k'}
         vTypeOptsCC = ['N','CC','Fx','Fy','Ex','Ey']
         vTypeOptsV = ['CCv','F','E']
         vTypeOpts = vTypeOptsCC + vTypeOptsV
@@ -500,6 +478,63 @@ class TensorView(object):
         ax.grid(True)
         if showIt: plt.show()
 
+    def slicer(mesh, var, imageType='CC', normal='z', index=0, ax=None, clim=None):
+        assert normal in 'xyz', 'normal must be x, y, or z'
+        if ax is None: ax = plt.subplot(111)
+        I = mesh.r(var,'CC','CC','M')
+        axes = [p for p in 'xyz' if p not in normal.lower()]
+        if normal is 'x': I = I[index,:,:]
+        if normal is 'y': I = I[:,index,:]
+        if normal is 'z': I = I[:,:,index]
+        if clim is None: clim = [I.min(),I.max()]
+        p = ax.pcolormesh(getattr(mesh,'vectorN'+axes[0]),getattr(mesh,'vectorN'+axes[1]),I.T,vmin=clim[0],vmax=clim[1])
+        ax.axis('tight')
+        ax.set_xlabel(axes[0])
+        ax.set_ylabel(axes[1])
+        return p
+
+    def videoSlicer(mesh,var,imageType='CC',normal='z',figsize=(10,8)):
+        assert mesh.dim > 2, 'This is for 3D meshes only.'
+        # First set up the figure, the axis, and the plot element we want to animate
+        fig = plt.figure(figsize=figsize)
+        ax = plt.axes()
+        clim = [var.min(),var.max()]
+        plt.colorbar(mesh.slicer(var, imageType=imageType, normal=normal, index=0, ax=ax, clim=clim))
+        tlt = plt.title(normal)
+
+        def animateFrame(i):
+            mesh.slicer(var, imageType=imageType, normal=normal, index=i, ax=ax, clim=clim)
+            tlt.set_text(normal.upper()+('-Slice: %d, %4.4f' % (i,getattr(mesh,'vectorCC'+normal)[i])))
+
+        return animate(fig, animateFrame, frames=mesh.vnC['xyz'.index(normal)])
+
+    def video(mesh, var, function, figsize=(10, 8), colorbar=True, skip=1):
+        """
+        Call a function for a list of models to create a video.
+
+        ::
+
+            def function(var, ax, clim, tlt, i):
+                tlt.set_text('%d'%i)
+                return mesh.plotImage(var, imageType='CC', ax=ax, clim=clim)
+
+            mesh.video([model1, model2, ..., modeln],function)
+        """
+        # First set up the figure, the axis, and the plot element we want to animate
+        fig = plt.figure(figsize=figsize)
+        ax = plt.axes()
+        VAR = np.concatenate(var)
+        clim = [VAR.min(),VAR.max()]
+        tlt = plt.title('')
+        if colorbar:
+            plt.colorbar(function(var[0],ax,clim,tlt,0))
+
+        frames = np.arange(0,len(var),skip)
+        def animateFrame(j):
+            i = frames[j]
+            function(var[i],ax,clim,tlt,i)
+
+        return animate(fig, animateFrame, frames=len(frames))
 
 class CylView(object):
 

SimPEG/Optimization.py

@@ -888,8 +888,6 @@ class ProjectedGNCG(BFGS, Minimize, Remember):
     maxIterCG = 5
     tolCG = 1e-1
 
-    stepOffBoundsFact = 0.1 # perturbation of the inactive set off the bounds
-
     lower = -np.inf
     upper = np.inf
 
@@ -992,20 +990,4 @@ class ProjectedGNCG(BFGS, Minimize, Remember):
                     cgFlag = 1
                 # End CG Iterations
 
-            # Take a gradient step on the active cells if exist
-            if temp != self.xc.size:
-
-                rhs_a = (Active) * -self.g
-
-                dm_i = max( abs( delx ) )
-                dm_a = max( abs(rhs_a) )
-
-                # perturb inactive set off of bounds so that they are included in the step
-                delx = delx + self.stepOffBoundsFact * (rhs_a * dm_i / dm_a)
-
-
-            # Only keep gradients going in the right direction on the active set
-            indx = ((self.xc<=self.lower) & (delx < 0)) | ((self.xc>=self.upper) & (delx > 0))
-            delx[indx] = 0.
-
             return delx

SimPEG/Parallel.py

@@ -0,0 +1,638 @@
+from ipyparallel import Client, parallel, Reference, require, depend, interactive
+from SimPEG.Utils import CommonReducer
+import numpy as np
+import networkx
+
+DEFAULT_MPI = True
+MPI_BELLWETHERS = ['PMI_SIZE', 'OMPI_UNIVERSE_SIZE']
+
+class SuperReference(object):
+    '''
+    Object that can be called to return a reference, but
+    will only be schedulable on the correct worker(s) if
+    its 'lrank' parameter has been set.
+    '''
+
+    def __init__(self, ref, lrank=None):
+
+        if (lrank is None) or (type(lrank) is list):
+            self.rank = lrank
+        else:
+            self.rank = [lrank]
+            
+        self.ref = ref
+
+    def __call__(self, *args, **kwargs):
+
+        from ipyparallel import depend
+        from ipyparallel.error import UnmetDependency
+
+        if (self.rank is not None) and (globals().get('rank', None) not in self.rank):
+            raise UnmetDependency('Global \'rank\' does not satisfy requirements')
+
+        return self.ref(*args, **kwargs)
+
+class Endpoint(object):
+    '''
+    Object that holds the namespace of the SimPEG parallel
+    footprint on the remote workers.
+    '''
+
+    problemFactory = lambda: None   # Callable for constructing system / problem
+    surveyFactory = lambda: None    # Callable for constructing survey
+    localFields = {}                # Dictionary for storing local fields
+    globalFields = {}               # Dictionary for storing merged fields
+    localProblems = {}              # Dictionary of local subsystem / problem objects
+    localSurveys = {}               # Dictionary of local survey objects
+    functions = {}                  # Dictionary of callables to carry out modelling / etc.
+    fieldspec = None                # Dictionary of callables to setup field storage objects
+    baseSystemConfig = {}           # Base configuration for system
+
+    def setupLocalFields(self, whichfields=None):
+
+        # If no names are specified, clear all fields first
+        if whichfields is None:
+            self.localFields = {}
+
+        # If we have a 'fieldspec' object...
+        if getattr(self, 'fieldspec', None) is not None:
+            # ...either loop over the specified names, or all the fields...
+            for fn in (whichfields or self.fieldspec):
+                # ...and construct a new empty object per the 'fieldspec' constructor.
+                self.localFields[fn] = self.fieldspec[fn]()
+
+    def setupLocalSurveys(self, subConfigs):
+
+        # Loop over possible survey configurations (may differ in source terms, etc.)
+        for isub in subConfigs:
+            # For each 'isub' create a separate copy of the base configuration...
+            geom = self.baseSystemConfig['geom'].copy()
+            # ...and update with any differences...
+            geom.update(subConfigs[isub])
+            # ...then construct the Survey object and store it for later pairing.
+            self.localSurveys[isub] = self.surveyFactory(geom)
+
+    def setupLocalProblem(self, subConfig):
+
+        # Make a copy w/o the geometry information (which is used by Survey)
+        systemConfig = {key: self.baseSystemConfig[key] for key in self.baseSystemConfig if key not in ['geom']}
+
+        # Update with the configuration for this subproblem
+        systemConfig.update(subConfig)
+
+        # Create the local subproblem...
+        problem = self.problemFactory(systemConfig)
+        # ...and pair it with a corresponding survey for this 'isub' (e.g., frequency)...
+        problem.pair(self.localSurveys[subConfig['isub']])
+        # ...then store in the Endpoint for later access by the scheduler.
+        self.localProblems[subConfig['tag']] = problem
+
+
+class SystemGraph(networkx.DiGraph):
+    '''
+    NetworkX Directed Graph subclass that knows about
+    job status information, and can return a representation
+    of itself for use in interactive debugging/testing.
+    '''
+
+    @staticmethod
+    def _codeStatus(data):
+        
+        status = 0
+        
+        if 'jobs' in data:
+            status = 1 * data['jobs'][-1].ready() + 1
+            if status > 1:
+                status += 1 * (not data['jobs'][-1].successful())
+        
+        return status 
+
+    def _codeGraph(self):
+        from networkx.readwrite import json_graph
+        
+        G = networkx.DiGraph()
+        
+        for e in self.edges_iter():
+            G.add_edge(e[0], e[1])
+        
+        for n, data in self.nodes_iter(data=True):
+            G.add_node(n, status=self._codeStatus(data))
+        
+        return json_graph.node_link_data(G)
+
+    def RenderHTML(self):
+        import pkg_resources
+        from IPython.core import display
+        import time
+
+        data = str(self._codeGraph())
+        uniqueID = hash(time.time())
+
+        formatstr = {
+            'uniqueID': 'Graph%s'%uniqueID,
+            'JSONData': data,
+        }
+
+        code = pkg_resources.resource_string('SimPEG', 'Resources/Parallel/SystemGraph.html')%formatstr
+
+        return display.HTML(data=code)._repr_html_()
+
+try:
+    get_ipython().display_formatter.formatters['text/html'].for_type(SystemGraph, SystemGraph.RenderHTML)
+except NameError:
+    pass
+
+class SystemSolver(object):
+
+    def __init__(self, problem, schedule):
+
+        self.problem = problem
+        self.remote = problem.remote
+        self.schedule = schedule
+
+    def __call__(self, entry, isrcs):
+        
+        # TODO: Replace with SuperReference instances
+        fnformat = '%s.functions["%s"]'
+        fnRef = Reference(fnformat%(self.remote.endpointName, self.schedule[entry]['solve']))
+        clearRef = Reference(fnformat%(self.remote.endpointName, self.schedule[entry]['clear']))
+        reduceLabels = self.schedule[entry]['reduce']
+
+        dview = self.problem.remote.dview
+        lview = self.problem.remote.lview
+
+        chunksPerWorker = getattr(self.problem, 'chunksPerWorker', 1)
+
+        G = SystemGraph()
+
+        mainNode = 'Beginning'
+        G.add_node(mainNode)
+
+        # Parse sources
+        # TODO: Get from Survey somehow?
+        nsrc = self.problem.nsrc
+        if isrcs is None:
+            isrcs = slice(None)
+
+        elif not isinstance(isrcs, slice):
+            raise Exception('Scheduler must run over slice or None!')
+
+        # TODO: Replace w/ hook into Endpoint classes
+        systemsOnWorkers = dview['%s.localProblems.keys()'%self.remote.endpointName]
+        ids = dview['rank']
+        tags = set()
+        for ltags in systemsOnWorkers:
+            tags = tags.union(set(ltags))
+
+        clearJobs = []
+        endNodes = {}
+        tailNodes = []
+
+        for tag in tags:
+
+            tagNode = 'Head: %d, %d'%tag
+            G.add_edge(mainNode, tagNode)
+
+            relIDs = []
+            for i in xrange(len(ids)):
+
+                systems = systemsOnWorkers[i]
+                rank = ids[i]
+
+                if tag in systems:
+                    relIDs.append(rank)
+
+            systemJobs = []
+            endNodes[tag] = []
+            systemNodes = []
+
+            with lview.temp_flags(block=False):
+                iworks = 0
+                for work in self._subSlice(isrcs, int(round(chunksPerWorker*len(relIDs)))):
+                    if work:
+                        job = lview.apply(fnRef, Reference(self.remote.endpointName), tag, work)
+                        systemJobs.append(job)
+                        label = 'Compute: %d, %d, %d'%(tag[0], tag[1], iworks)
+                        systemNodes.append(label)
+                        G.add_node(label, jobs=[job], subslice=work, tag=tag)
+                        G.add_edge(tagNode, label)
+                        iworks += 1
+
+            if getattr(self.problem, 'ensembleClear', False): # True for ensemble ending, False for individual ending
+                tagNode = 'Wrap: %d, %d'%tag
+                for label in systemNodes:
+                    G.add_edge(label, tagNode)
+
+                for rank in relIDs:
+
+                    with lview.temp_flags(block=False, after=systemJobs):
+                        # TODO: Remove dependency on self._hasSystemRank, once the SuperReferences
+                        #       are able to be used. They will automatically schedule only on the
+                        #       correct (allowed) systems.
+                        job = lview.apply(clearRef, Reference(self.remote.endpointName), tag, rank)
+                        clearJobs.append(job)
+                        label = 'Wrap: %d, %d, %d'%(tag[0],tag[1], rank)
+                        G.add_node(label, jobs=[job], tag=tag, rank=rank)
+                        endNodes[tag].append(label)
+                        G.add_edge(tagNode, label)
+            else:
+
+                for i, sjob in enumerate(systemJobs):
+                    with lview.temp_flags(block=False, follow=sjob, after=sjob):
+                        job = lview.apply(clearRef, Reference(self.remote.endpointName), tag)
+                        clearJobs.append(job)
+                        label = 'Wrap: %d, %d, %d'%(tag[0],tag[1],i)
+                        G.add_node(label, jobs=[job])
+                        endNodes[tag].append(label)
+                        G.add_edge(systemNodes[i], label)
+
+            tagNode = 'Tail: %d, %d'%tag
+            for label in endNodes[tag]:
+                G.add_edge(label, tagNode)
+            tailNodes.append(tagNode)
+
+        endNode = 'End'
+        jobs = []
+        after = clearJobs
+        for label in reduceLabels:
+            job = self.problem.remote.reduceLB(Reference(self.remote.endpointName), label, after)
+            after = job
+            if job is not None:
+                jobs.append(job)
+        G.add_node(endNode, jobs=jobs)
+        for node in tailNodes:
+            G.add_edge(node, endNode)
+
+        return G
+
+    def wait(self, G):
+        self.problem.remote.lview.wait(G.node['End']['jobs'] if G.node['End']['jobs'] else (G.node[wn]['jobs'] for wn in (G.predecessors(tn)[0] for tn in G.predecessors('End'))))
+
+    # TODO: Hopefully obsoleted by SuperReference
+    @staticmethod
+    @interactive
+    def _hasSystemRank(endpoint, tag, wid):
+        global rank
+
+        return (tag in endpoint.localProblems) and (rank == wid)
+
+    @staticmethod
+    def _getChunks(problems, chunks=1):
+        nproblems = len(problems)
+        return (problems[i*nproblems // chunks: (i+1)*nproblems // chunks] for i in range(chunks))
+
+    @staticmethod
+    def _subSlice(insl,  chunks=1):
+        start = insl.start or 0
+        nproblems = insl.stop - start
+        return [slice(start + i*nproblems/chunks, start + (i+1)*nproblems/chunks) for i in xrange(chunks)]
+
+
+class RemoteInterface(object):
+
+    def __init__(self, profile=None, MPI=None, nThreads=1, bootstrap=None, endpointName='endpoint'):
+
+        # TODO: Add interface for namespace bootstrapping from
+        #       the dispatcher / problem side
+
+        if profile is not None:
+            pupdate = {'profile': profile}
+        else:
+            pupdate = {}
+
+        pclient = Client(**pupdate)
+
+        if not self._cdSame(pclient):
+            print('Could not change all workers to the same directory as the client!')
+
+        dview = pclient[:]
+        dview.block = True
+        dview.clear()
+
+        remoteSetup = '''
+        import os'''
+
+        parMPISetup = ''' 
+        from mpi4py import MPI
+        comm = MPI.COMM_WORLD
+        rank = comm.Get_rank()''' 
+
+        for command in remoteSetup.strip().split('\n'):
+            dview.execute(command.strip())
+
+        dview.scatter('rank', pclient.ids, flatten=True)
+
+        self.e0 = pclient[0]
+        self.e0.block = True
+
+        self.useMPI = False
+        MPI = DEFAULT_MPI if MPI is None else MPI
+        if MPI:
+            MPISafe = False
+
+            for var in MPI_BELLWETHERS:
+                MPISafe = MPISafe or all(dview['os.getenv("%s")'%(var,)])
+
+            if MPISafe:
+                for command in parMPISetup.strip().split('\n'):
+                    dview.execute(command.strip())
+                ranks = dview['rank']
+                reorder = [ranks.index(i) for i in xrange(len(ranks))]
+                dview = pclient[reorder]
+                dview.block = True
+                dview.activate()
+
+                # Set up necessary parts for broadcast-based communication
+                self.e0 = pclient[reorder[0]]
+                self.e0.block = True
+                self.comm = Reference('comm')
+
+            self.useMPI = MPISafe
+
+        self.pclient = pclient
+        self.dview = dview
+        self.lview = pclient.load_balanced_view()
+
+        self.nThreads = nThreads
+
+        if bootstrap is not None:
+            for command in bootstrap.strip().split('\n'):
+                dview.execute(command.strip())
+
+        self.endpointName = endpointName
+
+    @property
+    def nThreads(self):
+        return self._nThreads
+    @nThreads.setter
+    def nThreads(self, value):
+        self._nThreads = value
+        self.dview.apply(self._adjustMKLVectorization, self._nThreads)
+    
+
+    def __setitem__(self, key, item):
+
+        if self.useMPI:
+            self.e0[key] = item
+            code = 'if rank != 0: %(key)s = None\n%(key)s = comm.bcast(%(key)s, root=0)'
+            self.dview.execute(code%{'key': key})
+
+        else:
+            self.dview[key] = item
+
+    def __getitem__(self, key):
+
+        if self.useMPI:
+            code = 'temp_%(key)s = None\ntemp_%(key)s = comm.gather(%(key)s, root=%(root)d)'
+            self.dview.execute(code%{'key': key, 'root': 0})
+            item = self.e0['temp_%s'%(key,)]
+            self.e0.execute('del temp_%s'%(key,))
+
+        else:
+            item = self.dview[key]
+
+        return item
+
+    def reduceLB(self, endpoint, key, after=None):
+
+        repeat = lambda value: (value for i in xrange(len(self.pclient.ids)))
+
+        if self.useMPI:
+            with self.lview.temp_flags(block=False, after=after):
+                job = self.lview.map(self._reduceJob, xrange(len(self.pclient.ids)), repeat(0), repeat(endpoint), repeat(key))
+
+            return job
+
+    def reduce(self, key, axis=None):
+
+        if self.useMPI:
+            code = 'temp_%(key)s = comm.reduce(%(key)s, root=%(root)d)'
+            self.dview.execute(code%{'key': key, 'root': 0})
+
+            # if axis is not None:
+            #     code = 'temp_%(key)s = temp_%(key)s.sum(axis=%(axis)d)'
+            #     self.e0.execute(code%{'key': key, 'axis': axis})
+
+            item = self.e0['temp_%s'%(key,)]
+            self.dview.execute('del temp_%s'%(key,))
+
+        else:
+            item = reduce(np.add, self.dview[key])
+
+        return item
+
+    def reduceMul(self, key1, key2, axis=None):
+
+        if self.useMPI:
+            # Gather
+            code_reduce = 'temp_%(key)s = comm.reduce(%(key)s, root=%(root)d)'
+            self.dview.execute(code_reduce%{'key': key1, 'root': 0})
+            self.dview.execute(code_reduce%{'key': key2, 'root': 0})
+
+            # Multiply
+            code_mul = 'temp_%(key1)s%(key2)s = temp_%(key1)s * temp_%(key2)s'
+            self.e0.execute(code_mul%{'key1': key1, 'key2': key2})
+
+            # Potentially sum
+            if axis is not None:
+                code = 'temp_%(key1)s%(key2)s = temp_%(key1)s%(key2)s.sum(axis=%(axis)d)'
+                self.e0.execute(code%{'key1': key1, 'key2': key2, 'axis': axis})
+
+            # Pull
+            item = self.e0['temp_%(key1)s%(key2)s'%{'key1': key1, 'key2': key2}]
+
+            # Clear
+            self.dview.execute('del temp_%s'%(key1,))
+            self.dview.execute('del temp_%s'%(key2,))
+            self.e0.execute('del temp_%(key1)s%(key2)s'%{'key1': key1, 'key2': key2})
+
+        else:
+            item1 = reduce(np.add, self.dview[key1])
+            item2 = reduce(np.add, self.dview[key2])
+            item = item1 * item2
+
+        return item
+
+    def remoteMulE0(self, key1, key2, axis=None):
+
+        code_mul = 'temp_field = %(key1)s * %(key2)s'
+        self.e0.execute(code_mul%{'key1': key1, 'key2': key2})
+
+        if axis is not None:
+            code = 'temp_field = temp_field.sum(axis=%(axis)d)'
+            self.e0.execute(code%{'axis': axis})
+
+        item = self.e0['temp_field']
+        self.e0.execute('del temp_field')
+
+        return item
+
+    def remoteDifference(self, key1, key2, keyresult):
+
+        if self.useMPI:
+
+            root = 0
+
+            # Gather
+            code_reduce = 'temp_%(key)s = comm.reduce(%(key)s, root=%(root)d)'
+            self.dview.execute(code_reduce%{'key': key1, 'root': root})
+            self.dview.execute(code_reduce%{'key': key2, 'root': root})
+
+            # Difference
+            code_difference = '%(keyresult)s = temp_%(key1)s - temp_%(key2)s'
+            self.e0.execute(code_difference%{'key1': key1, 'key2': key2, 'keyresult': keyresult})
+
+            # Broadcast
+            code = 'if rank != 0: %(key)s = None\n%(key)s = comm.bcast(%(key)s, root=%(root)d)'
+            self.dview.execute(code%{'key': keyresult, 'root': root})
+
+            # Clear
+            self.e0.execute('del temp_%s'%(key1,))
+            self.e0.execute('del temp_%s'%(key2,))
+
+        else:
+            item1 = reduce(np.add, self.dview[key1])
+            item2 = reduce(np.add, self.dview[key2])
+
+            item = item1 - item2
+            self.dview[keyresult] = item
+
+    def remoteOpGatherFirst(self, op, key1, key2, keyresult):
+
+        if self.useMPI:
+
+            root = 0
+
+            # Gather
+            code_reduce = 'temp_%(key)s = comm.reduce(%(key)s, root=%(root)d)'
+            self.dview.execute(code_reduce%{'key': key1, 'root': root})
+
+            # Difference
+            code_difference = '%(keyresult)s = temp_%(key1)s %(op)s %(key2)s'
+            self.e0.execute(code_difference%{'op': op, 'key1': key1, 'key2': key2, 'keyresult': keyresult})
+
+            # Broadcast
+            code = 'if rank != 0: %(key)s = None\n%(key)s = comm.bcast(%(key)s, root=%(root)d)'
+            self.dview.execute(code%{'key': keyresult, 'root': root})
+
+            # Clear
+            self.e0.execute('del temp_%s'%(key1,))
+
+        else:
+            item1 = reduce(np.add, self.dview[key1])
+            item2 = self.e0[key2] # Assumes that any arbitrary worker has this information
+
+            item = eval('item1 %s item2'%(op,))
+            self.dview[keyresult] = item
+
+    def remoteDifferenceGatherFirst(self, *args):
+        self.remoteOpGatherFirst('-', *args)
+
+    def remoteSrcEstGatherFirst(self, keyresult, key1, key2, individual=False):
+
+        if self.useMPI:
+
+            root = 0
+
+            # # Gather
+            # code_reduce = 'temp_%(key)s = comm.reduce(%(key)s, root=%(root)d)'
+            # self.dview.execute(code_reduce%{'key': key1, 'root': root})
+
+            # SrcEst
+            if individual:
+                code_srcest = '%(keyresult)s = (%(key2)s.conj() * %(key1)s).sum(axis=1) / (%(key1)s.conj() * %(key1)s).sum(axis=1)'
+            else:
+                code_srcest = '%(keyresult)s = (%(key2)s.conj() * %(key1)s).sum() / (%(key1)s.conj() * %(key1)s).sum()'
+            self.e0.execute(code_srcest%{'key1': key1, 'key2': key2, 'keyresult': keyresult})
+
+            # Broadcast
+            code = 'if rank != %(root)d: %(key)s = None\n%(key)s = comm.bcast(%(key)s, root=%(root)d)'
+            self.dview.execute(code%{'key': keyresult, 'root': root})
+
+        else:
+
+            item1 = reduce(np.add, self.dview[key1])
+            item2 = self.e0[key2]
+
+            if individual:
+                item = (item2.conj() * item1).sum(axis=1) / (item1.conj() * item1).sum(axis=1)
+            else:
+                item = (item2.conj() * item1).sum() / (item1.conj() * item1).sum()
+
+            self.dview[keyresult] = item
+
+    def remoteApplySrc(self, keyData, keySrc):
+
+        code = '%(keyData)s = %(keySrc)s * %(keyData)s'
+        self.dview.execute(code%{'keyData': keyData, 'keySrc': keySrc})
+
+    # def normFromDifference(self, key):
+
+    #     code = 'temp_norm%(key)s = (%(key)s * %(key)s.conj()).sum(0).sum(0)'
+    #     self.e0.execute(code%{'key': key})
+    #     code = 'temp_norm%(key)s = {key: np.sqrt(temp_norm%(key)s[key]).real for key in temp_norm%(key)s.keys()}'
+    #     self.e0.execute(code%{'key': key})
+    #     result = CommonReducer(self.e0['temp_norm%s'%(key,)])
+    #     self.e0.execute('del temp_norm%s'%(key,))
+
+    #     return result
+
+    def normFromDifference(self, key):
+
+        code = 'temp_norm = (%(key)s * %(key)s.conj()).sum(0).sum(0)'
+        self.e0.execute(code%{'key': key})
+        code = 'temp_norm = {key: np.sqrt(temp_norm[key]).real for key in temp_norm}'
+        self.e0.execute(code%{'key': key})
+        result = CommonReducer(self.e0['temp_norm'])
+        self.e0.execute('del temp_norm')
+
+        return result
+
+    @staticmethod
+    @interactive
+    def _reduceJob(worker, root, endpoint, key):
+
+        from ipyparallel.error import UnmetDependency
+        if not rank == worker:
+            raise UnmetDependency
+
+        # code = '%(endpoint)s.globalFields["%(key)s"] = comm.reduce(%(endpoint)s.localFields["%(key)s"], root=%(root)d)'
+        # exec(code%{'endpoint': endpoint, 'key': key, 'root': root})
+
+        if key not in endpoint.localFields:
+            endpoint.localFields[key] = endpoint.fieldspec[key]()
+
+        endpoint.globalFields[key] = comm.reduce(endpoint.localFields[key], root=root)
+
+    @staticmethod
+    def _adjustMKLVectorization(nt=1):
+        try:
+            import mkl
+            mkl.set_num_threads(nt)
+        except ImportError:
+            pass
+
+    @staticmethod
+    def _cdSame(rc):
+        import os
+
+        dview = rc[:]
+
+        home = os.getenv('HOME')
+        cwd = os.getcwd()
+
+        @interactive
+        def cdrel(relpath):
+            import os
+            home = os.getenv('HOME')
+            fullpath = os.path.join(home, relpath)
+            try:
+                os.chdir(fullpath)
+            except OSError:
+                return False
+            else:
+                return True
+
+        if cwd.find(home) == 0:
+            relpath = cwd[len(home)+1:]
+            return all(rc[:].apply_sync(cdrel, relpath))

SimPEG/Problem.py

@@ -32,8 +32,8 @@ class BaseProblem(object):
             val._assertMatchesPair(self.mapPair)
             self._mapping = val
         else:
-            self._mapping = self.PropMap(val)
-
+            self._mapping = self.PropMap(val) 
+    
     def __init__(self, mesh, mapping=None, **kwargs):
         Utils.setKwargs(self, **kwargs)
         assert isinstance(mesh, Mesh.BaseMesh), "mesh must be a SimPEG.Mesh object."
@@ -88,28 +88,28 @@ class BaseProblem(object):
         return self.survey is not None
 
     @Utils.timeIt
-    def Jvec(self, m, v, f=None):
-        """Jvec(m, v, f=None)
+    def Jvec(self, m, v, u=None):
+        """Jvec(m, v, u=None)
 
             Effect of J(m) on a vector v.
 
             :param numpy.array m: model
             :param numpy.array v: vector to multiply
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: numpy.array
             :return: Jv
         """
         raise NotImplementedError('J is not yet implemented.')
 
     @Utils.timeIt
-    def Jtvec(self, m, v, f=None):
-        """Jtvec(m, v, f=None)
+    def Jtvec(self, m, v, u=None):
+        """Jtvec(m, v, u=None)
 
             Effect of transpose of J(m) on a vector v.
 
             :param numpy.array m: model
             :param numpy.array v: vector to multiply
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: numpy.array
             :return: JTv
         """
@@ -117,32 +117,32 @@ class BaseProblem(object):
 
 
     @Utils.timeIt
-    def Jvec_approx(self, m, v, f=None):
-        """Jvec_approx(m, v, f=None)
+    def Jvec_approx(self, m, v, u=None):
+        """Jvec_approx(m, v, u=None)
 
             Approximate effect of J(m) on a vector v
 
             :param numpy.array m: model
             :param numpy.array v: vector to multiply
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: numpy.array
             :return: approxJv
         """
-        return self.Jvec(m, v, f)
+        return self.Jvec(m, v, u)
 
     @Utils.timeIt
-    def Jtvec_approx(self, m, v, f=None):
-        """Jtvec_approx(m, v, f=None)
+    def Jtvec_approx(self, m, v, u=None):
+        """Jtvec_approx(m, v, u=None)
 
             Approximate effect of transpose of J(m) on a vector v.
 
             :param numpy.array m: model
             :param numpy.array v: vector to multiply
-            :param Fields f: fields
+            :param numpy.array u: fields
             :rtype: numpy.array
             :return: JTv
         """
-        return self.Jtvec(m, v, f)
+        return self.Jtvec(m, v, u)
 
     def fields(self, m):
         """
@@ -213,20 +213,5 @@ class BaseTimeProblem(BaseProblem):
         if hasattr(self, '_timeMesh'):
             del self._timeMesh
 
-class LinearProblem(BaseProblem):
 
-    surveyPair = Survey.LinearSurvey
-
-    def __init__(self, mesh, G, **kwargs):
-        BaseProblem.__init__(self, mesh, **kwargs)
-        self.G = G
-
-    def fields(self, m):
-        return self.G.dot(m)
-
-    def Jvec(self, m, v, f=None):
-        return self.G.dot(v)
-
-    def Jtvec(self, m, v, f=None):
-        return self.G.T.dot(v)
 

SimPEG/Regularization.py

@@ -1,289 +1,5 @@
 import Utils, Maps, Mesh, numpy as np, scipy.sparse as sp
 
-class RegularizationMesh(object):
-    """
-    **Regularization Mesh**
-
-    This contains the operators used in the regularization. Note that these
-    are not necessarily true differential operators, but are constructed from
-    a SimPEG Mesh.
-
-    :param Mesh mesh: problem mesh
-    :param numpy.array indActive: bool array, size nC, that is True where we have active cells. Used to reduce the operators so we regularize only on active cells
-    """
-
-    def __init__(self, mesh, indActive=None):
-        self.mesh = mesh
-        assert indActive is None or indActive.dtype == 'bool', 'indActive needs to be None or a bool'
-        self.indActive = indActive
-
-    @property
-    def vol(self):
-        """
-        reduced volume vector
-        :rtype: numpy.array
-        :return: reduced cell volume
-        """
-        if getattr(self, '_vol', None) is None:
-            self._vol = self._Pac.T * self.mesh.vol
-        return self._vol
-
-    @property
-    def nC(self):
-        """
-        reduced number of cells
-        :rtype: int
-        :return: number of cells being regularized
-        """
-        if getattr(self, '_nC', None) is None:
-            if self.indActive is None:
-                self._nC = self.mesh.nC
-            else:
-                self._nC = sum(self.indActive)
-        return self._nC
-
-    @property
-    def dim(self):
-        """
-        dimension of regularization mesh (1D, 2D, 3D)
-        :rtype: int
-        :return: dimension
-        """
-        if getattr(self, '_dim', None) is None:
-            self._dim = self.mesh.dim
-        return self._dim
-
-
-    @property
-    def _Pac(self):
-        """
-        projection matrix that takes from the reduced space of active cells to full modelling space (ie. nC x nindActive)
-        :rtype: scipy.sparse.csr_matrix
-        :return: active cell projection matrix
-        """
-        if getattr(self, '__Pac', None) is None:
-            if self.indActive is None:
-                self.__Pac = Utils.speye(self.mesh.nC)
-            else:
-                self.__Pac = Utils.speye(self.mesh.nC)[:,self.indActive]
-        return self.__Pac
-
-    @property
-    def _Pafx(self):
-        """
-        projection matrix that takes from the reduced space of active x-faces to full modelling space (ie. nFx x nindActive_Fx )
-        :rtype: scipy.sparse.csr_matrix
-        :return: active face-x projection matrix
-        """
-        if getattr(self, '__Pafx', None) is None:
-            if self.indActive is None:
-                self.__Pafx = Utils.speye(self.mesh.nFx)
-            else:
-                indActive_Fx = (self.mesh.aveFx2CC.T * self.indActive) == 1
-                self.__Pafx = Utils.speye(self.mesh.nFx)[:,indActive_Fx]
-        return self.__Pafx
-
-    @property
-    def _Pafy(self):
-        """
-        projection matrix that takes from the reduced space of active y-faces to full modelling space (ie. nFy x nindActive_Fy )
-        :rtype: scipy.sparse.csr_matrix
-        :return: active face-y projection matrix
-        """
-        if getattr(self, '__Pafy', None) is None:
-            if self.indActive is None:
-                self.__Pafy = Utils.speye(self.mesh.nFy)
-            else:
-                indActive_Fy = (self.mesh.aveFy2CC.T * self.indActive) == 1
-                self.__Pafy = Utils.speye(self.mesh.nFy)[:,indActive_Fy]
-        return self.__Pafy
-
-    @property
-    def _Pafz(self):
-        """
-        projection matrix that takes from the reduced space of active z-faces to full modelling space (ie. nFz x nindActive_Fz )
-        :rtype: scipy.sparse.csr_matrix
-        :return: active face-z projection matrix
-        """
-        if getattr(self, '__Pafz', None) is None:
-            if self.indActive is None:
-                self.__Pafz = Utils.speye(self.mesh.nFz)
-            else:
-                indActive_Fz = (self.mesh.aveFz2CC.T * self.indActive) == 1
-                self.__Pafz = Utils.speye(self.mesh.nFz)[:,indActive_Fz]
-        return self.__Pafz
-
-    @property
-    def aveFx2CC(self):
-        """
-        averaging from active cell centers to active x-faces
-        :rtype: scipy.sparse.csr_matrix
-        :return: averaging from active cell centers to active x-faces
-        """
-        if getattr(self, '_aveFx2CC', None) is None:
-            self._aveFx2CC =  self._Pac.T * self.mesh.aveFx2CC * self._Pafx
-        return self._aveFx2CC
-
-    @property
-    def aveCC2Fx(self):
-        """
-        averaging from active x-faces to active cell centers
-        :rtype: scipy.sparse.csr_matrix
-        :return: averaging matrix from active x-faces to active cell centers
-        """
-        if getattr(self, '_aveCC2Fx', None) is None:
-            self._aveCC2Fx =  Utils.sdiag(1./(self.aveFx2CC.T).sum(1)) * self.aveFx2CC.T
-        return self._aveCC2Fx
-
-    @property
-    def aveFy2CC(self):
-        """
-        averaging from active cell centers to active y-faces
-        :rtype: scipy.sparse.csr_matrix
-        :return: averaging from active cell centers to active y-faces
-        """
-        if getattr(self, '_aveFy2CC', None) is None:
-            self._aveFy2CC = self._Pac.T * self.mesh.aveFy2CC * self._Pafy
-        return self._aveFy2CC
-
-    @property
-    def aveCC2Fy(self):
-        """
-        averaging from active y-faces to active cell centers
-        :rtype: scipy.sparse.csr_matrix
-        :return: averaging matrix from active y-faces to active cell centers
-        """
-        if getattr(self, '_aveCC2Fy', None) is None:
-            self._aveCC2Fy =  Utils.sdiag(1./(self.aveFy2CC.T).sum(1)) * self.aveFy2CC.T
-        return self._aveCC2Fy
-
-    @property
-    def aveFz2CC(self):
-        """
-        averaging from active cell centers to active z-faces
-        :rtype: scipy.sparse.csr_matrix
-        :return: averaging from active cell centers to active z-faces
-        """
-        if getattr(self, '_aveFz2CC', None) is None:
-            self._aveFz2CC = self._Pac.T * self.mesh.aveFz2CC * self._Pafz
-        return self._aveFz2CC
-
-    @property
-    def aveCC2Fz(self):
-        """
-        averaging from active z-faces to active cell centers
-        :rtype: scipy.sparse.csr_matrix
-        :return: averaging matrix from active z-faces to active cell centers
-        """
-        if getattr(self, '_aveCC2Fz', None) is None:
-            self._aveCC2Fz =  Utils.sdiag(1./(self.aveFz2CC.T).sum(1)) * self.aveFz2CC.T
-        return self._aveCC2Fz
-
-    @property
-    def cellDiffx(self):
-        """
-        cell centered difference in the x-direction
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active cells in the x-direction
-        """
-        if getattr(self, '_cellDiffx', None) is None:
-            self._cellDiffx = self._Pafx.T * self.mesh.cellGradx * self._Pac
-        return self._cellDiffx
-
-    @property
-    def cellDiffy(self):
-        """
-        cell centered difference in the y-direction
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active cells in the y-direction
-        """
-        if getattr(self, '_cellDiffy', None) is None:
-            self._cellDiffy = self._Pafy.T * self.mesh.cellGrady * self._Pac
-        return self._cellDiffy
-
-    @property
-    def cellDiffz(self):
-        """
-        cell centered difference in the z-direction
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active cells in the z-direction
-        """
-        if getattr(self, '_cellDiffz', None) is None:
-            self._cellDiffz = self._Pafz.T * self.mesh.cellGradz * self._Pac
-        return self._cellDiffz
-
-    @property
-    def faceDiffx(self):
-        """
-        x-face differences
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active faces in the x-direction
-        """
-        if getattr(self, '_faceDiffx', None) is None:
-            self._faceDiffx = self._Pac.T * self.mesh.faceDivx * self._Pafx
-        return self._faceDiffx
-
-    @property
-    def faceDiffy(self):
-        """
-        y-face differences
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active faces in the y-direction
-        """
-        if getattr(self, '_faceDiffy', None) is None:
-            self._faceDiffy = self._Pac.T * self.mesh.faceDivy * self._Pafy
-        return self._faceDiffy
-
-    @property
-    def faceDiffz(self):
-        """
-        z-face differences
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active faces in the z-direction
-        """
-        if getattr(self, '_faceDiffz', None) is None:
-            self._faceDiffz = self._Pac.T * self.mesh.faceDivz * self._Pafz
-        return self._faceDiffz
-
-    @property
-    def cellDiffxStencil(self):
-        """
-        cell centered difference stencil (no cell lengths include) in the x-direction
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active cells in the x-direction
-        """
-        if getattr(self, '_cellDiffxStencil', None) is None:
-
-            self._cellDiffxStencil = self._Pafx.T * self.mesh._cellGradxStencil() * self._Pac
-        return self._cellDiffxStencil
-
-    @property
-    def cellDiffyStencil(self):
-        """
-        cell centered difference stencil (no cell lengths include) in the y-direction
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active cells in the y-direction
-        """
-        if self.dim < 2: return None
-        if getattr(self, '_cellDiffyStencil', None) is None:
-
-            self._cellDiffyStencil = self._Pafy.T * self.mesh._cellGradyStencil() * self._Pac
-        return self._cellDiffyStencil
-
-    @property
-    def cellDiffzStencil(self):
-        """
-        cell centered difference stencil (no cell lengths include) in the y-direction
-        :rtype: scipy.sparse.csr_matrix
-        :return: differencing matrix for active cells in the y-direction
-        """
-        if self.dim < 3: return None
-        if getattr(self, '_cellDiffzStencil', None) is None:
-
-            self._cellDiffzStencil = self._Pafz.T * self.mesh._cellGradzStencil() * self._Pac
-        return self._cellDiffzStencil
-
-
 class BaseRegularization(object):
     """
     **Base Regularization Class**
@@ -302,19 +18,14 @@ class BaseRegularization(object):
 
     mapping = None    #: A SimPEG.Map instance.
     mesh    = None    #: A SimPEG.Mesh instance.
-    mref    = None    #: Reference model.
+    mref = None       #: Reference model.
 
-    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
+    def __init__(self, mesh, mapping=None, **kwargs):
         Utils.setKwargs(self, **kwargs)
+        self.mesh = mesh
         assert isinstance(mesh, Mesh.BaseMesh), "mesh must be a SimPEG.Mesh object."
-        if indActive is not None and indActive.dtype != 'bool':
-            tmp = indActive
-            indActive = np.zeros(mesh.nC, dtype=bool)
-            indActive[tmp] = True
-        self.regmesh = RegularizationMesh(mesh,indActive)
-        self.mapping = mapping or self.mapPair(mesh)
+        self.mapping = mapping or Maps.IdentityMap(mesh)
         self.mapping._assertMatchesPair(self.mapPair)
-        self.indActive = indActive
 
     @property
     def parent(self):
@@ -343,7 +54,8 @@ class BaseRegularization(object):
     @property
     def W(self):
         """Full regularization weighting matrix W."""
-        return sp.identity(self.regmesh.nC)
+        return sp.identity(self.mapping.nP)
+
 
     @Utils.timeIt
     def eval(self, m):
@@ -374,12 +86,11 @@ class BaseRegularization(object):
     @Utils.timeIt
     def eval2Deriv(self, m, v=None):
         """
-        Second derivative
 
-        :param numpy.array m: geophysical model
-        :param numpy.array v: vector to multiply
-        :rtype: scipy.sparse.csr_matrix or numpy.ndarray
-        :return: WtW or WtW*v
+            :param numpy.array m: geophysical model
+            :param numpy.array v: vector to multiply
+            :rtype: scipy.sparse.csr_matrix or numpy.ndarray
+            :return: WtW or WtW*v
 
         The regularization is:
 
@@ -400,94 +111,153 @@ class BaseRegularization(object):
 
         return mD.T * ( self.W.T * ( self.W * ( mD * v) ) )
 
+
+
+
 class Tikhonov(BaseRegularization):
+    """**Tikhonov Regularization**
+
+        Here we will define regularization of a model, m, in general however, this should be thought of as (m-m_ref) but otherwise it is exactly the same:
+
+        .. math::
+
+            R(m) = \int_\Omega \\frac{\\alpha_x}{2}\left(\\frac{\partial m}{\partial x}\\right)^2 + \\frac{\\alpha_y}{2}\left(\\frac{\partial m}{\partial y}\\right)^2 \partial v
+
+        Our discrete gradient operator works on cell centers and gives the derivative on the cell faces, which is not where we want to be evaluating this integral. We need to average the values back to the cell-centers before we integrate. To avoid null spaces, we square first and then average. In 2D with ij notation it looks like this:
+
+        .. math::
+
+            R(m) \\approx \sum_{ij} \left[\\frac{\\alpha_x}{2}\left[\left(\\frac{m_{i+1,j} - m_{i,j}}{h}\\right)^2 + \left(\\frac{m_{i,j} - m_{i-1,j}}{h}\\right)^2\\right]
+            + \\frac{\\alpha_y}{2}\left[\left(\\frac{m_{i,j+1} - m_{i,j}}{h}\\right)^2 + \left(\\frac{m_{i,j} - m_{i,j-1}}{h}\\right)^2\\right]
+            \\right]h^2
+
+        If we let D_1 be the derivative matrix in the x direction
+
+        .. math::
+
+            \mathbf{D}_1 = \mathbf{I}_2\otimes\mathbf{d}_1
+
+        .. math::
+
+            \mathbf{D}_2 = \mathbf{d}_2\otimes\mathbf{I}_1
+
+        Where d_1 is the one dimensional derivative:
+
+        .. math::
+
+            \mathbf{d}_1 = \\frac{1}{h} \left[ \\begin{array}{cccc}
+            -1 & 1 & & \\\\
+             & \ddots & \ddots&\\\\
+             &  & -1 & 1\end{array} \\right]
+
+        .. math::
+
+            R(m) \\approx \mathbf{v}^\\top \left[\\frac{\\alpha_x}{2}\mathbf{A}_1 (\mathbf{D}_1 m) \odot (\mathbf{D}_1 m) + \\frac{\\alpha_y}{2}\mathbf{A}_2 (\mathbf{D}_2 m) \odot (\mathbf{D}_2 m) \\right]
+
+        Recall that this is really a just point wise multiplication, or a diagonal matrix times a vector. When we multiply by something in a diagonal we can interchange and it gives the same results (i.e. it is point wise)
+
+        .. math::
+
+            \mathbf{a\odot b} = \\text{diag}(\mathbf{a})\mathbf{b} = \\text{diag}(\mathbf{b})\mathbf{a} = \mathbf{b\odot a}
+
+        and the transpose also is true (but the sizes have to make sense...):
+
+        .. math::
+
+            \mathbf{a}^\\top\\text{diag}(\mathbf{b}) = \mathbf{b}^\\top\\text{diag}(\mathbf{a})
+
+        So R(m) can simplify to:
+
+        .. math::
+
+            R(m) \\approx  \mathbf{m}^\\top \left[\\frac{\\alpha_x}{2}\mathbf{D}_1^\\top \\text{diag}(\mathbf{A}_1^\\top\mathbf{v}) \mathbf{D}_1 +  \\frac{\\alpha_y}{2}\mathbf{D}_2^\\top \\text{diag}(\mathbf{A}_2^\\top \mathbf{v}) \mathbf{D}_2 \\right] \mathbf{m}
+
+        We will define W_x as:
+
+        .. math::
+
+            \mathbf{W}_x = \sqrt{\\alpha_x}\\text{diag}\left(\sqrt{\mathbf{A}_1^\\top\mathbf{v}}\\right) \mathbf{D}_1
+
+
+        And then W as a tall matrix of all of the different regularization terms:
+
+        .. math::
+
+            \mathbf{W} = \left[ \\begin{array}{c}
+            \mathbf{W}_s\\\\
+            \mathbf{W}_x\\\\
+            \mathbf{W}_y\end{array} \\right]
+
+        Then we can write
+
+        .. math::
+
+            R(m) \\approx \\frac{1}{2}\mathbf{m^\\top W^\\top W m}
+
+
     """
-    L2 Tikhonov regularization with both smallness and smoothness (first order
-    derivative) contributions.
+    smoothModel = True  #: SMOOTH and SMOOTH_MOD_DIF options
+    alpha_s  = Utils.dependentProperty('_alpha_s', 1e-6, ['_W', '_Ws'], "Smallness weight")
+    alpha_x  = Utils.dependentProperty('_alpha_x', 1.0, ['_W', '_Wx'], "Weight for the first derivative in the x direction")
+    alpha_y  = Utils.dependentProperty('_alpha_y', 1.0, ['_W', '_Wy'], "Weight for the first derivative in the y direction")
+    alpha_z  = Utils.dependentProperty('_alpha_z', 1.0, ['_W', '_Wz'], "Weight for the first derivative in the z direction")
+    alpha_xx = Utils.dependentProperty('_alpha_xx', 0.0, ['_W', '_Wxx'], "Weight for the second derivative in the x direction")
+    alpha_yy = Utils.dependentProperty('_alpha_yy', 0.0, ['_W', '_Wyy'], "Weight for the second derivative in the y direction")
+    alpha_zz = Utils.dependentProperty('_alpha_zz', 0.0, ['_W', '_Wzz'], "Weight for the second derivative in the z direction")
 
-    .. math::
-        \phi_m(\mathbf{m}) = \\alpha_s \| W_s (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
-        + \\alpha_x \| W_x \\frac{\partial}{\partial x} (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
-        + \\alpha_y \| W_y \\frac{\partial}{\partial y} (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
-        + \\alpha_z \| W_z \\frac{\partial}{\partial z} (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
-
-    Note if the key word argument `mrefInSmooth` is False, then mref is not
-    included in the smoothness contribution.
-
-    :param Mesh mesh: SimPEG mesh
-    :param Maps mapping: regularization mapping, takes the model from model space to the thing you want to regularize
-    :param numpy.ndarray indActive: active cell indices for reducing the size of differential operators in the definition of a regularization mesh
-    :param bool mrefInSmooth: (default = False) put mref in the smoothness component?
-    :param float alpha_s: (default 1e-6) smallness weight
-    :param float alpha_x: (default 1) smoothness weight for first derivative in the x-direction
-    :param float alpha_y: (default 1) smoothness weight for first derivative in the y-direction
-    :param float alpha_z: (default 1) smoothness weight for first derivative in the z-direction
-    :param float alpha_xx: (default 1) smoothness weight for second derivative in the x-direction
-    :param float alpha_yy: (default 1) smoothness weight for second derivative in the y-direction
-    :param float alpha_zz: (default 1) smoothness weight for second derivative in the z-direction
-    """
-    mrefInSmooth = False  # put mref in the smoothness contribution
-    alpha_s      = Utils.dependentProperty('_alpha_s', 1e-6, ['_W', '_Wsmall'], "Smallness weight")
-    alpha_x      = Utils.dependentProperty('_alpha_x',  1.0, ['_W', '_Wx'],     "Weight for the first derivative in the x direction")
-    alpha_y      = Utils.dependentProperty('_alpha_y',  1.0, ['_W', '_Wy'],     "Weight for the first derivative in the y direction")
-    alpha_z      = Utils.dependentProperty('_alpha_z',  1.0, ['_W', '_Wz'],     "Weight for the first derivative in the z direction")
-    alpha_xx     = Utils.dependentProperty('_alpha_xx', 0.0, ['_W', '_Wxx'],    "Weight for the second derivative in the x direction")
-    alpha_yy     = Utils.dependentProperty('_alpha_yy', 0.0, ['_W', '_Wyy'],    "Weight for the second derivative in the y direction")
-    alpha_zz     = Utils.dependentProperty('_alpha_zz', 0.0, ['_W', '_Wzz'],    "Weight for the second derivative in the z direction")
-
-    def __init__(self, mesh, mapping=None, indActive = None, **kwargs):
-        BaseRegularization.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
+    def __init__(self, mesh, mapping=None, **kwargs):
+        BaseRegularization.__init__(self, mesh, mapping=mapping, **kwargs)
 
     @property
-    def Wsmall(self):
-        """Regularization matrix Wsmall"""
-        if getattr(self,'_Wsmall', None) is None:
-            self._Wsmall = Utils.sdiag((self.regmesh.vol*self.alpha_s)**0.5)
-        return self._Wsmall
+    def Ws(self):
+        """Regularization matrix Ws"""
+        if getattr(self,'_Ws', None) is None:
+                self._Ws = Utils.sdiag((self.mesh.vol*self.alpha_s)**0.5)
+        return self._Ws
 
     @property
     def Wx(self):
         """Regularization matrix Wx"""
         if getattr(self, '_Wx', None) is None:
-            Ave_x_vol = self.regmesh.aveCC2Fx * self.regmesh.vol
-            self._Wx = Utils.sdiag((Ave_x_vol*self.alpha_x)**0.5)*self.regmesh.cellDiffx
+            Ave_x_vol = self.mesh.aveF2CC[:,:self.mesh.nFx].T*self.mesh.vol
+            self._Wx = Utils.sdiag((Ave_x_vol*self.alpha_x)**0.5)*self.mesh.cellGradx
         return self._Wx
 
     @property
     def Wy(self):
         """Regularization matrix Wy"""
         if getattr(self, '_Wy', None) is None:
-            Ave_y_vol = self.regmesh.aveCC2Fy * self.regmesh.vol
-            self._Wy = Utils.sdiag((Ave_y_vol*self.alpha_y)**0.5)*self.regmesh.cellDiffy
+            Ave_y_vol = self.mesh.aveF2CC[:,self.mesh.nFx:np.sum(self.mesh.vnF[:2])].T*self.mesh.vol
+            self._Wy = Utils.sdiag((Ave_y_vol*self.alpha_y)**0.5)*self.mesh.cellGrady
         return self._Wy
 
     @property
     def Wz(self):
         """Regularization matrix Wz"""
         if getattr(self, '_Wz', None) is None:
-            Ave_z_vol = self.regmesh.aveCC2Fz * self.regmesh.vol
-            self._Wz = Utils.sdiag((Ave_z_vol*self.alpha_z)**0.5)*self.regmesh.cellDiffz
+            Ave_z_vol = self.mesh.aveF2CC[:,np.sum(self.mesh.vnF[:2]):].T*self.mesh.vol
+            self._Wz = Utils.sdiag((Ave_z_vol*self.alpha_z)**0.5)*self.mesh.cellGradz
         return self._Wz
 
     @property
     def Wxx(self):
         """Regularization matrix Wxx"""
         if getattr(self, '_Wxx', None) is None:
-            self._Wxx = Utils.sdiag((self.regmesh.vol*self.alpha_xx)**0.5)*self.regmesh.faceDiffx*self.regmesh.cellDiffx
+            self._Wxx = Utils.sdiag((self.mesh.vol*self.alpha_xx)**0.5)*self.mesh.faceDivx*self.mesh.cellGradx
         return self._Wxx
 
     @property
     def Wyy(self):
         """Regularization matrix Wyy"""
         if getattr(self, '_Wyy', None) is None:
-            self._Wyy = Utils.sdiag((self.regmesh.vol*self.alpha_yy)**0.5)*self.regmesh.faceDiffy*self.regmesh.cellDiffy
+            self._Wyy = Utils.sdiag((self.mesh.vol*self.alpha_yy)**0.5)*self.mesh.faceDivy*self.mesh.cellGrady
         return self._Wyy
 
     @property
     def Wzz(self):
         """Regularization matrix Wzz"""
         if getattr(self, '_Wzz', None) is None:
-            self._Wzz = Utils.sdiag((self.regmesh.vol*self.alpha_zz)**0.5)*self.regmesh.faceDiffz*self.regmesh.cellDiffz
+            self._Wzz = Utils.sdiag((self.mesh.vol*self.alpha_zz)**0.5)*self.mesh.faceDivz*self.mesh.cellGradz
         return self._Wzz
 
     @property
@@ -495,9 +265,9 @@ class Tikhonov(BaseRegularization):
         """Full smoothness regularization matrix W"""
         if getattr(self, '_Wsmooth', None) is None:
             wlist = (self.Wx, self.Wxx)
-            if self.regmesh.dim > 1:
+            if self.mesh.dim > 1:
                 wlist += (self.Wy, self.Wyy)
-            if self.regmesh.dim > 2:
+            if self.mesh.dim > 2:
                 wlist += (self.Wz, self.Wzz)
             self._Wsmooth = sp.vstack(wlist)
         return self._Wsmooth
@@ -506,44 +276,25 @@ class Tikhonov(BaseRegularization):
     def W(self):
         """Full regularization matrix W"""
         if getattr(self, '_W', None) is None:
-            wlist = (self.Wsmall, self.Wsmooth)
+            wlist = (self.Ws, self.Wsmooth)
             self._W = sp.vstack(wlist)
         return self._W
 
-    @Utils.timeIt
-    def _evalSmall(self, m):
-        r = self.Wsmall * ( self.mapping * (m - self.mref) )
-        return 0.5 * r.dot(r)
-
-    @Utils.timeIt
-    def _evalSmooth(self, m):
-        if self.mrefInSmooth == True:
-            r = self.Wsmooth * ( self.mapping * (m - self.mref) )
-        elif self.mrefInSmooth == False:
-            r = self.Wsmooth * ( self.mapping * (m) )
-        return 0.5 * r.dot(r)
-
     @Utils.timeIt
     def eval(self, m):
-        return self._evalSmall(m) + self._evalSmooth(m)
+        if self.smoothModel == True:
+            r1 = self.Wsmooth * ( self.mapping * (m) )
+            r2 = self.Ws * ( self.mapping * (m - self.mref) )
+            return 0.5*(r1.dot(r1)+r2.dot(r2))
+        elif self.smoothModel == False:
+            r = self.W * ( self.mapping * (m - self.mref) )
+            return 0.5*r.dot(r)
 
-    @Utils.timeIt
-    def _evalSmallDeriv(self,m):
-        r = self.Wsmall * ( self.mapping * (m - self.mref) )
-        return r.T * ( self.Wsmall * self.mapping.deriv(m - self.mref) )
-
-    @Utils.timeIt
-    def _evalSmoothDeriv(self,m):
-        if self.mrefInSmooth == True:
-            r = self.Wsmooth * ( self.mapping * ( m - self.mref ) )
-            return r.T * ( self.Wsmooth * self.mapping.deriv(m - self.mref) )
-        elif self.mrefInSmooth == False:
-            r = self.Wsmooth * ( self.mapping * m )
-            return r.T * ( self.Wsmooth * self.mapping.deriv(m) )
 
     @Utils.timeIt
     def evalDeriv(self, m):
         """
+
         The regularization is:
 
         .. math::
@@ -557,185 +308,17 @@ class Tikhonov(BaseRegularization):
             R(m) = \mathbf{W^\\top W (m-m_\\text{ref})}
 
         """
-        return self._evalSmallDeriv(m) + self._evalSmoothDeriv(m)
+        if self.smoothModel == True:
+            mD1 = self.mapping.deriv(m)
+            mD2 = self.mapping.deriv(m - self.mref)
+            r1 = self.Wsmooth * ( self.mapping * (m)) 
+            r2 = self.Ws * ( self.mapping * (m - self.mref) )
+            out1 = mD1.T * ( self.Wsmooth.T * r1 )
+            out2 = mD2.T * ( self.Ws.T * r2 )
+            out = out1+out2
+        elif self.smoothModel == False:
+            mD = self.mapping.deriv(m - self.mref)
+            r = self.W * ( self.mapping * (m - self.mref) )
+            out = mD.T * ( self.W.T * r )
+        return out
 
-
-class Simple(Tikhonov):
-    """
-    Simple regularization that does not include length scales in the derivatives.
-    """
-
-    mrefInSmooth = False  #: SMOOTH and SMOOTH_MOD_DIF options
-    alpha_s     = Utils.dependentProperty('_alpha_s', 1.0, ['_W', '_Wsmall'], "Smallness weight")
-    alpha_x     = Utils.dependentProperty('_alpha_x', 1.0, ['_W', '_Wx'], "Weight for the first derivative in the x direction")
-    alpha_y     = Utils.dependentProperty('_alpha_y', 1.0, ['_W', '_Wy'], "Weight for the first derivative in the y direction")
-    alpha_z     = Utils.dependentProperty('_alpha_z', 1.0, ['_W', '_Wz'], "Weight for the first derivative in the z direction")
-    wght        = 1.
-
-    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
-        BaseRegularization.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
-
-        if isinstance(self.wght,float):
-            self.wght = np.ones(self.regmesh.nC) * self.wght
-
-    @property
-    def Wsmall(self):
-        """Regularization matrix Wsmall"""
-        if getattr(self,'_Wsmall', None) is None:
-            self._Wsmall = Utils.sdiag((self.regmesh.vol*self.alpha_s*self.wght)**0.5)
-        return self._Wsmall
-
-    @property
-    def Wx(self):
-        """Regularization matrix Wx"""
-        if getattr(self, '_Wx', None) is None:
-            self._Wx = Utils.sdiag((self.regmesh.aveCC2Fx * self.regmesh.vol*self.alpha_x*(self.regmesh.aveCC2Fx*self.wght))**0.5)*self.regmesh.cellDiffxStencil
-        return self._Wx
-
-    @property
-    def Wy(self):
-        """Regularization matrix Wy"""
-        if getattr(self, '_Wy', None) is None:
-            self._Wy = Utils.sdiag((self.regmesh.aveCC2Fy * self.regmesh.vol * self.alpha_y*(self.regmesh.aveCC2Fy*self.wght))**0.5)*self.regmesh.cellDiffyStencil
-        return self._Wy
-
-    @property
-    def Wz(self):
-        """Regularization matrix Wz"""
-        if getattr(self, '_Wz', None) is None:
-            self._Wz = Utils.sdiag((self.regmesh.aveCC2Fz * self.regmesh.vol*self.alpha_z*(self.regmesh.aveCC2Fz*self.wght))**0.5)*self.regmesh.cellDiffzStencil
-        return self._Wz
-
-    @property
-    def Wsmooth(self):
-        """Full smoothness regularization matrix W"""
-        if getattr(self, '_Wsmooth', None) is None:
-            wlist = (self.Wx,)
-            if self.regmesh.dim > 1:
-                wlist += (self.Wy,)
-            if self.regmesh.dim > 2:
-                wlist += (self.Wz,)
-            self._Wsmooth = sp.vstack(wlist)
-        return self._Wsmooth
-
-    @property
-    def W(self):
-        """Full regularization matrix W"""
-        if getattr(self, '_W', None) is None:
-            wlist = (self.Wsmall, self.Wsmooth)
-            self._W = sp.vstack(wlist)
-        return self._W
-
-    @Utils.timeIt
-    def _evalSmall(self, m):
-        r = self.Wsmall * ( self.mapping * (m - self.mref) )
-        return 0.5 * r.dot(r)
-
-    @Utils.timeIt
-    def _evalSmooth(self, m):
-        if self.mrefInSmooth == True:
-            r = self.Wsmooth * ( self.mapping * (m - self.mref) )
-        elif self.mrefInSmooth == False:
-            r = self.Wsmooth * ( self.mapping * m)
-        return 0.5 * r.dot(r)
-
-
-class Sparse(Simple):
-
-    # set default values
-    eps_p      = 1e-1
-    eps_q      = 1e-1
-    curModel = None # use a model to compute the weights
-    gamma    = 1.
-    norms    = [0., 2., 2., 2.]
-    wght     = 1.
-
-    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
-        Simple.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
-
-        if isinstance(self.wght,float):
-            self.wght = np.ones(self.regmesh.nC) * self.wght
-
-    @property
-    def Wsmall(self):
-        """Regularization matrix Wsmall"""
-        if getattr(self, 'curModel', None) is None:
-            self.Rs = Utils.speye(self.regmesh.nC)
-
-        else:
-            f_m = self.curModel - self.reg.mref
-            self.rs = self.R(f_m , self.eps_p, self.norms[0])
-            #print "Min rs: " + str(np.max(self.rs)) + "Max rs: " + str(np.min(self.rs))
-            self.Rs = Utils.sdiag( self.rs )
-
-        return Utils.sdiag((self.regmesh.vol*self.alpha_s*self.gamma*self.wght)**0.5)*self.Rs
-
-
-    @property
-    def Wx(self):
-        """Regularization matrix Wx"""
-
-        if getattr(self, 'curModel', None) is None:
-            self.Rx = Utils.speye(self.regmesh.cellDiffxStencil.shape[0])
-
-        else:
-            f_m = self.regmesh.cellDiffxStencil * self.curModel
-            self.rx = self.R( f_m , self.eps_q, self.norms[1])
-            self.Rx = Utils.sdiag( self.rx )
-
-        return Utils.sdiag(( (self.regmesh.aveCC2Fx * self.regmesh.vol) *self.alpha_x*self.gamma*(self.regmesh.aveCC2Fx*self.wght))**0.5)*self.Rx*self.regmesh.cellDiffxStencil
-
-    @property
-    def Wy(self):
-        """Regularization matrix Wy"""
-
-        if getattr(self, 'curModel', None) is None:
-            self.Ry = Utils.speye(self.regmesh.cellDiffyStencil.shape[0])
-
-        else:
-            f_m = self.regmesh.cellDiffyStencil * self.curModel
-            self.ry = self.R( f_m , self.eps_q, self.norms[2])
-            self.Ry = Utils.sdiag( self.ry )
-
-        return Utils.sdiag(((self.regmesh.aveCC2Fy * self.regmesh.vol)*self.alpha_y*self.gamma*(self.regmesh.aveCC2Fy*self.wght))**0.5)*self.Ry*self.regmesh.cellDiffyStencil
-
-    @property
-    def Wz(self):
-        """Regularization matrix Wz"""
-
-        if getattr(self, 'curModel', None) is None:
-            self.Rz = Utils.speye(self.regmesh.cellDiffzStencil.shape[0])
-
-        else:
-            f_m = self.regmesh.cellDiffzStencil * self.curModel
-            self.rz = self.R( f_m , self.eps_q, self.norms[3])
-            self.Rz = Utils.sdiag( self.rz )
-
-        return Utils.sdiag(((self.regmesh.aveCC2Fz * self.regmesh.vol)*self.alpha_z*self.gamma*(self.regmesh.aveCC2Fz*self.wght))**0.5)*self.Rz*self.regmesh.cellDiffzStencil
-
-    @property
-    def Wsmooth(self):
-        """Full smoothness regularization matrix W"""
-        #if getattr(self, '_Wsmooth', None) is None:
-        wlist = (self.Wx,)
-        if self.regmesh.dim > 1:
-            wlist += (self.Wy,)
-        if self.regmesh.dim > 2:
-            wlist += (self.Wz,)
-        #self._Wsmooth = sp.vstack(wlist)
-        return sp.vstack(wlist)
-
-    @property
-    def W(self):
-        """Full regularization matrix W"""
-        if getattr(self, '_W', None) is None:
-            wlist = (self.Wsmall, self.Wsmooth)
-            self._W = sp.vstack(wlist)
-        return self._W
-
-    def R(self, f_m , eps, exponent):
-
-        eta = (eps**(1.-exponent/2.))**0.5
-        r = eta / (f_m**2.+ eps**2.)**((1.-exponent/2.)/2.)
-
-        return r