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 ipywidgets 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)
 
@@ -144,18 +144,12 @@ class BetaSchedule(InversionDirective):
             if self.debug: print 'BetaSchedule is cooling Beta. Iteration: %d' % self.opt.iter
             self.invProb.beta /= self.coolingFactor
 
-
 class TargetMisfit(InversionDirective):
 
-    chifact = 1.
-    phi_d_star = None
-
     @property
     def target(self):
         if getattr(self, '_target', None) is None:
-            if self.phi_d_star is None:
-                self.phi_d_star = 0.5 * self.survey.nD
-            self._target = self.chifact * self.phi_d_star # the factor of 0.5 is because we do phid = 0.5*|| dpred - dobs||^2
+            self._target = self.survey.nD
         return self._target
     @target.setter
     def target(self, val):
@@ -212,219 +206,17 @@ 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):
-    """
-    Saves inversion parameters at every iteraion.
 
 
-    """
 
-    def initialize(self):
-        print "SimPEG.SaveOutputDictEveryIteration will save your inversion progress as dictionary: '###-%s.npz'"%self.fileName
+# class UpdateReferenceModel(Parameter):
 
-    def endIter(self):
+#     mref0 = None
 
-        # Initialize the output dict
-        outDict = {}
-        # Save the data.
-        outDict['iter'] = self.opt.iter
-        outDict['beta'] = self.invProb.beta
-        outDict['phi_d'] = self.invProb.phi_d
-        outDict['phi_ms'] = self.reg._evalSmall(self.invProb.curModel)
-        outDict['phi_mx'] = self.reg._evalSmoothx(self.invProb.curModel)
-        outDict['phi_my'] = self.reg._evalSmoothy(self.invProb.curModel) if self.prob.mesh.dim >= 2 else 'NaN'
-        outDict['phi_mz'] = self.reg._evalSmoothz(self.invProb.curModel) if self.prob.mesh.dim==3 else 'NaN'
-        outDict['f'] = self.opt.f
-        outDict['m'] = self.invProb.curModel
-        outDict['dpred'] = self.invProb.dpred
-
-        # Save the file as a npz
-        np.savez('{:03d}-{:s}'.format(self.opt.iter,self.fileName), outDict)
-
-class Update_IRLS(InversionDirective):
-
-    eps_min = None
-    eps_p = None
-    eps_q = None
-    norms = [2.,2.,2.,2.]
-    factor = None
-    gamma = None
-    phi_m_last = None
-    phi_d_last = None
-    f_old = None
-    f_min_change = 1e-2
-    beta_tol = 5e-2
-
-    # Solving parameter for IRLS (mode:2)
-    IRLSiter   = 0
-    minGNiter = 5
-    maxIRLSiter = 10
-    iterStart = 0
-
-    # Beta schedule
-    coolingFactor = 2.
-    coolingRate = 1
-
-    mode = 1
-
-    @property
-    def target(self):
-        if getattr(self, '_target', None) is None:
-            self._target = self.survey.nD*0.5
-        return self._target
-    @target.setter
-    def target(self, val):
-        self._target = val
-
-    def initialize(self):
-
-        if self.mode == 1:
-            self.reg.norms = [2., 2., 2., 2.]
-
-    def endIter(self):
-
-        # After reaching target misfit with l2-norm, switch to IRLS (mode:2)
-        if self.invProb.phi_d < self.target and self.mode == 1:
-            print "Convergence with smooth l2-norm regularization: Start IRLS steps..."
-
-            self.mode = 2
-            print self.eps_p, self.eps_q, self.norms
-            self.reg.eps_p = self.eps_p
-            self.reg.eps_q = self.eps_q
-            self.reg.norms = self.norms
-            self.coolingFactor = 1.
-            self.coolingRate = 1
-            self.iterStart = self.opt.iter
-            self.phi_d_last = self.invProb.phi_d
-            self.phi_m_last = self.invProb.phi_m_last
-
-            self.reg.l2model = self.invProb.curModel
-            self.reg.curModel = self.invProb.curModel
-
-            if getattr(self, 'f_old', None) is None:
-                self.f_old = self.reg.eval(self.invProb.curModel)#self.invProb.evalFunction(self.invProb.curModel, return_g=False, return_H=False)
-
-        # Beta Schedule
-        if self.opt.iter > 0 and self.opt.iter % self.coolingRate == 0:
-            if self.debug: print 'BetaSchedule is cooling Beta. Iteration: %d' % self.opt.iter
-            self.invProb.beta /= self.coolingFactor
-
-
-        # Only update after GN iterations
-        if (self.opt.iter-self.iterStart) % self.minGNiter == 0 and self.mode==2:
-
-            self.IRLSiter += 1
-
-            phim_new = self.reg.eval(self.invProb.curModel)
-            self.f_change = np.abs(self.f_old - phim_new) / self.f_old
-
-            print "Regularization decrease: %6.3e" % (self.f_change)
-
-            # Check for maximum number of IRLS cycles
-            if self.IRLSiter == self.maxIRLSiter:
-                print "Reach maximum number of IRLS cycles: %i" % self.maxIRLSiter
-                self.opt.stopNextIteration = True
-                return
-
-            # Check if the function has changed enough
-            if self.f_change < self.f_min_change and self.IRLSiter > 1:
-                print "Minimum decrease in regularization. End of IRLS"
-                self.opt.stopNextIteration = True
-                return
-            else:
-                self.f_old = phim_new
-
-            # 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
-
-            # Reset the regularization matrices so that it is
-            # recalculated for current model
-            self.reg._Wsmall = None
-            self.reg._Wx = None
-            self.reg._Wy = None
-            self.reg._Wz = None
-
-             # 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
-
-            # Reset the regularization matrices again for new gamma
-            self.reg._Wsmall = None
-            self.reg._Wx = None
-            self.reg._Wy = None
-            self.reg._Wz = None
-
-            # Check if misfit is within the tolerance, otherwise scale beta
-            val = self.invProb.phi_d / (self.survey.nD*0.5)
-
-            if np.abs(1.-val) > self.beta_tol:
-                self.invProb.beta = self.invProb.beta * self.survey.nD*0.5 / self.invProb.phi_d
-
-class Update_lin_PreCond(InversionDirective):
-    """
-    Create a Jacobi preconditioner for the linear problem
-    """
-    onlyOnStart=False
-
-    def initialize(self):
-
-        if getattr(self.opt, 'approxHinv', None) is 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((self.prob.mapping.deriv(None).T *diagA)**-1.)
-            self.opt.approxHinv = PC
-
-    def endIter(self):
-        # Cool the threshold parameter
-        if self.onlyOnStart==True:
-            return
-
-        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((self.prob.mapping.deriv(None).T *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
+#     def nextIter(self):
+#         mref = getattr(self, 'm_prev', None)
+#         if mref is None:
+#             if self.debug: print 'UpdateReferenceModel is using mref0'
+#             mref = self.mref0
+#         self.m_prev = self.invProb.m_current
+#         return mref

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/DC.py

@@ -1,118 +0,0 @@
-import numpy as np
-from scipy.constants import mu_0, pi
-from scipy import special
-
-def DCAnalyticHalf(txloc, rxlocs, sigma, earth_type="wholespace"):
-    """
-        Analytic solution for electric potential from a postive pole
-
-        :param array txloc: a xyz location of A (+) electrode (np.r_[xa, ya, za])
-        :param list rxlocs: xyz locations of M (+) and N (-) electrodes [M, N]
-
-            e.g.
-            rxlocs = [M, N]
-            M: xyz locations of M (+) electrode (np.c_[xmlocs, ymlocs, zmlocs])
-            N: xyz locations of N (-) electrode (np.c_[xnlocs, ynlocs, znlocs])
-
-        :param float or complex sigma: values of conductivity
-        :param string earth_type: values of conductivity ("wholsespace" or "halfspace")
-
-    """
-    M = rxlocs[0]
-    N = rxlocs[1]
-
-    rM = np.sqrt( (M[:,0]-txloc[0])**2 + (M[:,1]-txloc[1])**2 + (M[:,2]-txloc[1])**2 )
-    rN = np.sqrt( (N[:,0]-txloc[0])**2 + (N[:,1]-txloc[1])**2 + (N[:,2]-txloc[1])**2 )
-
-    phiM = 1./(4*np.pi*rM*sigma)
-    phiN = 1./(4*np.pi*rN*sigma)
-    phi = phiM - phiN
-
-    if earth_type == "halfspace":
-        phi *= 2
-
-    return phi
-
-deg2rad  = lambda deg: deg/180.*np.pi
-rad2deg  = lambda rad: rad*180./np.pi
-
-def DCAnalyticSphere(txloc, rxloc, xc, radius, sigma, sigma1, \
-                 field_type = "secondary", order=12, halfspace=False):
-# def DCSpherePointCurrent(txloc, rxloc, xc, radius, rho, rho1, \
-#                  field_type = "secondary", order=12):
-    """
-
-        Parameters:
-
-            :param array txloc: A (+) current electrode location (x,y,z)
-            :param array xc: x center of depressed sphere
-            :param array rxloc: M(+) electrode locations / (Nx3 array, # of electrodes)
-
-            :param float radius: radius (float): radius of the sphere (m)
-            :param float rho: resistivity of the background (ohm-m)
-            :param float rho1: resistivity of the sphere
-            :param string field_type: : "secondary", "total", "primary"
-                  (default="secondary")
-                  "secondary": secondary potential only due to sphere
-                  "primary": primary potential from the point source
-                  "total": "secondary"+"primary"
-            :param float order: maximum order of Legendre polynomial (default=12)
-
-        Written by Seogi Kang (skang@eos.ubc.ca)
-        Ph.D. Candidate of University of British Columbia, Canada
-
-    """
-
-    Pleg = []
-    # Compute Legendre Polynomial
-    for i in range(order):
-        Pleg.append(special.legendre(i, monic=0))
-
-
-    rho = 1./sigma
-    rho1 = 1./sigma1
-
-    # Center of the sphere should be aligned in txloc in y-direction
-    yc = txloc[1]
-    xyz = np.c_[rxloc[:,0]-xc, rxloc[:,1]-yc, rxloc[:,2]]
-    r = np.sqrt( (xyz**2).sum(axis=1) )
-
-    x0 = abs(txloc[0]-xc)
-
-    costheta = xyz[:,0]/r * (txloc[0]-xc)/x0
-    phi = np.zeros_like(r)
-    R = (r**2+x0**2.-2.*r*x0*costheta)**0.5
-    # primary potential in a whole space
-    prim = rho*1./(4*np.pi*R)
-
-    if field_type =="primary":
-        return prim
-
-    sphind = r < radius
-    out = np.zeros_like(r)
-    for n in range(order):
-        An, Bn = AnBnfun(n, radius, x0, rho, rho1)
-        dumout = An*r[~sphind]**(-n-1.)*Pleg[n](costheta[~sphind])
-        out[~sphind] += dumout
-        dumin = Bn*r[sphind]**(n)*Pleg[n](costheta[sphind])
-        out[sphind] += dumin
-
-    out[~sphind] += prim[~sphind]
-
-    if halfspace:
-        scale = 2
-    else:
-        scale = 1
-
-    if field_type == "secondary":
-        return scale*(out-prim)
-    elif field_type == "total":
-        return scale*out
-
-def AnBnfun(n, radius, x0, rho, rho1, I=1.):
-    const = I*rho/(4*np.pi)
-    bunmo = n*rho + (n+1)*rho1
-    An = const * radius**(2*n+1) / x0 ** (n+1.) * n * \
-        (rho1-rho) / bunmo
-    Bn = const * 1. / x0 ** (n+1.) * (2*n+1) * (rho1) / bunmo
-    return An, Bn

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,4 +0,0 @@
-from TDEM import hzAnalyticDipoleT
-from FDEM import hzAnalyticDipoleF
-from FDEMcasing import *
-from DC import DCAnalyticHalf, DCAnalyticSphere

SimPEG/EM/Base.py

@@ -1,231 +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 MeI(self):
-        """
-            Edge inner product matrix
-        """
-        if getattr(self, '_MeI', None) is None:
-            self._MeI = self.mesh.getEdgeInnerProduct(invMat=True)
-        return self._MeI
-
-    @property
-    def Mf(self):
-        """
-            Face inner product matrix
-        """
-        if getattr(self, '_Mf', None) is None:
-            self._Mf = self.mesh.getFaceInnerProduct()
-        return self._Mf
-
-    @property
-    def MfI(self):
-        """
-            Face inner product matrix
-        """
-        if getattr(self, '_MfI', None) is None:
-            self._MfI = self.mesh.getFaceInnerProduct(invMat=True)
-        return self._MfI
-
-    @property
-    def Vol(self):
-        if getattr(self, '_Vol', None) is None:
-            self._Vol = Utils.sdiag(self.mesh.vol)
-        return self._Vol
-
-    # ----- 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)
-        return dMeSigmaI_dI * ( dMe_dsig * self.curModel.sigmaDeriv )
-
-    @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) * 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.
-        """
-
-        dMfRhoI_dI = -self.MfRhoI**2
-        dMf_drho = self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u)
-        return dMfRhoI_dI * ( dMf_drho * 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, f):
-        """
-        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, f)
-        return data
-
-    def evalDeriv(self, f):
-        raise Exception('Use Receivers to project fields deriv.')

SimPEG/EM/FDEM/ProblemFDEM.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, Fields3D_e, Fields3D_b, Fields3D_h, Fields3D_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:`Problem3D_e`
-        or :code:`Problem3D_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:`Problem3D_j` or :code:`Problem3D_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, '_{0}Deriv'.format(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, '_{0}Deriv'.format(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?
-                    if rx.component is 'real':
-                        Jtv +=   np.array(df_dmT, dtype=complex).real
-                    elif rx.component 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)
-            #Why are you adding?
-            s_m[:,i] = s_m[:,i] + smi
-            s_e[:,i] = s_e[:,i] + sei
-
-        return s_m, s_e
-
-
-##########################################################################################
-################################ E-B Formulation #########################################
-##########################################################################################
-
-class Problem3D_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    = Fields3D_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 Problem3D_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    = Fields3D_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 Problem3D_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    = Fields3D_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 Problem3D_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    = Fields3D_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/RxFDEM.py

@@ -1,126 +0,0 @@
-import SimPEG
-from SimPEG import sp
-
-class BaseRx(SimPEG.Survey.BaseRx):
-    """
-    Frequency domain receiver base class
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        assert(orientation in ['x','y','z']), "Orientation %s not known. Orientation must be in 'x', 'y', 'z'. Arbitrary orientations have not yet been implemented."%orientation
-        assert(component in ['real', 'imag']), "'component' must be 'real' or 'imag', not %s"%component
-
-        self.projComp = orientation
-        self.component = component
-
-        SimPEG.Survey.BaseRx.__init__(self, locs, rxType=None) #TODO: remove rxType from baseRx
-
-    def projGLoc(self, u):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        return u._GLoc(self.projField) + self.projComp
-
-    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
-        """
-
-        P = self.getP(mesh, self.projGLoc(f))
-        f_part_complex = f[src, self.projField]
-        f_part = getattr(f_part_complex, self.component) # get the real or imag component
-
-        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
-            Pv = getattr(Pv_complex, self.component)
-        elif adjoint:
-            Pv_real = P.T * v
-
-            if self.component == 'imag':
-                Pv = 1j*Pv_real
-            elif self.component == 'real':
-                Pv = Pv_real.astype(complex)
-            else:
-                raise NotImplementedError('must be real or imag')
-
-        return Pv
-
-
-class Point_e(BaseRx):
-    """
-    Electric field FDEM receiver
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        self.projField = 'e'
-        super(Point_e, self).__init__(locs, orientation, component)
-
-
-class Point_b(BaseRx):
-    """
-    Magnetic flux FDEM receiver
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        self.projField = 'b'
-        super(Point_b, self).__init__(locs, orientation, component)
-
-
-class Point_h(BaseRx):
-    """
-    Magnetic field FDEM receiver
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        self.projField = 'h'
-        super(Point_h, self).__init__(locs, orientation, component)
-
-
-class Point_j(BaseRx):
-    """
-    Current density FDEM receiver
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        self.projField = 'j'
-        super(Point_j, self).__init__(locs, orientation, component)

SimPEG/EM/FDEM/SrcFDEM.py

@@ -1,618 +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
-    integrate = False
-    _ePrimary = None
-    _bPrimary = None
-    _hPrimary = None
-    _jPrimary = None
-
-    def __init__(self, rxList, **kwargs):
-        Survey.BaseSrc.__init__(self, rxList, **kwargs)
-
-    def eval(self, prob):
-        """
-        - :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
-        """
-        if self._bPrimary is None:
-            return Zero()
-        return self._bPrimary
-
-    def hPrimary(self, prob):
-        """
-        Primary magnetic field
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary magnetic field
-        """
-        if self._hPrimary is None:
-            return Zero()
-        return self._hPrimary
-
-    def ePrimary(self, prob):
-        """
-        Primary electric field
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary electric field
-        """
-        if self._ePrimary is None:
-            return Zero()
-        return self._ePrimary
-
-    def jPrimary(self, prob):
-        """
-        Primary current density
-
-        :param Problem prob: FDEM Problem
-        :rtype: numpy.ndarray
-        :return: primary current density
-        """
-        if self._jPrimary is None:
-            return Zero()
-        return self._jPrimary
-
-    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) [False]
-    """
-
-    def __init__(self, rxList, freq, s_e, **kwargs):
-        self._s_e = np.array(s_e, dtype=complex)
-        self.freq = float(freq)
-
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    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) [False]
-    """
-
-    def __init__(self, rxList, freq, s_m, **kwargs):  #ePrimary=Zero(), bPrimary=Zero(), hPrimary=Zero(), jPrimary=Zero()):
-        self._s_m = np.array(s_m, dtype=complex)
-        self.freq = float(freq)
-
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    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) [False]
-    """
-    def __init__(self, rxList, freq, s_m, s_e, **kwargs):
-        self._s_m = np.array(s_m, dtype=complex)
-        self._s_e = np.array(s_e, dtype=complex)
-        self.freq = float(freq)
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    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, **kwargs):
-        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
-        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 = MagneticLoopVectorPotential(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,62 +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
-import RxFDEM as Rx
-from SimPEG import sp
-
-class Survey(BaseEMSurvey):
-    """
-    Frequency domain electromagnetic survey
-
-    :param list srcList: list of FDEM sources used in the survey
-    """
-
-    srcPair = Src.BaseSrc
-    rxPair = Rx.BaseRx
-
-    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,5 +0,0 @@
-from SurveyFDEM import Survey
-import SrcFDEM as Src
-import RxFDEM as Rx
-from ProblemFDEM import Problem3D_e, Problem3D_b, Problem3D_j, Problem3D_h
-from FieldsFDEM import Fields3D_e, Fields3D_b, Fields3D_j, Fields3D_h

SimPEG/EM/Static/DC/BoundaryUtils.py

@@ -1,160 +0,0 @@
-import numpy as np
-
-def getxBCyBC_CC(mesh, alpha, beta, gamma):
-# def getxBCyBC(mesh, alpha, beta, gamma):
-    """
-    This is a subfunction generating mixed-boundary condition:
-
-    .. math::
-
-        \nabla \cdot \vec{j} = -\nabla \cdot \vec{j}_s = q
-
-        \rho \vec{j} = -\nabla \phi \phi
-
-        \alpha \phi + \beta \frac{\partial \phi}{\partial r} = \gamma \ at \ r = \partial \Omega
-
-        xBC = f_1(\alpha, \beta, \gamma)
-        yBC = f(\alpha, \beta, \gamma)
-
-    Computes xBC and yBC for cell-centered discretizations
-    """
-    if mesh.dim == 1: #1D
-        if (len(alpha) != 2 or len(beta) != 2 or len(gamma) != 2):
-            raise Exception("Lenght of list, alpha should be 2")
-        fCCxm,fCCxp = mesh.cellBoundaryInd
-        nBC = fCCxm.sum()+fCCxp.sum()
-        h_xm, h_xp = mesh.gridCC[fCCxm], mesh.gridCC[fCCxp]
-
-        alpha_xm, beta_xm, gamma_xm = alpha[0], beta[0], gamma[0]
-        alpha_xp, beta_xp, gamma_xp = alpha[1], beta[1], gamma[1]
-
-        # h_xm, h_xp = mesh.gridCC[fCCxm], mesh.gridCC[fCCxp]
-        h_xm, h_xp = mesh.hx[0], mesh.hx[-1]
-
-        a_xm = gamma_xm/(0.5*alpha_xm-beta_xm/h_xm)
-        b_xm = (0.5*alpha_xm+beta_xm/h_xm)/(0.5*alpha_xm-beta_xm/h_xm)
-        a_xp = gamma_xp/(0.5*alpha_xp-beta_xp/h_xp)
-        b_xp = (0.5*alpha_xp+beta_xp/h_xp)/(0.5*alpha_xp-beta_xp/h_xp)
-
-        xBC_xm = 0.5*a_xm
-        xBC_xp = 0.5*a_xp/b_xp
-        yBC_xm = 0.5*(1.-b_xm)
-        yBC_xp = 0.5*(1.-1./b_xp)
-
-        xBC = np.r_[xBC_xm, xBC_xp]
-        yBC = np.r_[yBC_xm, yBC_xp]
-
-    elif mesh.dim == 2: #2D
-        if (len(alpha) != 4 or len(beta) != 4 or len(gamma) != 4):
-            raise Exception("Lenght of list, alpha should be 4")
-
-        fxm,fxp,fym,fyp = mesh.faceBoundaryInd
-        nBC = fxm.sum()+fxp.sum()+fxm.sum()+fxp.sum()
-
-        alpha_xm, beta_xm, gamma_xm = alpha[0], beta[0], gamma[0]
-        alpha_xp, beta_xp, gamma_xp = alpha[1], beta[1], gamma[1]
-        alpha_ym, beta_ym, gamma_ym = alpha[2], beta[2], gamma[2]
-        alpha_yp, beta_yp, gamma_yp = alpha[3], beta[3], gamma[3]
-
-        # h_xm, h_xp = mesh.gridCC[fCCxm,0], mesh.gridCC[fCCxp,0]
-        # h_ym, h_yp = mesh.gridCC[fCCym,1], mesh.gridCC[fCCyp,1]
-
-        h_xm, h_xp = mesh.hx[0]*np.ones_like(alpha_xm), mesh.hx[-1]*np.ones_like(alpha_xp)
-        h_ym, h_yp = mesh.hy[0]*np.ones_like(alpha_ym), mesh.hy[-1]*np.ones_like(alpha_yp)
-
-        a_xm = gamma_xm/(0.5*alpha_xm-beta_xm/h_xm)
-        b_xm = (0.5*alpha_xm+beta_xm/h_xm)/(0.5*alpha_xm-beta_xm/h_xm)
-        a_xp = gamma_xp/(0.5*alpha_xp-beta_xp/h_xp)
-        b_xp = (0.5*alpha_xp+beta_xp/h_xp)/(0.5*alpha_xp-beta_xp/h_xp)
-
-        a_ym = gamma_ym/(0.5*alpha_ym-beta_ym/h_ym)
-        b_ym = (0.5*alpha_ym+beta_ym/h_ym)/(0.5*alpha_ym-beta_ym/h_ym)
-        a_yp = gamma_yp/(0.5*alpha_yp-beta_yp/h_yp)
-        b_yp = (0.5*alpha_yp+beta_yp/h_yp)/(0.5*alpha_yp-beta_yp/h_yp)
-
-        xBC_xm = 0.5*a_xm
-        xBC_xp = 0.5*a_xp/b_xp
-        yBC_xm = 0.5*(1.-b_xm)
-        yBC_xp = 0.5*(1.-1./b_xp)
-        xBC_ym = 0.5*a_ym
-        xBC_yp = 0.5*a_yp/b_yp
-        yBC_ym = 0.5*(1.-b_ym)
-        yBC_yp = 0.5*(1.-1./b_yp)
-
-        sortindsfx = np.argsort(np.r_[np.arange(mesh.nFx)[fxm], np.arange(mesh.nFx)[fxp]])
-        sortindsfy = np.argsort(np.r_[np.arange(mesh.nFy)[fym], np.arange(mesh.nFy)[fyp]])
-
-        xBC_x = np.r_[xBC_xm, xBC_xp][sortindsfx]
-        xBC_y = np.r_[xBC_ym, xBC_yp][sortindsfy]
-        yBC_x = np.r_[yBC_xm, yBC_xp][sortindsfx]
-        yBC_y = np.r_[yBC_ym, yBC_yp][sortindsfy]
-
-        xBC = np.r_[xBC_x, xBC_y]
-        yBC = np.r_[yBC_x, yBC_y]
-
-    elif mesh.dim == 3: #3D
-        if (len(alpha) != 6 or len(beta) != 6 or len(gamma) != 6):
-            raise Exception("Lenght of list, alpha should be 6")
-        # fCCxm,fCCxp,fCCym,fCCyp,fCCzm,fCCzp = mesh.cellBoundaryInd
-        fxm,fxp,fym,fyp,fzm,fzp = mesh.faceBoundaryInd
-        nBC = fxm.sum()+fxp.sum()+fxm.sum()+fxp.sum()
-
-        alpha_xm, beta_xm, gamma_xm = alpha[0], beta[0], gamma[0]
-        alpha_xp, beta_xp, gamma_xp = alpha[1], beta[1], gamma[1]
-        alpha_ym, beta_ym, gamma_ym = alpha[2], beta[2], gamma[2]
-        alpha_yp, beta_yp, gamma_yp = alpha[3], beta[3], gamma[3]
-        alpha_zm, beta_zm, gamma_zm = alpha[4], beta[4], gamma[4]
-        alpha_zp, beta_zp, gamma_zp = alpha[5], beta[5], gamma[5]
-
-        # h_xm, h_xp = mesh.gridCC[fCCxm,0], mesh.gridCC[fCCxp,0]
-        # h_ym, h_yp = mesh.gridCC[fCCym,1], mesh.gridCC[fCCyp,1]
-        # h_zm, h_zp = mesh.gridCC[fCCzm,2], mesh.gridCC[fCCzp,2]
-
-        h_xm, h_xp = mesh.hx[0]*np.ones_like(alpha_xm), mesh.hx[-1]*np.ones_like(alpha_xp)
-        h_ym, h_yp = mesh.hy[0]*np.ones_like(alpha_ym), mesh.hy[-1]*np.ones_like(alpha_yp)
-        h_zm, h_zp = mesh.hz[0]*np.ones_like(alpha_zm), mesh.hz[-1]*np.ones_like(alpha_zp)
-
-        a_xm = gamma_xm/(0.5*alpha_xm-beta_xm/h_xm)
-        b_xm = (0.5*alpha_xm+beta_xm/h_xm)/(0.5*alpha_xm-beta_xm/h_xm)
-        a_xp = gamma_xp/(0.5*alpha_xp-beta_xp/h_xp)
-        b_xp = (0.5*alpha_xp+beta_xp/h_xp)/(0.5*alpha_xp-beta_xp/h_xp)
-
-        a_ym = gamma_ym/(0.5*alpha_ym-beta_ym/h_ym)
-        b_ym = (0.5*alpha_ym+beta_ym/h_ym)/(0.5*alpha_ym-beta_ym/h_ym)
-        a_yp = gamma_yp/(0.5*alpha_yp-beta_yp/h_yp)
-        b_yp = (0.5*alpha_yp+beta_yp/h_yp)/(0.5*alpha_yp-beta_yp/h_yp)
-
-        a_zm = gamma_zm/(0.5*alpha_zm-beta_zm/h_zm)
-        b_zm = (0.5*alpha_zm+beta_zm/h_zm)/(0.5*alpha_zm-beta_zm/h_zm)
-        a_zp = gamma_zp/(0.5*alpha_zp-beta_zp/h_zp)
-        b_zp = (0.5*alpha_zp+beta_zp/h_zp)/(0.5*alpha_zp-beta_zp/h_zp)
-
-        xBC_xm = 0.5*a_xm
-        xBC_xp = 0.5*a_xp/b_xp
-        yBC_xm = 0.5*(1.-b_xm)
-        yBC_xp = 0.5*(1.-1./b_xp)
-        xBC_ym = 0.5*a_ym
-        xBC_yp = 0.5*a_yp/b_yp
-        yBC_ym = 0.5*(1.-b_ym)
-        yBC_yp = 0.5*(1.-1./b_yp)
-        xBC_zm = 0.5*a_zm
-        xBC_zp = 0.5*a_zp/b_zp
-        yBC_zm = 0.5*(1.-b_zm)
-        yBC_zp = 0.5*(1.-1./b_zp)
-
-        sortindsfx = np.argsort(np.r_[np.arange(mesh.nFx)[fxm], np.arange(mesh.nFx)[fxp]])
-        sortindsfy = np.argsort(np.r_[np.arange(mesh.nFy)[fym], np.arange(mesh.nFy)[fyp]])
-        sortindsfz = np.argsort(np.r_[np.arange(mesh.nFz)[fzm], np.arange(mesh.nFz)[fzp]])
-
-        xBC_x = np.r_[xBC_xm, xBC_xp][sortindsfx]
-        xBC_y = np.r_[xBC_ym, xBC_yp][sortindsfy]
-        xBC_z = np.r_[xBC_zm, xBC_zp][sortindsfz]
-
-        yBC_x = np.r_[yBC_xm, yBC_xp][sortindsfx]
-        yBC_y = np.r_[yBC_ym, yBC_yp][sortindsfy]
-        yBC_z = np.r_[yBC_zm, yBC_zp][sortindsfz]
-
-        xBC = np.r_[xBC_x, xBC_y, xBC_z]
-        yBC = np.r_[yBC_x, yBC_y, yBC_z]
-
-    return xBC, yBC

SimPEG/EM/Static/DC/FieldsDC.py

@@ -1,148 +0,0 @@
-import SimPEG
-from SimPEG.Utils import Identity, Zero
-import numpy as np
-from scipy.constants import epsilon_0
-
-class Fields(SimPEG.Problem.Fields):
-    knownFields = {}
-    dtype = float
-
-    def _phiDeriv(self, src, du_dm_v, v, adjoint=False):
-        if getattr(self, '_phiDeriv_u', None) is None or getattr(self, '_phiDeriv_m', None) is None:
-            raise NotImplementedError ('Getting phiDerivs from %s is not implemented' %self.knownFields.keys()[0])
-
-        if adjoint:
-            return self._phiDeriv_u(src, v, adjoint=adjoint), self._phiDeriv_m(src, v, adjoint=adjoint)
-
-        return np.array(self._phiDeriv_u(src, du_dm_v, adjoint) + self._phiDeriv_m(src, v, adjoint), dtype = float)
-
-    def _eDeriv(self, src, du_dm_v, v, adjoint=False):
-        if getattr(self, '_eDeriv_u', None) is None or getattr(self, '_eDeriv_m', None) is None:
-            raise NotImplementedError ('Getting eDerivs from %s is not implemented' %self.knownFields.keys()[0])
-
-        if adjoint:
-            return self._eDeriv_u(src, v, adjoint), self._eDeriv_m(src, v, adjoint)
-        return np.array(self._eDeriv_u(src, du_dm_v, adjoint) + self._eDeriv_m(src, v, adjoint), dtype = float)
-
-    def _jDeriv(self, src, du_dm_v, v, adjoint=False):
-        if getattr(self, '_jDeriv_u', None) is None or getattr(self, '_jDeriv_m', None) is None:
-            raise NotImplementedError ('Getting jDerivs from %s is not implemented' %self.knownFields.keys()[0])
-
-        if adjoint:
-            return self._jDeriv_u(src, v, adjoint), self._jDeriv_m(src, v, adjoint)
-        return np.array(self._jDeriv_u(src, du_dm_v, adjoint) + self._jDeriv_m(src, v, adjoint), dtype = float)
-
-
-class Fields_CC(Fields):
-    knownFields = {'phiSolution':'CC'}
-    aliasFields = {
-                    'phi': ['phiSolution','CC','_phi'],
-                    'j' : ['phiSolution','F','_j'],
-                    'e' : ['phiSolution','F','_e'],
-                    'charge' : ['phiSolution','CC','_charge'],
-                  }
-                  # primary - secondary
-                  # CC variables
-
-    def __init__(self, mesh, survey, **kwargs):
-        Fields.__init__(self, mesh, survey, **kwargs)
-        mesh.setCellGradBC("neumann")
-        cellGrad = mesh.cellGrad
-    def startup(self):
-        self.prob = self.survey.prob
-
-    def _GLoc(self, fieldType):
-        if fieldType == 'phi':
-            return 'CC'
-        elif fieldType == 'e' or fieldType == 'j':
-            return 'F'
-        else:
-            raise Exception('Field type must be phi, e, j')
-
-    def _phi(self, phiSolution, srcList):
-        return phiSolution
-
-    def _phiDeriv_u(self, src, v, adjoint = False):
-        return Identity()*v
-
-    def _phiDeriv_m(self, src, v, adjoint = False):
-        return Zero()
-
-    def _j(self, phiSolution, srcList):
-        """
-            .. math::
-                \mathbf{j} = \mathbf{M}^{f \ -1}_{\rho} \mathbf{G} \phi
-        """
-        return self.prob.MfRhoI*self.prob.Grad*phiSolution
-
-    def _e(self, phiSolution, srcList):
-        """
-            In HJ formulation e is not well-defined!!
-            .. math::
-                \vec{e} = -\nabla \phi
-        """
-        return -self.mesh.cellGrad*phiSolution
-
-    def _charge(self, phiSolution, srcList):
-        """
-            .. math::
-                \int \nabla \codt \vec{e} =  \int \frac{\rho_v }{\epsillon_0}
-        """
-        return epsilon_0*self.prob.Vol*(self.mesh.faceDiv*self._e(phiSolution, srcList))
-
-class Fields_N(Fields):
-    knownFields = {'phiSolution':'N'}
-    aliasFields = {
-                    'phi': ['phiSolution','N','_phi'],
-                    'j' : ['phiSolution','E','_j'],
-                    'e' : ['phiSolution','E','_e'],
-                    'charge' : ['phiSolution','N','_charge'],
-                  }
-                  # primary - secondary
-                  # N variables
-
-    def __init__(self, mesh, survey, **kwargs):
-        Fields.__init__(self, mesh, survey, **kwargs)
-
-    def startup(self):
-        self.prob = self.survey.prob
-
-    def _GLoc(self, fieldType):
-        if fieldType == 'phi':
-            return 'N'
-        elif fieldType == 'e' or fieldType == 'j':
-            return 'E'
-        else:
-            raise Exception('Field type must be phi, e, j')
-
-    def _phi(self, phiSolution, srcList):
-        return phiSolution
-
-    def _phiDeriv_u(self, src, v, adjoint = False):
-        return Identity()*v
-
-    def _phiDeriv_m(self, src, v, adjoint = False):
-        return Zero()
-
-    def _j(self, phiSolution, srcList):
-        """
-            In EB formulation j is not well-defined!!
-            .. math::
-                \mathbf{j} = - \mathbf{M}^{e}_{\sigma} \mathbf{G} \phi
-        """
-        return self.prob.MeSigma * self._e(phiSolution, srcList)
-
-    def _e(self, phiSolution, srcList):
-        """
-            In HJ formulation e is not well-defined!!
-            .. math::
-                \vec{e} = -\nabla \phi
-        """
-        return -self.mesh.nodalGrad * phiSolution
-
-    def _charge(self, phiSolution, srcList):
-        """
-            .. math::
-                \int \nabla \codt \vec{e} =  \int \frac{\rho_v }{\epsillon_0}
-        """
-        return - epsilon_0*(self.mesh.nodalGrad.T*self.mesh.getEdgeInnerProduct()*self._e(phiSolution, srcList))

SimPEG/EM/Static/DC/FieldsDC_2D.py

@@ -1,146 +0,0 @@
-import SimPEG
-from SimPEG.Utils import Identity, Zero
-import numpy as np
-
-class Fields_ky(SimPEG.Problem.TimeFields):
-
-    """
-
-    Fancy Field Storage for a 2.5D code.
-
-    u[:,'phi', kyInd] = phi
-    print u[src0,'phi']
-
-    Only one field type is stored for
-    each problem, the rest are computed. The fields obejct acts like an array and is indexed by
-    .. code-block:: python
-        f = problem.fields(m)
-        e = f[srcList,'e']
-        j = f[srcList,'j']
-
-    If accessing all sources for a given field, use the :code:`:`
-    .. code-block:: python
-        f = problem.fields(m)
-        phi = f[:,'phi']
-        e = f[:,'e']
-        b = f[:,'b']
-    The array returned will be size (nE or nF, nSrcs :math:`\\times` nFrequencies)
-    """
-
-    knownFields = {}
-    dtype = float
-
-    def _phiDeriv(self,kyInd, src, du_dm_v, v, adjoint=False):
-        if getattr(self, '_phiDeriv_u', None) is None or getattr(self, '_phiDeriv_m', None) is None:
-            raise NotImplementedError ('Getting phiDerivs from %s is not implemented' %self.knownFields.keys()[0])
-
-        if adjoint:
-            return self._phiDeriv_u(kyInd, src, v, adjoint=adjoint), self._phiDeriv_m(kyInd, src, v, adjoint=adjoint)
-
-        return np.array(self._phiDeriv_u(kyInd, src, du_dm_v, adjoint) + self._phiDeriv_m(kyInd, src, v, adjoint), dtype = float)
-
-    def _eDeriv(self,kyInd, src, du_dm_v, v, adjoint=False):
-        if getattr(self, '_eDeriv_u', None) is None or getattr(self, '_eDeriv_m', None) is None:
-            raise NotImplementedError ('Getting eDerivs from %s is not implemented' %self.knownFields.keys()[0])
-
-        if adjoint:
-            return self._eDeriv_u(kyInd, src, v, adjoint), self._eDeriv_m(kyInd, src, v, adjoint)
-        return np.array(self._eDeriv_u(kyInd, src, du_dm_v, adjoint) + self._eDeriv_m(kyInd, src, v, adjoint), dtype = float)
-
-    def _jDeriv(self,kyInd, src, du_dm_v, v, adjoint=False):
-        if getattr(self, '_jDeriv_u', None) is None or getattr(self, '_jDeriv_m', None) is None:
-            raise NotImplementedError ('Getting jDerivs from %s is not implemented' %self.knownFields.keys()[0])
-
-        if adjoint:
-            return self._jDeriv_u(kyInd, src, v, adjoint), self._jDeriv_m(kyInd, src, v, adjoint)
-        return np.array(self._jDeriv_u(kyInd, src, du_dm_v, adjoint) + self._jDeriv_m(kyInd, src, v, adjoint), dtype = float)
-
-
-    # def _eDeriv(self, tInd, src, dun_dm_v, v, adjoint=False):
-    #     if adjoint is True:
-    #         return self._eDeriv_u(tInd, src, v, adjoint), self._eDeriv_m(tInd, src, v, adjoint)
-    #     return self._eDeriv_u(tInd, src, dun_dm_v) + self._eDeriv_m(tInd, src, v)
-
-    # def _bDeriv(self, tInd, src, dun_dm_v, v, adjoint=False):
-    #     if adjoint is True:
-    #         return self._bDeriv_u(tInd, src, v, adjoint), self._bDeriv_m(tInd, src, v, adjoint)
-    #     return self._bDeriv_u(tInd, src, dun_dm_v) + self._bDeriv_m(tInd, src, v)
-
-
-class Fields_ky_CC(Fields_ky):
-    knownFields = {'phiSolution':'CC'}
-    aliasFields = {
-                    'phi': ['phiSolution','CC','_phi'],
-                    'j' : ['phiSolution','F','_j'],
-                    'e' : ['phiSolution','F','_e'],
-                  }
-                  # primary - secondary
-                  # CC variables
-
-    def __init__(self, mesh, survey, **kwargs):
-        Fields_ky.__init__(self, mesh, survey, **kwargs)
-
-    def startup(self):
-        self.prob = self.survey.prob
-
-    def _GLoc(self, fieldType):
-        if fieldType == 'phi':
-            return 'CC'
-        elif fieldType == 'e' or fieldType == 'j':
-            return 'F'
-        else:
-            raise Exception('Field type must be phi, e, j')
-
-    def _phi(self, phiSolution, src, kyInd):
-        return phiSolution
-
-    def _phiDeriv_u(self, kyInd, src, v, adjoint = False):
-        return Identity()*v
-
-    def _phiDeriv_m(self, kyInd, src, v, adjoint = False):
-        return Zero()
-
-    def _j(self, phiSolution, srcList):
-        raise NotImplementedError
-
-    def _e(self, phiSolution, srcList):
-        raise NotImplementedError
-
-class Fields_ky_N(Fields_ky):
-    knownFields = {'phiSolution':'N'}
-    aliasFields = {
-                    'phi': ['phiSolution','N','_phi'],
-                    'j' : ['phiSolution','E','_j'],
-                    'e' : ['phiSolution','E','_e'],
-                  }
-                  # primary - secondary
-                  # CC variables
-
-    def __init__(self, mesh, survey, **kwargs):
-        Fields_ky.__init__(self, mesh, survey, **kwargs)
-
-    def startup(self):
-        self.prob = self.survey.prob
-
-    def _GLoc(self, fieldType):
-        if fieldType == 'phi':
-            return 'N'
-        elif fieldType == 'e' or fieldType == 'j':
-            return 'E'
-        else:
-            raise Exception('Field type must be phi, e, j')
-
-    def _phi(self, phiSolution, src, kyInd):
-        return phiSolution
-
-    def _phiDeriv_u(self, kyInd, src, v, adjoint = False):
-        return Identity()*v
-
-    def _phiDeriv_m(self, kyInd, src, v, adjoint = False):
-        return Zero()
-
-    def _j(self, phiSolution, srcList):
-        raise NotImplementedError
-
-    def _e(self, phiSolution, srcList):
-        raise NotImplementedError

SimPEG/EM/Static/DC/ProblemDC.py

@@ -1,296 +0,0 @@
-from SimPEG import Problem, Utils
-from SimPEG.EM.Base import BaseEMProblem
-from SurveyDC import Survey
-from FieldsDC import Fields, Fields_CC, Fields_N
-from SimPEG.Utils import sdiag
-import numpy as np
-from SimPEG.Utils import Zero
-from BoundaryUtils import getxBCyBC_CC
-
-class BaseDCProblem(BaseEMProblem):
-
-    surveyPair = Survey
-    fieldsPair = Fields
-    Ainv = None
-
-    def fields(self, m):
-        self.curModel = m
-
-        if not self.Ainv == None:
-            self.Ainv.clean()
-
-        f = self.fieldsPair(self.mesh, self.survey)
-        A = self.getA()
-        self.Ainv = self.Solver(A, **self.solverOpts)
-        RHS = self.getRHS()
-        u = self.Ainv * RHS
-        Srcs = self.survey.srcList
-        f[Srcs, self._solutionType] = u
-        return f
-
-    def Jvec(self, m, v, f=None):
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-
-        Jv = self.dataPair(self.survey) #same size as the data
-
-        A = self.getA()
-
-        for src in self.survey.srcList:
-            u_src = f[src, self._solutionType] # solution vector
-            dA_dm_v = self.getADeriv(u_src, v)
-            dRHS_dm_v = self.getRHSDeriv(src, v)
-            du_dm_v = self.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)
-        return Utils.mkvc(Jv)
-
-    def Jtvec(self, m, v, f=None):
-        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)
-        AT = self.getA()
-
-
-        for src in self.survey.srcList:
-            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 = self.Ainv * df_duT
-
-                dA_dmT = self.getADeriv(u_src, ATinvdf_duT, adjoint=True)
-                dRHS_dmT = self.getRHSDeriv(src, ATinvdf_duT, adjoint=True)
-                du_dmT = -dA_dmT + dRHS_dmT
-                Jtv += (df_dmT + du_dmT).astype(float)
-
-        return Utils.mkvc(Jtv)
-
-    def getSourceTerm(self):
-        """
-        takes concept of source and turns it into a matrix
-        """
-        """
-        Evaluates the sources, and puts them in matrix form
-
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: q (nC or nN, nSrc)
-        """
-
-        Srcs = self.survey.srcList
-
-        if self._formulation is 'EB':
-            n = self.mesh.nN
-            # return NotImplementedError
-
-        elif self._formulation is 'HJ':
-            n = self.mesh.nC
-
-        q = np.zeros((n, len(Srcs)))
-
-        for i, src in enumerate(Srcs):
-            q[:,i] = src.eval(self)
-        return q
-
-class Problem3D_CC(BaseDCProblem):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'HJ' # CC potentials means J is on faces
-    fieldsPair    = Fields_CC
-
-    def __init__(self, mesh, **kwargs):
-        BaseDCProblem.__init__(self, mesh, **kwargs)
-        self.setBC()
-
-    def getA(self):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = D MfRhoI G
-
-        """
-
-        D = self.Div
-        G = self.Grad
-        MfRhoI = self.MfRhoI
-        A = D * MfRhoI * G
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return V.T * A
-        return A
-
-    def getADeriv(self, u, v, adjoint= False):
-
-        D = self.Div
-        G = self.Grad
-        MfRhoIDeriv = self.MfRhoIDeriv
-
-        if adjoint:
-            return(MfRhoIDeriv( G * u ).T) * ( D.T * v)
-
-        return D * (MfRhoIDeriv( G * u ) * v)
-
-    def getRHS(self):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm()
-
-        return RHS
-
-    def getRHSDeriv(self, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-    def setBC(self):
-        if self.mesh.dim==3:
-            fxm,fxp,fym,fyp,fzm,fzp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-            gBFzm = self.mesh.gridFz[fzm,:]
-            gBFzp = self.mesh.gridFz[fzp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-            temp_zm, temp_zp = np.ones_like(gBFzm[:,2]), np.ones_like(gBFzp[:,2])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-            alpha_zm, alpha_zp = temp_zm*0., temp_zp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-            beta_zm, beta_zp = temp_zm, temp_zp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-            gamma_zm, gamma_zp = temp_zm*0., temp_zp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp, alpha_zm, alpha_zp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp, beta_zm, beta_zp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp, gamma_zm, gamma_zp]
-
-        elif self.mesh.dim==2:
-
-            fxm,fxp,fym,fyp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp]
-
-        x_BC, y_BC = getxBCyBC_CC(self.mesh, alpha, beta, gamma)
-        V = self.Vol
-        self.Div = V * self.mesh.faceDiv
-        P_BC, B = self.mesh.getBCProjWF_simple()
-        M = B*self.mesh.aveCC2F
-        self.Grad = self.Div.T - P_BC*Utils.sdiag(y_BC)*M
-
-
-class Problem3D_N(BaseDCProblem):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'EB' # N potentials means B is on faces
-    fieldsPair    = Fields_N
-
-    def __init__(self, mesh, **kwargs):
-        BaseDCProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = G.T MeSigma G
-
-        """
-
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        A = Grad.T * MeSigma * Grad
-
-        # Handling Null space of A
-        A[0,0] = A[0,0] + 1.
-
-        return A
-
-    def getADeriv(self, u, v, adjoint=False):
-        """
-
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        """
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        if not adjoint:
-            return Grad.T*(self.MeSigmaDeriv(Grad*u)*v)
-        elif adjoint:
-            return self.MeSigmaDeriv(Grad*u).T * (Grad*v)
-
-
-    def getRHS(self):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm()
-        return RHS
-
-    def getRHSDeriv(self, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-
-
-

SimPEG/EM/Static/DC/ProblemDC_2D.py

@@ -1,349 +0,0 @@
-from SimPEG import Problem, Utils
-from SimPEG.EM.Base import BaseEMProblem
-from SurveyDC import Survey, Survey_ky
-from FieldsDC_2D import Fields_ky, Fields_ky_CC, Fields_ky_N
-from SimPEG.Utils import sdiag
-import numpy as np
-from SimPEG.Utils import Zero
-from BoundaryUtils import getxBCyBC_CC
-
-class BaseDCProblem_2D(BaseEMProblem):
-
-    surveyPair = Survey_ky
-    fieldsPair = Fields_ky
-    nky = 15
-    kys = np.logspace(-4, 1, nky)
-    Ainv = [None for i in range(nky)]
-    nT = nky # Only for using TimeFields
-
-    def fields(self, m):
-        self.curModel = m
-
-        if not self.Ainv[0] == None:
-            for i in range(self.nky):
-                self.Ainv[i].clean()
-
-        f = self.fieldsPair(self.mesh, self.survey)
-        Srcs = self.survey.srcList
-        for iky in range(self.nky):
-            ky = self.kys[iky]
-            A = self.getA(ky)
-            self.Ainv[iky] = self.Solver(A, **self.solverOpts)
-            RHS = self.getRHS(ky)
-            u = self.Ainv[iky] * RHS
-            f[Srcs, self._solutionType, iky] = u
-        return f
-
-    def Jvec(self, m, v, f=None):
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-
-        Jv = self.dataPair(self.survey) #same size as the data
-        Jv0 = self.dataPair(self.survey)
-
-        # Assume y=0.
-        # This needs some thoughts to implement in general when src is dipole
-        dky = np.diff(self.kys)
-        dky = np.r_[dky[0], dky]
-        y = 0.
-
-        #TODO: this loop is pretty slow .. (Parellize)
-        for iky in range(self.nky):
-            ky = self.kys[iky]
-            A = self.getA(ky)
-            for src in self.survey.srcList:
-                u_src = f[src, self._solutionType, iky] # solution vector
-                dA_dm_v = self.getADeriv(ky, u_src, v)
-                dRHS_dm_v = self.getRHSDeriv(ky, src, v)
-                du_dm_v = self.Ainv[iky] * ( - dA_dm_v + dRHS_dm_v )
-                for rx in src.rxList:
-                    df_dmFun = getattr(f, '_%sDeriv'%rx.projField, None)
-                    df_dm_v = df_dmFun(iky, src, du_dm_v, v, adjoint=False)
-                    # Trapezoidal intergration
-                    Jv1_temp = 1./np.pi*rx.evalDeriv(ky, src, self.mesh, f, df_dm_v)
-                    if iky==0:
-                        #First assigment
-                        Jv[src, rx] = Jv1_temp*dky[iky]*np.cos(ky*y)
-                    else:
-                        Jv[src, rx] += Jv1_temp*dky[iky]    /2.*np.cos(ky*y)
-                        Jv[src, rx] += Jv0[src, rx]*dky[iky]/2.*np.cos(ky*y)
-                    Jv0[src, rx] = Jv1_temp.copy()
-        return Utils.mkvc(Jv)
-
-    def Jtvec(self, m, v, f=None):
-        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, dtype=float)
-
-        # Assume y=0.
-        # This needs some thoughts to implement in general when src is dipole
-        dky = np.diff(self.kys)
-        dky = np.r_[dky[0], dky]
-        y = 0.
-
-        for src in self.survey.srcList:
-            for rx in src.rxList:
-                Jtv_temp1 = np.zeros(m.size, dtype=float)
-                Jtv_temp0 = np.zeros(m.size, dtype=float)
-                #TODO: this loop is pretty slow .. (Parellize)
-                for iky in range(self.nky):
-                    u_src = f[src, self._solutionType, iky]
-                    ky = self.kys[iky]
-                    AT = self.getA(ky)
-                    PTv = rx.evalDeriv(ky, 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(iky, src, None, PTv, adjoint=True)
-
-                    ATinvdf_duT = self.Ainv[iky] * df_duT
-
-                    dA_dmT = self.getADeriv(ky, u_src, ATinvdf_duT, adjoint=True)
-                    dRHS_dmT = self.getRHSDeriv(ky, src, ATinvdf_duT, adjoint=True)
-                    du_dmT = -dA_dmT + dRHS_dmT
-                    Jtv_temp1 = 1./np.pi*(df_dmT + du_dmT).astype(float)
-                    # Trapezoidal intergration
-                    if iky==0:
-                        #First assigment
-                        Jtv += Jtv_temp1*dky[iky]*np.cos(ky*y)
-                    else:
-                        Jtv += Jtv_temp1*dky[iky]/2.*np.cos(ky*y)
-                        Jtv += Jtv_temp0*dky[iky]/2.*np.cos(ky*y)
-                    Jtv_temp0 = Jtv_temp1.copy()
-        return Utils.mkvc(Jtv)
-
-    def getSourceTerm(self, ky):
-        """
-        takes concept of source and turns it into a matrix
-        """
-        """
-        Evaluates the sources, and puts them in matrix form
-
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: q (nC or nN, nSrc)
-        """
-
-        Srcs = self.survey.srcList
-
-        if self._formulation is 'EB':
-            n = self.mesh.nN
-            # return NotImplementedError
-
-        elif self._formulation is 'HJ':
-            n = self.mesh.nC
-
-        q = np.zeros((n, len(Srcs)))
-
-        for i, src in enumerate(Srcs):
-            q[:,i] = src.eval(self)
-        return q
-
-class Problem2D_CC(BaseDCProblem_2D):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'HJ' # CC potentials means J is on faces
-    fieldsPair    = Fields_ky_CC
-
-    def __init__(self, mesh, **kwargs):
-        BaseDCProblem_2D.__init__(self, mesh, **kwargs)
-        self.setBC()
-
-    def getA(self, ky):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = D MfRhoI G
-
-        """
-
-        D = self.Div
-        G = self.Grad
-        vol = self.mesh.vol
-        MfRhoI = self.MfRhoI
-        # Get resistivity rho
-        rho = self.curModel.rho
-        A = D * MfRhoI * G + Utils.sdiag(ky**2*vol/rho)
-        return A
-
-    def getADeriv(self, ky, u, v, adjoint= False):
-
-        D = self.Div
-        G = self.Grad
-        vol = self.mesh.vol
-        MfRhoIDeriv = self.MfRhoIDeriv
-        rho = self.curModel.rho
-        if adjoint:
-            return(MfRhoIDeriv( G * u ).T) * ( D.T * v) + ky**2*Utils.sdiag(u.flatten()*vol*(-1./rho**2))*v
-        return D * ((MfRhoIDeriv( G * u )) * v) + ky**2*Utils.sdiag(u.flatten()*vol*(-1./rho**2))*v
-
-    def getRHS(self, ky):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm(ky)
-        return RHS
-
-    def getRHSDeriv(self, ky, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, ky, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-    def setBC(self):
-        if self.mesh.dim==3:
-            fxm,fxp,fym,fyp,fzm,fzp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-            gBFzm = self.mesh.gridFz[fzm,:]
-            gBFzp = self.mesh.gridFz[fzp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-            temp_zm, temp_zp = np.ones_like(gBFzm[:,2]), np.ones_like(gBFzp[:,2])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-            alpha_zm, alpha_zp = temp_zm*0., temp_zp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-            beta_zm, beta_zp = temp_zm, temp_zp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-            gamma_zm, gamma_zp = temp_zm*0., temp_zp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp, alpha_zm, alpha_zp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp, beta_zm, beta_zp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp, gamma_zm, gamma_zp]
-
-        elif self.mesh.dim==2:
-
-            fxm,fxp,fym,fyp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp]
-
-        x_BC, y_BC = getxBCyBC_CC(self.mesh, alpha, beta, gamma)
-        V = self.Vol
-        self.Div = V * self.mesh.faceDiv
-        P_BC, B = self.mesh.getBCProjWF_simple()
-        M = B*self.mesh.aveCC2F
-        self.Grad = self.Div.T - P_BC*Utils.sdiag(y_BC)*M
-
-class Problem2D_N(BaseDCProblem_2D):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'EB' # CC potentials means J is on faces
-    fieldsPair    = Fields_ky_N
-
-    def __init__(self, mesh, **kwargs):
-        BaseDCProblem_2D.__init__(self, mesh, **kwargs)
-        # self.setBC()
-
-    @property
-    def MnSigma(self):
-        """
-            Node inner product matrix for \\(\\sigma\\). Used in the E-B formulation
-        """
-        # TODO: only works isotropic sigma
-        sigma = self.curModel.sigma
-        vol = self.mesh.vol
-        MnSigma = Utils.sdiag(self.mesh.aveN2CC.T*(Utils.sdiag(vol)*sigma))
-
-        return MnSigma
-
-    def MnSigmaDeriv(self, u):
-        """
-            Derivative of MnSigma with respect to the model
-        """
-        sigma = self.curModel.sigma
-        sigmaderiv = self.curModel.sigmaDeriv
-        vol = self.mesh.vol
-        return Utils.sdiag(u)*self.mesh.aveN2CC.T*Utils.sdiag(vol) * self.curModel.sigmaDeriv
-
-    def getA(self, ky):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = D MfRhoI G
-
-        """
-
-        MeSigma = self.MeSigma
-        MnSigma = self.MnSigma
-        Grad = self.mesh.nodalGrad
-        # Get conductivity sigma
-        sigma = self.curModel.sigma
-        A = Grad.T * MeSigma * Grad + ky**2*MnSigma
-
-        # Handling Null space of A
-        A[0,0] = A[0,0] + 1.
-        return A
-
-    def getADeriv(self, ky, u, v, adjoint= False):
-
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        sigma = self.curModel.sigma
-        vol = self.mesh.vol
-
-        if adjoint:
-            return self.MeSigmaDeriv(Grad*u).T * (Grad*v) + ky**2*self.MnSigmaDeriv(u).T*v
-        return Grad.T*(self.MeSigmaDeriv(Grad*u)*v) + ky**2*self.MnSigmaDeriv(u)*v
-
-    def getRHS(self, ky):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm(ky)
-        return RHS
-
-    def getRHSDeriv(self, ky, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, ky, adjoint=adjoint)
-        # return qDeriv
-        return Zero()

SimPEG/EM/Static/DC/RxDC.py

@@ -1,129 +0,0 @@
-import SimPEG
-import numpy as np
-from SimPEG.Utils import Zero, closestPoints
-
-class BaseRx(SimPEG.Survey.BaseRx):
-    locs = None
-    rxType = None
-
-    knownRxTypes = {
-                    'phi':['phi',None],
-                    'ex':['e','x'],
-                    'ey':['e','y'],
-                    'ez':['e','z'],
-                    'jx':['j','x'],
-                    'jy':['j','y'],
-                    'jz':['j','z'],
-                    }
-
-    def __init__(self, locs, rxType, **kwargs):
-        SimPEG.Survey.BaseRx.__init__(self, locs, rxType, **kwargs)
-
-
-    @property
-    def projField(self):
-        """Field Type projection (e.g. e b ...)"""
-        return self.knownRxTypes[self.rxType][0]
-
-    def projGLoc(self, f):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        comp = self.knownRxTypes[self.rxType][1]
-        if comp is not None:
-            return f._GLoc(self.rxType) + comp
-        return f._GLoc(self.rxType)
-
-    def eval(self, src, mesh, f):
-        P = self.getP(mesh, self.projGLoc(f))
-        return P*f[src, self.projField]
-
-    def evalDeriv(self, src, mesh, f, v, adjoint=False):
-        P = self.getP(mesh, self.projGLoc(f))
-        if not adjoint:
-            return P*v
-        elif adjoint:
-            return P.T*v
-
-# DC.Rx.Dipole(locs)
-class Dipole(BaseRx):
-
-    def __init__(self, locsM, locsN, rxType = 'phi', **kwargs):
-        assert locsM.shape == locsN.shape, 'locsM and locsN need to be the same size'
-        locs = [locsM, locsN]
-        # We may not need this ...
-        BaseRx.__init__(self, locs, rxType)
-
-    @property
-    def nD(self):
-        """Number of data in the receiver."""
-        return self.locs[0].shape[0]
-
-        # Not sure why ...
-        # return int(self.locs[0].size / 2)
-
-
-    def getP(self, mesh, Gloc):
-        if mesh in self._Ps:
-            return self._Ps[mesh]
-
-        P0 = mesh.getInterpolationMat(self.locs[0], Gloc)
-        P1 = mesh.getInterpolationMat(self.locs[1], Gloc)
-        P = P0 - P1
-
-        if self.storeProjections:
-            self._Ps[mesh] = P
-
-        return P
-
-
-class Dipole_ky(BaseRx):
-
-    def __init__(self, locsM, locsN, rxType = 'phi', **kwargs):
-        assert locsM.shape == locsN.shape, 'locsM and locsN need to be the same size'
-        locs = [locsM, locsN]
-        # We may not need this ...
-        BaseRx.__init__(self, locs, rxType)
-
-    @property
-    def nD(self):
-        """Number of data in the receiver."""
-        return self.locs[0].shape[0]
-
-        # Not sure why ...
-        # return int(self.locs[0].size / 2)
-
-    def getP(self, mesh, Gloc):
-        if mesh in self._Ps:
-            return self._Ps[mesh]
-
-        P0 = mesh.getInterpolationMat(self.locs[0], Gloc)
-        P1 = mesh.getInterpolationMat(self.locs[1], Gloc)
-        P = P0 - P1
-        if self.storeProjections:
-            self._Ps[mesh] = P
-        return P
-
-    def eval(self, kys, src, mesh, f):
-        P = self.getP(mesh, self.projGLoc(f))
-        Pf = P*f[src, self.projField,:]
-        return self.IntTrapezoidal(kys, Pf, y=0.)
-
-    def evalDeriv(self, ky, src, mesh, f, v, adjoint=False):
-        P = self.getP(mesh, self.projGLoc(f))
-        if not adjoint:
-            return P*v
-        elif adjoint:
-            return P.T*v
-
-    def IntTrapezoidal(self, kys, Pf, y=0.):
-        phi = np.zeros(Pf.shape[0])
-        nky = kys.size
-        dky = np.diff(kys)
-        dky = np.r_[dky[0], dky]
-        phi0 = 1./np.pi*Pf[:,0]
-        for iky in range(nky):
-            phi1 = 1./np.pi*Pf[:,iky]
-            phi += phi1*dky[iky]/2.*np.cos(kys[iky]*y)
-            phi += phi0*dky[iky]/2.*np.cos(kys[iky]*y)
-            phi0 = phi1.copy()
-        return phi
-

SimPEG/EM/Static/DC/SrcDC.py

@@ -1,86 +0,0 @@
-import SimPEG
-# from SimPEG.EM.Base import BaseEMSurvey
-from SimPEG.Utils import Zero, closestPoints, mkvc
-import numpy as np
-
-class BaseSrc(SimPEG.Survey.BaseSrc):
-
-    current = 1.0
-    loc = None
-
-    def __init__(self, rxList, **kwargs):
-        SimPEG.Survey.BaseSrc.__init__(self, rxList, **kwargs)
-
-    def eval(self, prob):
-        raise NotImplementedError
-
-    def evalDeriv(self, prob):
-        return Zero()
-
-
-class Dipole(BaseSrc):
-
-    def __init__(self, rxList, locA, locB, **kwargs):
-        assert locA.shape == locB.shape, 'Shape of locA and locB should be the same'
-        self.loc = [locA, locB]
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    def eval(self, prob):
-        if prob._formulation == 'HJ':
-            inds = closestPoints(prob.mesh, self.loc, gridLoc='CC')
-            q = np.zeros(prob.mesh.nC)
-            q[inds] = self.current * np.r_[1., -1.]
-        elif prob._formulation == 'EB':
-            qa = prob.mesh.getInterpolationMat(self.loc[0], locType='N').todense()
-            qb = -prob.mesh.getInterpolationMat(self.loc[1], locType='N').todense()
-            q = self.current * mkvc(qa+qb)
-        return q
-
-class Pole(BaseSrc):
-
-    def __init__(self, rxList, loc, **kwargs):
-        BaseSrc.__init__(self, rxList, loc=loc, **kwargs)
-
-    def eval(self, prob):
-        if prob._formulation == 'HJ':
-            inds = closestPoints(prob.mesh, self.loc)
-            q = np.zeros(prob.mesh.nC)
-            q[inds] = self.current * np.r_[1.]
-        elif prob._formulation == 'EB':
-            q = prob.mesh.getInterpolationMat(self.loc, locType='N').todense()
-            q = self.current * mkvc(q)
-        return q
-
-
-# class Dipole_ky(BaseSrc):
-
-#     def __init__(self, rxList, locA, locB, **kwargs):
-#         assert locA.shape == locB.shape, 'Shape of locA and locB should be the same'
-#         self.loc = [locA[[0,2]], locB[[0,2]]]
-#         BaseSrc.__init__(self, rxList, **kwargs)
-
-#     def eval(self, prob):
-#         if prob._formulation == 'HJ':
-#             inds = closestPoints(prob.mesh, self.loc, gridLoc='CC')
-#             q = np.zeros(prob.mesh.nC)
-#             q[inds] = self.current * np.r_[1., -1.]
-#         elif prob._formulation == 'EB':
-#             qa = prob.mesh.getInterpolationMat(self.loc[0], locType='N').todense()
-#             qb = -prob.mesh.getInterpolationMat(self.loc[1], locType='N').todense()
-#             q = self.current * mkvc(qa+qb)
-#         return q
-
-# class Pole_ky(BaseSrc):
-
-#     def __init__(self, rxList, loc, **kwargs):
-#         BaseSrc.__init__(self, rxList, loc=loc, **kwargs)
-
-#     def eval(self, prob):
-#         if prob._formulation == 'HJ':
-#             inds = closestPoints(prob.mesh, self.loc[[0,2]])
-#             q = np.zeros(prob.mesh.nC)
-#             q[inds] = self.current * np.r_[1.]
-#         elif prob._formulation == 'EB':
-#             q = prob.mesh.getInterpolationMat(self.loc[[0,2]], locType='N').todense()
-#             q = self.current * mkvc(q)
-#         return q

SimPEG/EM/Static/DC/SurveyDC.py

@@ -1,38 +0,0 @@
-import SimPEG
-from SimPEG.EM.Base import BaseEMSurvey
-from SimPEG import sp, Survey
-from SimPEG.Utils import Zero, Identity
-from RxDC import BaseRx
-from SrcDC import BaseSrc
-
-class Survey(BaseEMSurvey):
-    rxPair  = BaseRx
-    srcPair = BaseSrc
-
-    def __init__(self, srcList, **kwargs):
-        self.srcList = srcList
-        BaseEMSurvey.__init__(self, srcList, **kwargs)
-
-class Survey_ky(BaseEMSurvey):
-    rxPair  = BaseRx
-    srcPair = BaseSrc
-
-    def __init__(self, srcList, **kwargs):
-        self.srcList = srcList
-        BaseEMSurvey.__init__(self, srcList, **kwargs)
-
-    def eval(self, f):
-        """
-        Project fields to receiver locations
-        :param Fields u: fields object
-        :rtype: numpy.ndarray
-        :return: data
-        """
-        data = SimPEG.Survey.Data(self)
-        kys = self.prob.kys
-        for src in self.srcList:
-            for rx in src.rxList:
-                data[src, rx] = rx.eval(kys, src, self.mesh, f)
-        return data
-
-

SimPEG/EM/Static/DC/Utils.py

@@ -1,38 +0,0 @@
-import numpy as np
-
-def WennerSrcList(nElecs, aSpacing, in2D=False, plotIt=False):
-
-    import SimPEG.EM.Static.DC 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.Rx.Dipole(getLoc(i,1).reshape([1,-1]),getLoc(i,2).reshape([1,-1]))
-        src = DC.Src.Dipole([rx], getLoc(i,0),getLoc(i,3))
-        srcList += [src]
-
-    return srcList

SimPEG/EM/Static/DC/__init__.py

@@ -1,8 +0,0 @@
-from ProblemDC import Problem3D_CC, Problem3D_N
-from ProblemDC_2D import Problem2D_CC, Problem2D_N
-from SurveyDC import Survey, Survey_ky
-import SrcDC as Src #Pole
-import RxDC as Rx
-from FieldsDC import Fields_CC
-from BoundaryUtils import getxBCyBC_CC
-import Utils

SimPEG/EM/Static/IP/ProblemIP.py

@@ -1,372 +0,0 @@
-from SimPEG import Problem, Utils, Maps, Mesh
-from SimPEG.EM.Base import BaseEMProblem
-from SimPEG.EM.Static.DC.FieldsDC import Fields, Fields_CC, Fields_N
-from SimPEG.Utils import sdiag
-import numpy as np
-from SimPEG.Utils import Zero
-from SimPEG.EM.Static.DC import getxBCyBC_CC
-from SurveyIP import Survey
-
-class IPPropMap(Maps.PropMap):
-    """
-        Property Map for IP Problems. The electrical chargeability,
-        (\\(\\eta\\)) is the default inversion property
-    """
-    eta = Maps.Property("Electrical Chargeability", defaultInvProp = True)
-
-class BaseIPProblem(BaseEMProblem):
-
-    surveyPair = Survey
-    fieldsPair = Fields
-    PropMap = IPPropMap
-    Ainv = None
-    sigma = None
-    rho = None
-    f = None
-    Ainv = None
-
-    def fields(self, m):
-        self.curModel = m
-        if self.f is None:
-            self.f = self.fieldsPair(self.mesh, self.survey)
-            if self.Ainv == None:
-                A = self.getA()
-                self.Ainv = self.Solver(A, **self.solverOpts)
-            RHS = self.getRHS()
-            u = self.Ainv * RHS
-            Srcs = self.survey.srcList
-            self.f[Srcs, self._solutionType] = u
-        return self.f
-
-    def Jvec(self, m, v, f=None):
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-
-        Jv = self.dataPair(self.survey) #same size as the data
-
-        A = self.getA()
-
-        for src in self.survey.srcList:
-            u_src = f[src, self._solutionType] # solution vector
-            dA_dm_v = self.getADeriv(u_src, v)
-            dRHS_dm_v = self.getRHSDeriv(src, v)
-            du_dm_v = self.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)
-        # Conductivity (d u / d log sigma)
-        if self._formulation is 'EB':
-            return -Utils.mkvc(Jv)
-        # Conductivity (d u / d log rho)
-        if self._formulation is 'HJ':
-            return Utils.mkvc(Jv)
-
-    def Jtvec(self, m, v, f=None):
-        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)
-        AT = self.getA()
-
-        for src in self.survey.srcList:
-            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 = self.Ainv * df_duT
-                dA_dmT = self.getADeriv(u_src, ATinvdf_duT, adjoint=True)
-                dRHS_dmT = self.getRHSDeriv(src, ATinvdf_duT, adjoint=True)
-                du_dmT = -dA_dmT + dRHS_dmT
-                Jtv += (df_dmT + du_dmT).astype(float)
-        # Conductivity ((d u / d log sigma).T)
-        if self._formulation is 'EB':
-            return -Utils.mkvc(Jtv)
-        # Conductivity ((d u / d log rho).T)
-        if self._formulation is 'HJ':
-            return Utils.mkvc(Jtv)
-
-    def getSourceTerm(self):
-        """
-        takes concept of source and turns it into a matrix
-        """
-        """
-        Evaluates the sources, and puts them in matrix form
-
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: q (nC or nN, nSrc)
-        """
-
-        Srcs = self.survey.srcList
-
-        if self._formulation is 'EB':
-            n = self.mesh.nN
-            # return NotImplementedError
-
-        elif self._formulation is 'HJ':
-            n = self.mesh.nC
-
-        q = np.zeros((n, len(Srcs)))
-
-        for i, src in enumerate(Srcs):
-            q[:,i] = src.eval(self)
-        return q
-
-    @property
-    def deleteTheseOnModelUpdate(self):
-        toDelete = []
-        return toDelete
-
-    # assume log rho or log cond
-    @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.sigma)
-        return self._MeSigma
-
-    @property
-    def MfRhoI(self):
-        """
-            Inverse of :code:`MfRho`
-        """
-        if getattr(self, '_MfRhoI', None) is None:
-            self._MfRhoI = self.mesh.getFaceInnerProduct(self.rho, invMat=True)
-        return self._MfRhoI
-
-    def MfRhoIDeriv(self,u):
-        """
-            Derivative of :code:`MfRhoI` with respect to the model.
-        """
-
-        dMfRhoI_dI = -self.MfRhoI**2
-        dMf_drho = self.mesh.getFaceInnerProductDeriv(self.rho)(u)
-        drho_dlogrho = Utils.sdiag(self.rho)*self.curModel.etaDeriv
-        return dMfRhoI_dI * ( dMf_drho * ( drho_dlogrho))
-
-    # TODO: This should take a vector
-    def MeSigmaDeriv(self, u):
-        """
-            Derivative of MeSigma with respect to the model
-        """
-        dsigma_dlogsigma = Utils.sdiag(self.sigma)*self.curModel.etaDeriv
-        return self.mesh.getEdgeInnerProductDeriv(self.sigma)(u) * dsigma_dlogsigma
-
-class Problem3D_CC(BaseIPProblem):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'HJ' # CC potentials means J is on faces
-    fieldsPair    = Fields_CC
-
-    def __init__(self, mesh, **kwargs):
-        BaseIPProblem.__init__(self, mesh, **kwargs)
-        self.setBC()
-
-    def getA(self):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = D MfRhoI G
-
-        """
-
-        D = self.Div
-        G = self.Grad
-        MfRhoI = self.MfRhoI
-        A = D * MfRhoI * G
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return V.T * A
-        return A
-
-    def getADeriv(self, u, v, adjoint= False):
-
-        D = self.Div
-        G = self.Grad
-        MfRhoIDeriv = self.MfRhoIDeriv
-
-        if adjoint:
-            # if self._makeASymmetric is True:
-            #     v = V * v
-            return(MfRhoIDeriv( G * u ).T) * ( D.T * v)
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return V.T * ( D * ( MfRhoIDeriv( D.T * ( V * u ) ) * v ) )
-        return D * (MfRhoIDeriv( G * u ) * v)
-
-    def getRHS(self):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm()
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return self.Vol.T * RHS
-
-        return RHS
-
-    def getRHSDeriv(self, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-    def setBC(self):
-        if self.mesh.dim==3:
-            fxm,fxp,fym,fyp,fzm,fzp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-            gBFzm = self.mesh.gridFz[fzm,:]
-            gBFzp = self.mesh.gridFz[fzp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-            temp_zm, temp_zp = np.ones_like(gBFzm[:,2]), np.ones_like(gBFzp[:,2])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-            alpha_zm, alpha_zp = temp_zm*0., temp_zp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-            beta_zm, beta_zp = temp_zm, temp_zp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-            gamma_zm, gamma_zp = temp_zm*0., temp_zp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp, alpha_zm, alpha_zp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp, beta_zm, beta_zp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp, gamma_zm, gamma_zp]
-
-        elif self.mesh.dim==2:
-
-            fxm,fxp,fym,fyp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp]
-
-        x_BC, y_BC = getxBCyBC_CC(self.mesh, alpha, beta, gamma)
-        V = self.Vol
-        self.Div = V * self.mesh.faceDiv
-        P_BC, B = self.mesh.getBCProjWF_simple()
-        M = B*self.mesh.aveCC2F
-        self.Grad = self.Div.T - P_BC*Utils.sdiag(y_BC)*M
-
-
-class Problem3D_N(BaseIPProblem):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'EB' # N potentials means B is on faces
-    fieldsPair    = Fields_N
-
-    def __init__(self, mesh, **kwargs):
-        BaseIPProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = G.T MeSigma G
-
-        """
-
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        A = Grad.T * MeSigma * Grad
-
-        # Handling Null space of A
-        A[0,0] = A[0,0] + 1.
-
-        return A
-
-    def getADeriv(self, u, v, adjoint=False):
-        """
-
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        """
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        if not adjoint:
-            return Grad.T*(self.MeSigmaDeriv(Grad*u)*v)
-        elif adjoint:
-            return self.MeSigmaDeriv(Grad*u).T * (Grad*v)
-
-
-    def getRHS(self):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm()
-        return RHS
-
-    def getRHSDeriv(self, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-if __name__ == '__main__':
-
-
-    cs = 12.5
-    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],x0="CCN")
-    sigma = np.ones(mesh.nC)
-    prob = BaseIPProblem(mesh, sigma=sigma)
-
-

SimPEG/EM/Static/IP/SurveyIP.py

@@ -1,23 +0,0 @@
-import SimPEG
-from SimPEG.EM.Base import BaseEMSurvey
-from SimPEG import sp, Survey
-from SimPEG.Utils import Zero, Identity
-from SimPEG.EM.Static.DC.SrcDC import BaseSrc
-from SimPEG.EM.Static.DC.RxDC import BaseRx
-
-class Survey(BaseEMSurvey):
-    rxPair  = BaseRx
-    srcPair = BaseSrc
-
-    def __init__(self, srcList, **kwargs):
-        self.srcList = srcList
-        BaseEMSurvey.__init__(self, srcList, **kwargs)
-
-    def dpred(self, m, f=None):
-        """
-            Predicted data.
-
-            .. math::
-                d_\\text{pred} = Pf(m)
-        """
-        return self.prob.Jvec(m, m, f=f)

SimPEG/EM/Static/IP/__init__.py

@@ -1,2 +0,0 @@
-from ProblemIP import Problem3D_CC, Problem3D_N
-from SurveyIP import Survey

SimPEG/EM/Static/SIP/ProblemSIP.py

@@ -1,445 +0,0 @@
-from SimPEG import Problem, Utils, Maps, Mesh
-from SimPEG.EM.Base import BaseEMProblem
-from SimPEG.EM.Static.DC.FieldsDC import Fields, Fields_CC, Fields_N
-from SimPEG.Utils import sdiag
-import numpy as np
-from SimPEG.Utils import Zero
-from SimPEG.EM.Static.DC import getxBCyBC_CC
-from SurveySIP import Survey, Data
-
-class ColeColePropMap(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)
-    """
-
-    eta = Maps.Property("Electrical Conductivity", defaultInvProp=True)
-    tau = Maps.Property("Electrical Conductivity", defaultVal=0.1, propertyLink=('taui', Maps.ReciprocalMap))
-    taui   = Maps.Property("Electrical Conductivity", defaultVal=1., propertyLink=('tau', Maps.ReciprocalMap))
-    c   = Maps.Property("Electrical Conductivity", defaultVal=1.)
-
-
-class BaseSIPProblem(BaseEMProblem):
-
-    surveyPair = Survey
-    fieldsPair = Fields
-    dataPair = Data
-    PropMap = ColeColePropMap
-    Ainv = None
-    sigma = None
-    rho = None
-    f = None
-    Ainv = None
-
-    def DebyeTime(self, t):
-        peta = self.curModel.eta*np.exp(-self.curModel.taui*t)
-        return peta
-
-    def EtaDeriv(self, t, v, adjoint=False):
-        v = np.array(v, dtype=float)
-        if adjoint:
-            return self.curModel.etaDeriv.T * (np.exp(-self.curModel.taui*t)*v)
-        else:
-            return np.exp(-self.curModel.taui*t) * (self.curModel.etaDeriv*v)
-
-
-    def TauiDeriv(self, t, v, adjoint=False):
-        v = np.array(v, dtype=float)
-        if adjoint:
-            return -self.curModel.tauiDeriv.T * (self.curModel.eta*t*np.exp(-self.curModel.taui*t)*v)
-        else:
-            return -self.curModel.eta*t*np.exp(-self.curModel.taui*t) * (self.curModel.tauiDeriv*v)
-
-    def fields(self, m):
-        self.curModel = m
-        if self.f is None:
-            self.f = self.fieldsPair(self.mesh, self.survey)
-            if self.Ainv == None:
-                A = self.getA()
-                self.Ainv = self.Solver(A, **self.solverOpts)
-            RHS = self.getRHS()
-            u = self.Ainv * RHS
-            Srcs = self.survey.srcList
-            self.f[Srcs, self._solutionType] = u
-        return self.f
-
-    def forward(self, m, f=None):
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-        Jv = self.dataPair(self.survey) #same size as the data
-        # A = self.getA()
-        JvAll = []
-        for tind in range(len(self.survey.times)):
-            #Pseudo-chareability
-            t = self.survey.times[tind]
-            v = self.DebyeTime(t)
-            for src in self.survey.srcList:
-                u_src = f[src, self._solutionType] # solution vector
-                dA_dm_v = self.getADeriv(u_src, v)
-                dRHS_dm_v = self.getRHSDeriv(src, v)
-                du_dm_v = self.Ainv * ( - dA_dm_v + dRHS_dm_v )
-                for rx in src.rxList:
-                    timeindex = rx.getTimeP(self.survey.times)
-                    if timeindex[tind]:
-                        df_dmFun = getattr(f, '_%sDeriv'%rx.projField, None)
-                        df_dm_v = df_dmFun(src, du_dm_v, v, adjoint=False)
-                        Jv[src, rx, t] = rx.evalDeriv(src, self.mesh, f, df_dm_v)
-
-        # Conductivity (d u / d log sigma)
-        if self._formulation is 'EB':
-            return -Utils.mkvc(Jv)
-        # Resistivity (d u / d log rho)
-        if self._formulation is 'HJ':
-            return Utils.mkvc(Jv)
-
-    def Jvec(self, m, v, f=None):
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-        Jv = self.dataPair(self.survey) #same size as the data
-        # A = self.getA()
-        JvAll = []
-        #Assume only eta and tau (eta first then tau)
-        # v = [2*Mx1]
-        v = v.reshape((int(v.size/2), 2), order='F')
-
-        for tind in range(len(self.survey.times)):
-            t = self.survey.times[tind]
-            v0 = self.EtaDeriv(t, v[:,0])
-            v1 = self.TauiDeriv(t, v[:,1])
-            for src in self.survey.srcList:
-                u_src = f[src, self._solutionType] # solution vector
-                dA_dm_v0 = self.getADeriv(u_src, v0)
-                dRHS_dm_v0 = self.getRHSDeriv(src, v0)
-                du_dm_v0 = self.Ainv * ( - dA_dm_v0 + dRHS_dm_v0 )
-                dA_dm_v1 = self.getADeriv(u_src, v1)
-                dRHS_dm_v1 = self.getRHSDeriv(src, v1)
-                du_dm_v1 = self.Ainv * ( - dA_dm_v1 + dRHS_dm_v1 )
-                for rx in src.rxList:
-                    timeindex = rx.getTimeP(self.survey.times)
-                    if timeindex[tind]:
-                        df_dmFun = getattr(f, '_%sDeriv'%rx.projField, None)
-                        df_dm_v0 = df_dmFun(src, du_dm_v0, v0, adjoint=False)
-                        df_dm_v1 = df_dmFun(src, du_dm_v1, v1, adjoint=False)
-                        Jv[src, rx, t] = rx.evalDeriv(src, self.mesh, f, df_dm_v0)
-                        Jv[src, rx, t] += rx.evalDeriv(src, self.mesh, f, df_dm_v1)
-        # Conductivity (d u / d log sigma)
-        if self._formulation is 'EB':
-            return -Jv.tovec()
-        # Resistivity (d u / d log rho)
-        if self._formulation is 'HJ':
-            return Jv.tovec()
-
-    def Jtvec(self, m, v, f=None):
-        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 tind in range(len(self.survey.times)):
-            t = self.survey.times[tind]
-            for src in self.survey.srcList:
-                u_src = f[src, self._solutionType]
-                for rx in src.rxList:
-                    timeindex = rx.getTimeP(self.survey.times)
-                    if timeindex[tind]:
-                        PTv = rx.evalDeriv(src, self.mesh, f, v[src, rx, t], 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 = self.Ainv * df_duT
-                        dA_dmT = self.getADeriv(u_src, ATinvdf_duT, adjoint=True)
-                        dRHS_dmT = self.getRHSDeriv(src, ATinvdf_duT, adjoint=True)
-                        du_dmT = -dA_dmT + dRHS_dmT
-                        Jtv += np.r_[self.EtaDeriv(self.survey.times[tind], du_dmT, adjoint=True), self.TauiDeriv(self.survey.times[tind], du_dmT, adjoint=True)]
-
-        # Conductivity ((d u / d log sigma).T)
-        if self._formulation is 'EB':
-            return -Jtv
-        # Conductivity ((d u / d log rho).T)
-        if self._formulation is 'HJ':
-            return Jtv
-
-    def getSourceTerm(self):
-        """
-        takes concept of source and turns it into a matrix
-        """
-        """
-        Evaluates the sources, and puts them in matrix form
-
-        :rtype: (numpy.ndarray, numpy.ndarray)
-        :return: q (nC or nN, nSrc)
-        """
-
-        Srcs = self.survey.srcList
-
-        if self._formulation is 'EB':
-            n = self.mesh.nN
-            # return NotImplementedError
-
-        elif self._formulation is 'HJ':
-            n = self.mesh.nC
-
-        q = np.zeros((n, len(Srcs)))
-
-        for i, src in enumerate(Srcs):
-            q[:,i] = src.eval(self)
-        return q
-
-    @property
-    def deleteTheseOnModelUpdate(self):
-        toDelete = []
-        return toDelete
-
-    # assume log rho or log cond
-    @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.sigma)
-        return self._MeSigma
-
-    @property
-    def MfRhoI(self):
-        """
-            Inverse of :code:`MfRho`
-        """
-        if getattr(self, '_MfRhoI', None) is None:
-            self._MfRhoI = self.mesh.getFaceInnerProduct(self.rho, invMat=True)
-        return self._MfRhoI
-
-    def MfRhoIDeriv(self,u):
-        """
-            Derivative of :code:`MfRhoI` with respect to the model.
-        """
-
-        dMfRhoI_dI = -self.MfRhoI**2
-        dMf_drho = self.mesh.getFaceInnerProductDeriv(self.rho)(u)
-        drho_dlogrho = Utils.sdiag(self.rho)
-        return dMfRhoI_dI * ( dMf_drho * ( drho_dlogrho))
-
-    # TODO: This should take a vector
-    def MeSigmaDeriv(self, u):
-        """
-            Derivative of MeSigma with respect to the model
-        """
-        dsigma_dlogsigma = Utils.sdiag(self.sigma)
-        return self.mesh.getEdgeInnerProductDeriv(self.sigma)(u) * dsigma_dlogsigma
-
-class Problem3D_CC(BaseSIPProblem):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'HJ' # CC potentials means J is on faces
-    fieldsPair    = Fields_CC
-
-    def __init__(self, mesh, **kwargs):
-        BaseSIPProblem.__init__(self, mesh, **kwargs)
-        self.setBC()
-
-    def getA(self):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = D MfRhoI G
-
-        """
-
-        D = self.Div
-        G = self.Grad
-        # TODO: this won't work for full anisotropy
-        MfRhoI = self.MfRhoI
-        A = D * MfRhoI * G
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return V.T * A
-        return A
-
-    def getADeriv(self, u, v, adjoint= False):
-
-        D = self.Div
-        G = self.Grad
-        MfRhoIDeriv = self.MfRhoIDeriv
-
-        if adjoint:
-            # if self._makeASymmetric is True:
-            #     v = V * v
-            return(MfRhoIDeriv( G * u ).T) * ( D.T * v)
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return V.T * ( D * ( MfRhoIDeriv( D.T * ( V * u ) ) * v ) )
-        return D * (MfRhoIDeriv( G * u ) * v)
-
-    def getRHS(self):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm()
-
-        # I think we should deprecate this for DC problem.
-        # if self._makeASymmetric is True:
-        #     return self.Vol.T * RHS
-
-        return RHS
-
-    def getRHSDeriv(self, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-    def setBC(self):
-        if self.mesh.dim==3:
-            fxm,fxp,fym,fyp,fzm,fzp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-            gBFzm = self.mesh.gridFz[fzm,:]
-            gBFzp = self.mesh.gridFz[fzp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-            temp_zm, temp_zp = np.ones_like(gBFzm[:,2]), np.ones_like(gBFzp[:,2])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-            alpha_zm, alpha_zp = temp_zm*0., temp_zp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-            beta_zm, beta_zp = temp_zm, temp_zp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-            gamma_zm, gamma_zp = temp_zm*0., temp_zp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp, alpha_zm, alpha_zp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp, beta_zm, beta_zp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp, gamma_zm, gamma_zp]
-
-        elif self.mesh.dim==2:
-
-            fxm,fxp,fym,fyp = self.mesh.faceBoundaryInd
-            gBFxm = self.mesh.gridFx[fxm,:]
-            gBFxp = self.mesh.gridFx[fxp,:]
-            gBFym = self.mesh.gridFy[fym,:]
-            gBFyp = self.mesh.gridFy[fyp,:]
-
-            # Setup Mixed B.C (alpha, beta, gamma)
-            temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
-            temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
-
-            alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
-            alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
-
-            beta_xm, beta_xp = temp_xm, temp_xp
-            beta_ym, beta_yp = temp_ym, temp_yp
-
-            gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
-            gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
-
-            alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp]
-            beta =  [beta_xm, beta_xp, beta_ym, beta_yp]
-            gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp]
-
-        x_BC, y_BC = getxBCyBC_CC(self.mesh, alpha, beta, gamma)
-        V = self.Vol
-        self.Div = V * self.mesh.faceDiv
-        P_BC, B = self.mesh.getBCProjWF_simple()
-        M = B*self.mesh.aveCC2F
-        self.Grad = self.Div.T - P_BC*Utils.sdiag(y_BC)*M
-
-
-class Problem3D_N(BaseSIPProblem):
-
-    _solutionType = 'phiSolution'
-    _formulation  = 'EB' # N potentials means B is on faces
-    fieldsPair    = Fields_N
-
-    def __init__(self, mesh, **kwargs):
-        BaseSIPProblem.__init__(self, mesh, **kwargs)
-
-    def getA(self):
-        """
-
-        Make the A matrix for the cell centered DC resistivity problem
-
-        A = G.T MeSigma G
-
-        """
-
-        # TODO: this won't work for full anisotropy
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        A = Grad.T * MeSigma * Grad
-
-        # Handling Null space of A
-        A[0,0] = A[0,0] + 1.
-
-        return A
-
-    def getADeriv(self, u, v, adjoint=False):
-        """
-
-        Product of the derivative of our system matrix with respect to the model and a vector
-
-        """
-        MeSigma = self.MeSigma
-        Grad = self.mesh.nodalGrad
-        if not adjoint:
-            return Grad.T*(self.MeSigmaDeriv(Grad*u)*v)
-        elif adjoint:
-            return self.MeSigmaDeriv(Grad*u).T * (Grad*v)
-
-
-    def getRHS(self):
-        """
-        RHS for the DC problem
-
-        q
-        """
-
-        RHS = self.getSourceTerm()
-        return RHS
-
-    def getRHSDeriv(self, src, v, adjoint=False):
-        """
-        Derivative of the right hand side with respect to the model
-        """
-        # TODO: add qDeriv for RHS depending on m
-        # qDeriv = src.evalDeriv(self, adjoint=adjoint)
-        # return qDeriv
-        return Zero()
-
-if __name__ == '__main__':
-
-
-    cs = 12.5
-    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],x0="CCN")
-    sigma = np.ones(mesh.nC)
-    prob = BaseSIPProblem(mesh, sigma=sigma)
-
-

SimPEG/EM/Static/SIP/Regularization.py

@@ -1,204 +0,0 @@
-from SimPEG import Utils, Maps, Mesh, sp, np
-from SimPEG.Regularization import BaseRegularization, Simple
-
-class MultiRegularization(Simple):
-    """
-    **MultiRegularization Class**
-
-    This is used to regularize the model space
-    having multiple models [m1, m2, m3, ...] ::
-
-        reg = Regularization(mesh)
-
-    """
-    nModels = None # Number of models
-    ratios = None  # Ratio for different models
-    crossgrad = False # Use cross gradient or not
-    betacross = 1.
-    wx = []
-    wy = []
-    wz = []
-
-    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
-        BaseRegularization.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
-        if self.nModels == None:
-            raise Exception("Put nModels as a initial input!")
-        if self.ratios == None:
-            self.ratios = [1. for imodel in range(self.nModels)]
-
-    @property
-    def Wsmall(self):
-        """Regularization matrix Wsmall"""
-        if getattr(self,'_Wsmall', None) is None:
-            vecs = []
-            for imodel in range(self.nModels):
-                vecs.append((self.regmesh.vol*self.alpha_s*self.wght*self.ratios[imodel])**0.5)
-            self._Wsmall = Utils.sdiag(np.hstack(vecs))
-        return self._Wsmall
-
-    @property
-    def Wx(self):
-        """Regularization matrix Wx"""
-        if getattr(self, '_Wx', None) is None:
-            mats = []
-            for imodel in range(self.nModels):
-                self.wx.append(Utils.sdiag((self.regmesh.aveCC2Fx * self.regmesh.vol*self.alpha_x*self.ratios[imodel]*(self.regmesh.aveCC2Fx*self.wght))**0.5))
-                mats.append(self.wx[imodel]*self.regmesh.cellDiffxStencil)
-            self._Wx = sp.block_diag(mats)
-        return self._Wx
-
-    @property
-    def Wy(self):
-        """Regularization matrix Wy"""
-        if getattr(self, '_Wy', None) is None:
-            mats = []
-            for imodel in range(self.nModels):
-                self.wy.append(Utils.sdiag((self.regmesh.aveCC2Fy * self.regmesh.vol*self.alpha_y*self.ratios[imodel]*(self.regmesh.aveCC2Fy*self.wght))**0.5))
-                mats.append(self.wy[imodel]*self.regmesh.cellDiffyStencil)
-            self._Wy = sp.block_diag(mats)
-        return self._Wy
-
-    @property
-    def Wz(self):
-        """Regularization matrix Wz"""
-        if getattr(self, '_Wz', None) is None:
-            mats = []
-            for imodel in range(self.nModels):
-                self.wz.append(Utils.sdiag((self.regmesh.aveCC2Fz * self.regmesh.vol*self.alpha_z*self.ratios[imodel]*(self.regmesh.aveCC2Fz*self.wght))**0.5))
-                mats.append(self.wz[imodel]*self.regmesh.cellDiffzStencil)
-            self._Wz = sp.block_diag(mats)
-        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 eval(self, m):
-        return self._evalSmall(m) + self._evalSmooth(m)
-
-    @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)
-
-    def cross(a,b):
-        ax, ay, az = a[0], a[1], a[2]
-        bx, by, bz = b[0], b[1], b[2]
-        cx = ay*bz - az*by
-        cy = az*bx - ax*bz
-        cz = ax*by - ay*bx
-        return [cx, cy, cz]
-
-     # TODO: Implement Cross Gradients..
-    @Utils.timeIt
-    def _evalCross(self, m):
-        if self.crossgrad == False:
-            return 0.
-        elif self.crossgrad == True:
-            M = (self.mapping * m).reshape((self.regmesh.nC, self.nModels), order="F")
-
-            ax = self.regmesh.aveFx2CC*self.regmesh.wx[0]*M[:,0]
-            ay = self.regmesh.aveFy2CC*self.regmesh.wy[0]*M[:,0]
-            az = self.regmesh.aveFz2CC*self.regmesh.wz[0]*M[:,0]
-            bx = self.regmesh.aveFx2CC*self.regmesh.wx[1]*M[:,1]
-            by = self.regmesh.aveFy2CC*self.regmesh.wy[1]*M[:,1]
-            bz = self.regmesh.aveFz2CC*self.regmesh.wz[1]*M[:,1]
-            #ab
-            out_ab = cross([ax, ay, az], [bx, by, bz])
-            r = np.r_[out_ab[0], out_ab[1], out_ab[2]]*np.sqrt(self.betacross)
-
-            if self.nModels == 3:
-                cx = self.regmesh.aveFx2CC*self.regmesh.wx[1]*M[:,1]
-                cy = self.regmesh.aveFy2CC*self.regmesh.wy[1]*M[:,1]
-                cz = self.regmesh.aveFz2CC*self.regmesh.wz[1]*M[:,1]
-                #ac
-                out_ac = cross([ax, ay, az], [cx, cy, cz])
-                #bc
-                out_bc = cross([bx, by, bz], [cx, cy, cz])
-                r = np.r_[r, np.hstack(out_ac)*np.sqrt(self.betacross), np.hstack(out_bc)*np.sqrt(self.betacross)]
-
-            return 0.5 * r.dot(r)
-
-    @Utils.timeIt
-    def evalDeriv(self, m):
-        """
-        The regularization is:
-
-        .. math::
-
-            R(m) = \\frac{1}{2}\mathbf{(m-m_\\text{ref})^\\top W^\\top W(m-m_\\text{ref})}
-
-        So the derivative is straight forward:
-
-        .. math::
-
-            R(m) = \mathbf{W^\\top W (m-m_\\text{ref})}
-
-        """
-        deriv = self._evalSmallDeriv(m) + self._evalSmoothDeriv(m)
-        if self.crossgrad==True:
-            deriv += self._evalCrossDeriv(m)
-        return deriv
-
-    @Utils.timeIt
-    def _evalCrossDeriv(self,m):
-        r = self.Wsmall * ( self.mapping * (m - self.mref) )
-        return r.T * ( self.Wsmall * self.mapping.deriv(m - self.mref) )
-
-    @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
-
-        The regularization is:
-
-        .. math::
-
-            R(m) = \\frac{1}{2}\mathbf{(m-m_\\text{ref})^\\top W^\\top W(m-m_\\text{ref})}
-
-        So the second derivative is straight forward:
-
-        .. math::
-
-            R(m) = \mathbf{W^\\top W}
-
-        """
-        mD = self.mapping.deriv(m - self.mref)
-        if v is None:
-            return mD.T * self.W.T * self.W * mD
-
-        return mD.T * ( self.W.T * ( self.W * ( mD * v) ) )
-
-
-

SimPEG/EM/Static/SIP/RxSIP.py

@@ -1,88 +0,0 @@
-import SimPEG
-import numpy as np
-from SimPEG.Utils import Zero, closestPoints
-
-class BaseRx(SimPEG.Survey.BaseTimeRx):
-    locs = None
-    rxType = None
-
-    knownRxTypes = {
-                    'phi':['phi',None],
-                    'ex':['e','x'],
-                    'ey':['e','y'],
-                    'ez':['e','z'],
-                    'jx':['j','x'],
-                    'jy':['j','y'],
-                    'jz':['j','z'],
-                    }
-
-    def __init__(self, locs, times, rxType, **kwargs):
-        SimPEG.Survey.BaseTimeRx.__init__(self, locs, times, rxType, **kwargs)
-
-    @property
-    def projField(self):
-        """Field Type projection (e.g. e b ...)"""
-        return self.knownRxTypes[self.rxType][0]
-
-    def projGLoc(self, f):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        comp = self.knownRxTypes[self.rxType][1]
-        if comp is not None:
-            return f._GLoc(self.rxType) + comp
-        return f._GLoc(self.rxType)
-
-    def getTimeP(self, timesall):
-        """
-            Returns the time projection matrix.
-
-            .. note::
-
-                This is not stored in memory, but is created on demand.
-        """
-        time_inds = np.in1d(timesall, self.times)
-        return time_inds
-
-    def evalDeriv(self, src, mesh, f, v, adjoint=False):
-        P = self.getP(mesh, self.projGLoc(f))
-        if not adjoint:
-            return P*v
-        elif adjoint:
-            return P.T*v
-
-
-# DC.Rx.Dipole(locs)
-class Dipole(BaseRx):
-
-    def __init__(self, locsM, locsN, times, rxType = 'phi', **kwargs):
-        assert locsM.shape == locsN.shape, 'locsM and locsN need to be the same size'
-        locs = [locsM, locsN]
-        # We may not need this ...
-        BaseRx.__init__(self, locs, times, rxType)
-
-    @property
-    def nD(self):
-        """Number of data in the receiver."""
-        # return self.locs[0].shape[0] * len(self.times)
-        return self.locs[0].shape[0]
-
-    @property
-    def nRx(self):
-        """Number of data in the receiver."""
-        return self.locs[0].shape[0]
-
-        # Not sure why ...
-        # return int(self.locs[0].size / 2)
-
-
-    def getP(self, mesh, Gloc):
-        if mesh in self._Ps:
-            return self._Ps[mesh]
-
-        P0 = mesh.getInterpolationMat(self.locs[0], Gloc)
-        P1 = mesh.getInterpolationMat(self.locs[1], Gloc)
-        P = P0 - P1
-
-        if self.storeProjections:
-            self._Ps[mesh] = P
-
-        return P

SimPEG/EM/Static/SIP/SrcSIP.py

@@ -1,64 +0,0 @@
-import SimPEG
-# from SimPEG.EM.Base import BaseEMSurvey
-from SimPEG.Utils import Zero, closestPoints, mkvc
-import numpy as np
-
-class BaseSrc(SimPEG.Survey.BaseSrc):
-
-    current = 1.0
-    loc = None
-
-    def __init__(self, rxList, **kwargs):
-        SimPEG.Survey.BaseSrc.__init__(self, rxList, **kwargs)
-
-    def eval(self, prob):
-        raise NotImplementedError
-
-    def evalDeriv(self, prob):
-        return Zero()
-
-    @property
-    def nD(self):
-        """Number of data"""
-        return self.vnD.sum()
-
-    @property
-    def vnD(self):
-        """Vector number of data"""
-        return np.array([rx.nD*len(rx.times) for rx in self.rxList])
-
-
-
-class Dipole(BaseSrc):
-
-    def __init__(self, rxList, locA, locB, **kwargs):
-        assert locA.shape == locB.shape, 'Shape of locA and locB should be the same'
-        self.loc = [locA, locB]
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    def eval(self, prob):
-        if prob._formulation == 'HJ':
-            inds = closestPoints(prob.mesh, self.loc, gridLoc='CC')
-            q = np.zeros(prob.mesh.nC)
-            q[inds] = self.current * np.r_[1., -1.]
-        elif prob._formulation == 'EB':
-            qa = prob.mesh.getInterpolationMat(self.loc[0], locType='N').todense()
-            qb = -prob.mesh.getInterpolationMat(self.loc[1], locType='N').todense()
-            q = self.current * mkvc(qa+qb)
-        return q
-
-class Pole(BaseSrc):
-
-    def __init__(self, rxList, loc, **kwargs):
-        BaseSrc.__init__(self, rxList, loc=loc, **kwargs)
-
-    def eval(self, prob):
-        if prob._formulation == 'HJ':
-            inds = closestPoints(prob.mesh, self.loc)
-            q = np.zeros(prob.mesh.nC)
-            q[inds] = self.current * np.r_[1.]
-        elif prob._formulation == 'EB':
-            q = prob.mesh.getInterpolationMat(self.loc, locType='N').todense()
-            q = self.current * mkvc(q)
-        return q
-

SimPEG/EM/Static/SIP/SurveySIP.py

@@ -1,102 +0,0 @@
-import SimPEG
-from SimPEG.EM.Base import BaseEMSurvey
-from SimPEG import np, sp, Survey, Utils
-from SimPEG.Utils import Zero, Identity
-from SimPEG.EM.Static.SIP.SrcSIP import BaseSrc
-from SimPEG.EM.Static.SIP.RxSIP import BaseRx
-import uuid
-
-
-class Survey(BaseEMSurvey):
-    rxPair  = BaseRx
-    srcPair = BaseSrc
-    times = None
-
-    def __init__(self, srcList, **kwargs):
-        self.srcList = srcList
-        BaseEMSurvey.__init__(self, srcList, **kwargs)
-        self.getUniqueTimes()
-
-    def getUniqueTimes(self):
-        time_rx = []
-        for src in self.srcList:
-            for rx in src.rxList:
-                time_rx.append(rx.times)
-        self.times = np.unique(np.hstack(time_rx))
-
-    def dpred(self, m, f=None):
-        """
-            Predicted data.
-
-            .. math::
-                d_\\text{pred} = Pf(m)
-        """
-        return self.prob.forward(m, f=f)
-
-
-class Data(SimPEG.Survey.Data):
-    """Fancy data storage by Src and Rx"""
-
-    def __init__(self, survey, v=None):
-        self.uid = str(uuid.uuid4())
-        self.survey = survey
-        self._dataDict = {}
-        for src in self.survey.srcList:
-            self._dataDict[src] = {}
-            for rx in src.rxList:
-                self._dataDict[src][rx] = {}
-
-        if v is not None:
-            self.fromvec(v)
-
-    def _ensureCorrectKey(self, key):
-        if type(key) is tuple:
-            if len(key) is not 3:
-                raise KeyError('Key must be [Src, Rx, tInd]')
-            if key[0] not in self.survey.srcList:
-                raise KeyError('Src Key must be a source in the survey.')
-            if key[1] not in key[0].rxList:
-                raise KeyError('Rx Key must be a receiver for the source.')
-            return key
-        elif isinstance(key, self.survey.srcPair):
-            if key not in self.survey.srcList:
-                raise KeyError('Key must be a source in the survey.')
-            return key, None, None
-        else:
-            raise KeyError('Key must be [Src] or [Src,Rx] or [Src, Rx, tInd]')
-
-    def __setitem__(self, key, value):
-        src, rx, t = self._ensureCorrectKey(key)
-        assert rx is not None, 'set data using [Src, Rx]'
-        assert isinstance(value, np.ndarray), 'value must by ndarray'
-        assert value.size == rx.nD, "value must have the same number of data as the source."
-        self._dataDict[src][rx][t] = Utils.mkvc(value)
-
-    def __getitem__(self, key):
-        src, rx, t = self._ensureCorrectKey(key)
-        if rx is not None:
-            if rx not in self._dataDict[src]:
-                raise Exception('Data for receiver has not yet been set.')
-            return self._dataDict[src][rx][t]
-
-        return np.concatenate([self[src,rx, t] for rx in src.rxList])
-
-    def tovec(self):
-        val = []
-        for src in self.survey.srcList:
-            for rx in src.rxList:
-                for t in rx.times:
-                    val.append(self[src, rx, t])
-        return np.concatenate(val)
-
-
-    def fromvec(self, v):
-        v = Utils.mkvc(v)
-        assert v.size == self.survey.nD, 'v must have the correct number of data.'
-        indBot, indTop = 0, 0
-        for src in self.survey.srcList:
-            for rx in src.rxList:
-                for t in rx.times:
-                    indTop += rx.nRx
-                    self[src, rx, t] = v[indBot:indTop]
-                    indBot += rx.nRx

SimPEG/EM/Static/SIP/__init__.py

@@ -1,5 +0,0 @@
-from ProblemSIP import Problem3D_CC, Problem3D_N
-from SurveySIP import Survey, Data
-import SrcSIP as Src #Pole
-import RxSIP as Rx
-from Regularization import MultiRegularization

SimPEG/EM/Static/Utils/StaticUtils.py

@@ -1,317 +0,0 @@
-from SimPEG import np
-from SimPEG.EM.Static import DC, IP
-
-def plot_pseudoSection(DCsurvey, axs, stype='dpdp', dtype="appc", clim=None):
-    """
-        Read list of 2D tx-rx location and plot a speudo-section of apparent
-        resistivity.
-
-        Assumes flat topo for now...
-
-        Input:
-        :param d2D, z0
-        :switch stype -> Either 'pdp' (pole-dipole) | 'dpdp' (dipole-dipole)
-        :switch dtype=-> Either 'appr' (app. res) | 'appc' (app. con) | 'volt' (potential)
-        Output:
-        :figure scatter plot overlayed on image
-
-        Edited Feb 17th, 2016
-
-        @author: dominiquef
-
-    """
-    from SimPEG import np
-    from scipy.interpolate import griddata
-    import pylab as plt
-
-    # Set depth to 0 for now
-    z0 = 0.
-
-    # Pre-allocate
-    midx = []
-    midz = []
-    rho = []
-    LEG = []
-    count = 0 # Counter for data
-    for ii in range(DCsurvey.nSrc):
-
-        Tx = DCsurvey.srcList[ii].loc
-        Rx = DCsurvey.srcList[ii].rxList[0].locs
-
-        nD = DCsurvey.srcList[ii].rxList[0].nD
-
-        data = DCsurvey.dobs[count:count+nD]
-        count += nD
-
-        # Get distances between each poles A-B-M-N
-        if stype == 'pdp':
-            MA = np.abs(Tx[0] - Rx[0][:,0])
-            NA = np.abs(Tx[0] - Rx[1][:,0])
-            MN = np.abs(Rx[1][:,0] - Rx[0][:,0])
-
-            # Create mid-point location
-            Cmid = Tx[0]
-            Pmid = (Rx[0][:,0] + Rx[1][:,0])/2
-            if DCsurvey.mesh.dim == 2:
-                zsrc = Tx[1]
-            elif DCsurvey.mesh.dim ==3:
-                zsrc = Tx[2]
-
-        elif stype == 'dpdp':
-            MA = np.abs(Tx[0][0] - Rx[0][:,0])
-            MB = np.abs(Tx[1][0] - Rx[0][:,0])
-            NA = np.abs(Tx[0][0] - Rx[1][:,0])
-            NB = np.abs(Tx[1][0] - Rx[1][:,0])
-
-            # Create mid-point location
-            Cmid = (Tx[0][0] + Tx[1][0])/2
-            Pmid = (Rx[0][:,0] + Rx[1][:,0])/2
-            if DCsurvey.mesh.dim == 2:
-                zsrc = (Tx[0][1] + Tx[1][1])/2
-            elif DCsurvey.mesh.dim ==3:
-                zsrc = (Tx[0][2] + Tx[1][2])/2
-
-        # Change output for dtype
-        if dtype == 'volt':
-
-            rho = np.hstack([rho,data])
-
-        else:
-
-            # Compute pant leg of apparent rho
-            if stype == 'pdp':
-
-                leg =  data * 2*np.pi  * MA * ( MA + MN ) / MN
-
-            elif stype == 'dpdp':
-
-                leg = data * 2*np.pi / ( 1/MA - 1/MB + 1/NB - 1/NA )
-                LEG.append(1./(2*np.pi) *( 1/MA - 1/MB + 1/NB - 1/NA ))
-            else:
-                print """dtype must be 'pdp'(pole-dipole) | 'dpdp' (dipole-dipole) """
-                break
-
-
-            if dtype == 'appc':
-
-                leg = np.log10(abs(1./leg))
-                rho = np.hstack([rho,leg])
-
-            elif dtype == 'appr':
-
-                leg = np.log10(abs(leg))
-                rho = np.hstack([rho,leg])
-
-            else:
-                print """dtype must be 'appr' | 'appc' | 'volt' """
-                break
-
-
-        midx = np.hstack([midx, ( Cmid + Pmid )/2 ])
-        if DCsurvey.mesh.dim==3:
-            midz = np.hstack([midz, -np.abs(Cmid-Pmid)/2 + zsrc ])
-        elif DCsurvey.mesh.dim==2:
-            midz = np.hstack([midz, -np.abs(Cmid-Pmid)/2 + zsrc ])
-    ax = axs
-
-    # Grid points
-    grid_x, grid_z = np.mgrid[np.min(midx):np.max(midx), np.min(midz):np.max(midz)]
-    grid_rho = griddata(np.c_[midx,midz], rho.T, (grid_x, grid_z), method='linear')
-
-    if clim == None:
-        vmin, vmax = rho.min(), rho.max()
-    else:
-        vmin, vmax = clim[0], clim[1]
-
-    grid_rho = np.ma.masked_where(np.isnan(grid_rho), grid_rho)
-    ph = plt.pcolormesh(grid_x[:,0],grid_z[0,:],grid_rho.T, clim=(vmin, vmax), vmin=vmin, vmax=vmax)
-    cbar = plt.colorbar(format="$10^{%.1f}$",fraction=0.04,orientation="horizontal")
-
-    cmin,cmax = cbar.get_clim()
-    ticks = np.linspace(cmin,cmax,3)
-    cbar.set_ticks(ticks)
-    cbar.ax.tick_params(labelsize=10)
-
-    if dtype == 'appc':
-        cbar.set_label("App.Cond",size=12)
-    elif dtype == 'appr':
-        cbar.set_label("App.Res.",size=12)
-    elif dtype == 'volt':
-        cbar.set_label("Potential (V)",size=12)
-
-    # Plot apparent resistivity
-    ax.scatter(midx,midz,s=10,c=rho.T, vmin =vmin, vmax = vmax, clim=(vmin, vmax))
-
-    #ax.set_xticklabels([])
-    #ax.set_yticklabels([])
-
-    plt.gca().set_aspect('equal', adjustable='box')
-
-
-
-    return ph, LEG
-
-def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
-    """
-        Load in endpoints and survey specifications to generate Tx, Rx location
-        stations.
-
-        Assumes flat topo for now...
-
-        Input:
-        :param endl -> input endpoints [x1, y1, z1, x2, y2, z2]
-        :object mesh -> SimPEG mesh object
-        :switch stype -> "dpdp" (dipole-dipole) | "pdp" (pole-dipole) | 'gradient'
-        : param a, n -> pole seperation, number of rx dipoles per tx
-
-        Output:
-        :param Tx, Rx -> List objects for each tx location
-            Lines: P1x, P1y, P1z, P2x, P2y, P2z
-
-        Created on Wed December 9th, 2015
-
-        @author: dominiquef
-        !! Require clean up to deal with DCsurvey
-    """
-
-    from SimPEG import np
-
-    def xy_2_r(x1,x2,y1,y2):
-        r = np.sqrt( np.sum((x2 - x1)**2 + (y2 - y1)**2) )
-        return r
-
-    ## Evenly distribute electrodes and put on surface
-    # Mesure survey length and direction
-    dl_len = xy_2_r(endl[0,0],endl[1,0],endl[0,1],endl[1,1])
-
-    dl_x = ( endl[1,0] - endl[0,0] ) / dl_len
-    dl_y = ( endl[1,1] - endl[0,1] ) / dl_len
-
-    nstn = np.floor( dl_len / a )
-
-    # Compute discrete pole location along line
-    stn_x = endl[0,0] + np.array(range(int(nstn)))*dl_x*a
-    stn_y = endl[0,1] + np.array(range(int(nstn)))*dl_y*a
-
-    if mesh.dim==2:
-        ztop = mesh.vectorNy[-1]
-        # Create line of P1 locations
-        M = np.c_[stn_x, np.ones(nstn).T*ztop]
-        # Create line of P2 locations
-        N = np.c_[stn_x+a*dl_x, np.ones(nstn).T*ztop]
-
-    elif mesh.dim==3:
-        ztop = mesh.vectorNz[-1]
-        # Create line of P1 locations
-        M = np.c_[stn_x, stn_y, np.ones(nstn).T*ztop]
-        # Create line of P2 locations
-        N = np.c_[stn_x+a*dl_x, stn_y+a*dl_y, np.ones(nstn).T*ztop]
-
-
-    ## Build list of Tx-Rx locations depending on survey type
-    # Dipole-dipole: Moving tx with [a] spacing -> [AB a MN1 a MN2 ... a MNn]
-    # Pole-dipole: Moving pole on one end -> [A a MN1 a MN2 ... MNn a B]
-    SrcList = []
-
-
-    if stype != 'gradient':
-
-        for ii in range(0, int(nstn)-1):
-
-
-            if stype == 'dpdp':
-                tx = np.c_[M[ii,:],N[ii,:]]
-            elif stype == 'pdp':
-                tx = np.c_[M[ii,:],M[ii,:]]
-
-            # Rx.append(np.c_[M[ii+1:indx,:],N[ii+1:indx,:]])
-
-            # Current elctrode seperation
-            AB = xy_2_r(tx[0,1],endl[1,0],tx[1,1],endl[1,1])
-
-            # Number of receivers to fit
-            nstn = np.min([np.floor( (AB - b) / a ) , n])
-
-            # Check if there is enough space, else break the loop
-            if nstn <= 0:
-                continue
-
-            # Compute discrete pole location along line
-            stn_x = N[ii,0] + dl_x*b + np.array(range(int(nstn)))*dl_x*a
-            stn_y = N[ii,1] + dl_y*b + np.array(range(int(nstn)))*dl_y*a
-
-            # Create receiver poles
-
-            if mesh.dim==3:
-                # Create line of P1 locations
-                P1 = np.c_[stn_x, stn_y, np.ones(nstn).T*ztop]
-                # Create line of P2 locations
-                P2 = np.c_[stn_x+a*dl_x, stn_y+a*dl_y, np.ones(nstn).T*ztop]
-                rxClass = DC.Rx.Dipole(P1, P2)
-
-            elif mesh.dim==2:
-                # Create line of P1 locations
-                P1 = np.c_[stn_x, np.ones(nstn).T*ztop]
-                # Create line of P2 locations
-                P2 = np.c_[stn_x+a*dl_x, np.ones(nstn).T*ztop]
-                rxClass = DC.Rx.Dipole_ky(P1, P2)
-
-            if stype == 'dpdp':
-                    srcClass = DC.Src.Dipole([rxClass], M[ii,:],N[ii,:])
-            elif stype == 'pdp':
-                    srcClass = DC.Src.Pole([rxClass], M[ii,:])
-            SrcList.append(srcClass)
-
-    elif stype == 'gradient':
-
-        # Gradient survey only requires Tx at end of line and creates a square
-        # grid of receivers at in the middle at a pre-set minimum distance
-
-        # Get the edge limit of survey area
-        min_x = endl[0,0] + dl_x * b
-        min_y = endl[0,1] + dl_y * b
-
-        max_x = endl[1,0] - dl_x * b
-        max_y = endl[1,1] - dl_y * b
-
-        box_l = np.sqrt( (min_x - max_x)**2 + (min_y - max_y)**2 )
-        box_w = box_l/2.
-
-        nstn = np.floor( box_l / a )
-
-        # Compute discrete pole location along line
-        stn_x = min_x + np.array(range(int(nstn)))*dl_x*a
-        stn_y = min_y + np.array(range(int(nstn)))*dl_y*a
-
-        # Define number of cross lines
-        nlin = int(np.floor( box_w / a ))
-        lind = range(-nlin,nlin+1)
-
-        ngrad = nstn * len(lind)
-
-        rx = np.zeros([ngrad,6])
-        for ii in range( len(lind) ):
-
-            # Move line in perpendicular direction by dipole spacing
-            lxx = stn_x - lind[ii]*a*dl_y
-            lyy = stn_y + lind[ii]*a*dl_x
-
-
-            M = np.c_[ lxx, lyy , np.ones(nstn).T*ztop]
-            N = np.c_[ lxx+a*dl_x, lyy+a*dl_y, np.ones(nstn).T*ztop]
-            rx[(ii*nstn):((ii+1)*nstn),:] = np.c_[M,N]
-
-            if mesh.dim==3:
-                rxClass = DC.Rx.Dipole(rx[:,:3], rx[:,3:])
-            elif mesh.dim==2:
-                M = M[:,[0,2]]
-                N = N[:,[0,2]]
-                rxClass = DC.Rx.Dipole_ky(rx[:,[0,2]], rx[:,[3,5]])
-            srcClass = DC.Src.Dipole([rxClass], M[0,:], N[-1,:])
-        SrcList.append(srcClass)
-    else:
-        print """stype must be either 'pdp', 'dpdp' or 'gradient'. """
-
-
-    return SrcList
-

SimPEG/EM/Static/Utils/__init__.py

@@ -1 +0,0 @@
-from StaticUtils import *

SimPEG/EM/Static/__init__.py

@@ -1,3 +0,0 @@
-import DC
-import IP
-import SIP

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,131 +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 = getattr(EM.FDEM.Rx, 'Point_' + comp[0])
-    if comp[2] == 'r':
-        real_or_imag = 'real'
-    elif comp[2] == 'i':
-        real_or_imag = 'imag'
-    rx0 = Rx0(XYZ, comp[1], 'imag')
-
-    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, mesh.getEdgeInnerProduct()*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, mesh.getEdgeInnerProduct()*S_m, S_e))
-
-    if verbose:
-        print '  Fetching %s problem' % (fdemType)
-
-    if fdemType == 'e':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem3D_e(mesh, mapping=mapping)
-
-    elif fdemType == 'b':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem3D_b(mesh, mapping=mapping)
-
-    elif fdemType == 'j':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem3D_j(mesh, mapping=mapping)
-
-    elif fdemType == 'h':
-        survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem3D_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,7 +0,0 @@
-import TDEM
-import FDEM
-import Static
-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,208 +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, surveyType='dipole-dipole', unitType='appConductivity', 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]
-        surveyType = survey type 'pole-dipole' or 'dipole-dipole'
-        unitType = Data type "appResistivity" | "appConductivity"  | "volt"
-        Created by @fourndo
-
-    """
-
-    assert surveyType in ['pole-dipole', 'dipole-dipole'], "Source type (surveyType) must be pdp or dpdp (pole dipole or dipole dipole)"
-    assert unitType in ['appResistivity', 'appConductivity', 'volt'], "Unit type (unitType) must be appResistivity or appConductivity 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, surveyType, param[0], param[1], param[2])
-    survey, Tx, Rx = DC.gen_DCIPsurvey(locs, mesh, surveyType, 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 'dipole-dipole' or "gradient"
-        if surveyType == 'pole-dipole':
-            # 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, surveyType=surveyType, unitType=unitType)        # 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.Point_b(np.array([[rxOffset, 0., 1e-3]]), orientation='z', component='imag')
-
-    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.Problem3D_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.Problem3D_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/Inversion_IRLS.py

@@ -1,124 +0,0 @@
-from SimPEG import *
-
-
-def run(N=100, 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
-    mref = np.zeros(mesh.nC)
-
-    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.mref = mref
-#    reg.cell_weights = wr
-#
-    dmis = DataMisfit.l2_DataMisfit(survey)
-    dmis.Wd = 1./wd
-#
-#    opt = Optimization.ProjectedGNCG(maxIter=20,lower=-2.,upper=2., maxIterCG= 10, 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)
-    reg.mref = mref
-    reg.cell_weights = wr
-
-    reg.mref = np.zeros(mesh.nC)
-    eps_p = 5e-2
-    eps_q = 5e-2
-    norms   = [0., 0., 2., 2.]
-
-    opt = Optimization.ProjectedGNCG(maxIter=100 ,lower=-2.,upper=2., maxIterLS = 20, maxIterCG= 10, tolCG = 1e-3)
-    invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
-    update_Jacobi = Directives.Update_lin_PreCond()
-    IRLS = Directives.Update_IRLS( norms=norms,  eps_p=eps_p, eps_q=eps_q)
-
-    inv = Inversion.BaseInversion(invProb, directiveList=[IRLS,betaest,update_Jacobi])
-
-    # 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, reg.l2model, '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,135 +0,0 @@
-import SimPEG as simpeg
-import numpy as np
-from SimPEG import NSEM
-from scipy.constants import mu_0
-import matplotlib.pyplot as plt
-
-np.random.seed(1983)
-
-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 = 26
-    freqs = np.logspace(2,-3,nFreq)
-    # Set mesh parameters
-    ct = 10
-    air = simpeg.Utils.meshTensor([(ct,25,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],25,-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 = 1e-2
-    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.InjectActiveCells(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(NSEM.Rx(simpeg.mkvc(np.array([-0.5]),2).T,rxType))
-    # Source list
-    srcList =[]
-    for freq in freqs:
-            srcList.append(NSEM.SrcNSEM.polxy_1Dprimary(rxList,freq))
-    # Make the survey
-    survey = NSEM.Survey(srcList)
-    survey.mtrue = m_true
-
-    ## Set the problem
-    problem = NSEM.Problem1D_ePrimSec(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.01*abs(survey.dtrue)*np.random.randn(*survey.dtrue.shape)
-
-    if plotIt:
-        fig = NSEM.Utils.dataUtils.plotMT1DModelData(problem,[])
-        fig.suptitle('Target - smooth true')
-
-
-    # Assign uncertainties
-    std = 0.025 # 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.ProjectedGNCG(maxIter = 25)
-    opt.counter = C
-    opt.lower = np.log(1e-4)
-    opt.upper = np.log(5)
-    opt.LSshorten = 0.1
-    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[active]],m1d.x0)
-    reg = simpeg.Regularization.Tikhonov(regMesh)
-    reg.mrefInSmooth = True
-    reg.alpha_s = 1e-1
-    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.
-    beta.coolingFactor = 4.
-    betaest = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=1.)
-    betaest.beta0 = 1.
-    targmis = simpeg.Directives.TargetMisfit()
-    targmis.target = survey.nD
-    # Create an inversion object
-    inv = simpeg.Inversion.BaseInversion(invProb, directiveList=[beta,betaest,targmis])
-
-    ## Run the inversion
-    mopt = inv.run(m_0)
-
-    if plotIt:
-        fig = NSEM.Utils.dataUtils.plotMT1DModelData(problem,[mopt])
-        fig.suptitle('Target - smooth true')
-        fig.axes[0].set_ylim([-10000,500])
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/MT_1D_analytic_nlayer_Earth.py

@@ -1,428 +0,0 @@
-from scipy.constants import epsilon_0, mu_0
-import matplotlib.pyplot as plt
-import numpy as np
-from ipywidgets import *
-from SimPEG.EM.Utils import k, omega
-
-"""
-MT1D: n layered earth problem
-*****************************
-
-Author: Thibaut Astic
-Contact: thast@eos.ubc.ca
-Date: January 2016
-
-This code compute the analytic response of a n-layered Earth to a plane wave (Magneto-Tellurics).
-
-We start by looking at Maxwell's equations in the electric
-field \\\(\\\mathbf{E}\\) and the magnetic flux
-\\\(\\\mathbf{H}\\) to write the wave equations
-\\(\\ \nabla ^2  \mathbf{E_x} + k^2 \mathbf{E_x} = 0 \\) &
-\\(\\ \nabla ^2  \mathbf{H_y} + k^2 \mathbf{H_y} = 0 \\)
-
-Then solving the equations in each layer "j" between z_{j-1} and z_j in the form of
-\\(\\ E_{x,j} (z) = U_j e^{i k (z-z_{j-1})} + D_j e^{-i k (z-z_{j-1})} \\)
-\\(\\ H_{y,j} (z) = \frac{1}{Z_j} (D_j e^{-i k (z-z_{j-1})} - U_j e^{i k (z-z_{j-1})}) \\)
-
-With U and D the Up and Down components of the E-field.
-
-The iteration from one layer to another is ensure by:
-
-\\(\\  \left(\begin{matrix} E_{x,j} \\ H_{y,j} \end{matrix} \right) =
-    P_j T_j P^{-1}_J \left(\begin{matrix} E_{x,j+1} \\ H_{y,j+1} \end{matrix} \right) \\)
-
-And the Boundary Condition is set for the E-field in the last layer, with no Up component (=0)
-and only a down component (=1 then normalized by the highest amplitude to ensure numeric stability)
-
-The layer 0 is assumed to be the air layer.
-
-"""
-
-#Define a frquency range for a survey
-frange = lambda minfreq, maxfreq, step: np.logspace(minfreq,maxfreq,num = step, base = 10.)
-
-#Functions to create random physical Perties for a n-layered earth
-thick = lambda minthick, maxthick, nlayer: np.append(np.array([1.2*10.**5]),
-                                                     np.ndarray.round(minthick + (maxthick-minthick)* np.random.rand(nlayer-1,1)
-                                                            ,decimals =1))
-
-sig = lambda minsig, maxsig, nlayer: np.append(np.array([0.]),
-                                               np.ndarray.round(10.**minsig + (10.**maxsig-10.**minsig)* np.random.rand(nlayer,1)
-                                                      ,decimals=3))
-
-mu  = lambda minmu, maxmu, nlayer: np.append(np.array([1.]),
-                                             np.ndarray.round(minmu + (maxmu-minmu)* np.random.rand(nlayer,1)
-                                                    ,decimals=1))
-
-eps = lambda mineps, maxeps, nlayer: np.append(np.array([1.]),
-                                               np.ndarray.round(mineps + (maxeps-mineps)* np.random.rand(nlayer,1)
-                                                                ,decimals=1))
-
-#Evaluate Impedance Z of a layer
-ImpZ = lambda f, mu, k: omega(f)*mu*mu_0/k
-
-#Complex Cole-Cole Conductivity - EM utils
-PCC= lambda siginf,m,t,c,f: siginf*(1.-(m/(1.+(1j*omega(f)*t)**c)))
-
-#Converted thickness array into top of layer array
-top = lambda thick: np.cumsum(thick)
-
-#Propagation Matrix and theirs inverses
-
-#matrix T for transition of Up and Down components accross a layer
-T = lambda h,k: np.matrix([[np.exp(1j*k*h),0.],[0.,np.exp(-1j*k*h)]],dtype='complex_')
-
-Tinv = lambda h,k: np.matrix([[np.exp(-1j*k*h),0.],[0.,np.exp(1j*k*h)]],dtype='complex_')
-
-#transition of Up and Down components accross a layer
-UD_Z = lambda UD,z,zj,k : T((z-zj),k)*UD
-
-
-#matrix P relating Up and Down components with E and H fields
-P = lambda z: np.matrix([[1.,1,],[-1./z,1./z]],dtype='complex_')
-
-Pinv = lambda z: np.matrix([[1.,-z],[1.,z]],dtype='complex_')/2.
-
-
-#Time Variation of E and H
-E_ZT = lambda U,D,f,t : np.exp(1j*omega(f)*t)*(U+D)
-H_ZT = lambda U,D,Z,f,t : (1./Z)*np.exp(1j*omega(f)*t)*(D-U)
-
-#Plot the configuration of the problem
-def PlotConfiguration(thick,sig,eps,mu,ax,widthg,z):
-
-    topn = top(thick)
-    widthn = np.arange(-widthg,widthg+widthg/10.,widthg/10.)
-
-    ax.set_ylim([z.min(),z.max()])
-    ax.set_xlim([-widthg,widthg])
-
-    ax.set_ylabel("Depth (m)", fontsize=16.)
-    ax.yaxis.tick_right()
-    ax.yaxis.set_label_position("right")
-
-    #define filling for the different layers
-    hatches=['/'  , '+', 'x', '|' , '\\', '-'  , 'o' , 'O' , '.' , '*' ]
-
-    #Write the physical properties of air
-    ax.annotate(("Air, $\sigma$ =%1.0f mS/m")%(sig[0]*10**(3)),
-            xy=(-widthg/2., -np.abs(z.max())/2.), xycoords='data',
-            xytext=(-widthg/2., -np.abs(z.max())/2.), textcoords='data',
-            fontsize=14.)
-
-    ax.annotate(("$\epsilon_r$= %1i")%(eps[0]),
-            xy=(-widthg/2., -np.abs(z.max())/3.), xycoords='data',
-            xytext=(-widthg/2., -np.abs(z.max())/3.), textcoords='data',
-            fontsize=14.)
-
-    ax.annotate(("$\mu_r$= %1i")%(mu[0]),
-            xy=(-widthg/2., -np.abs(z.max())/3.), xycoords='data',
-            xytext=(0, -np.abs(z.max())/3.), textcoords='data',
-            fontsize=14.)
-
-    #Write the physical properties of the differents layers up to the (n-1)-th and fill it with pattern
-    for i in range(1,len(topn)-1,1):
-        if topn[i] == topn[i+1]:
-            pass
-        else:
-            ax.annotate(("$\sigma$ =%3.3f mS/m")%(sig[i]*10**(3)),
-                xy=(0., (2.*topn[i]+topn[i+1])/3), xycoords='data',
-                xytext=(0., (2.*topn[i]+topn[i+1])/3), textcoords='data',
-                fontsize=14.)
-
-            ax.annotate(("$\epsilon_r$= %1i")%(eps[i]),
-                xy=(-widthg/1.1, (2.*topn[i]+topn[i+1])/3), xycoords='data',
-                xytext=(-widthg/1.1, (2.*topn[i]+topn[i+1])/3), textcoords='data',
-                fontsize=14.)
-
-            ax.annotate(("$\mu_r$= %1.2f")%(mu[i]),
-                xy=(-widthg/2., (2.*topn[i]+topn[i+1])/3), xycoords='data',
-                xytext=(-widthg/2., (2.*topn[i]+topn[i+1])/3), textcoords='data',
-                fontsize=14.)
-
-            ax.plot(widthn,topn[i]*np.ones_like(widthn),color='black')
-            ax.fill_between(widthn,topn[i],topn[i+1],alpha=0.3,color="none",edgecolor='black', hatch=hatches[(i-1)%10])
-
-    #Write the physical properties of the n-th layer and fill it with pattern
-    ax.plot(widthn,topn[-1]*np.ones_like(widthn),color='black')
-    ax.fill_between(widthn,topn[-1],z.max(),alpha=0.3,color="none",edgecolor='black', hatch=hatches[(len(topn)-2)%10])
-
-    ax.annotate(("$\sigma$ =%3.3f mS/m")%(sig[-1]*10**(3)),
-            xy=(0., (2.*topn[-1]+z.max())/3), xycoords='data',
-            xytext=(0., (2.*topn[-1]+z.max())/3), textcoords='data',
-            fontsize=14.)
-
-    ax.annotate(("$\epsilon_r$= %1i")%(eps[-1]),
-            xy=(-widthg/1.1, (2.*topn[-1]+z.max())/3), xycoords='data',
-            xytext=(-widthg/1.1, (2.*topn[-1]+z.max())/3), textcoords='data',
-            fontsize=14.)
-
-    ax.annotate(("$\mu_r$= %1.2f")%(mu[-1]),
-            xy=(-widthg/2., (2.*topn[-1]+z.max())/3), xycoords='data',
-            xytext=(-widthg/2., (2.*topn[-1]+z.max())/3), textcoords='data',
-            fontsize=14.)
-
-    #plot Trees!
-    ax.annotate("",
-            xy=(widthg/2., -1.*z.max()/5.), xycoords='data',
-            xytext=(widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.2,head_length=1.2',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(widthg/2., -3./4.*z.max()/5.), xycoords='data',
-            xytext=(widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.4,head_length=1.4',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(widthg/2., -1./2.*z.max()/5.), xycoords='data',
-            xytext=(widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.6,head_length=1.6',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(1.2*widthg/2., -1.*z.max()/5.), xycoords='data',
-            xytext=(1.2*widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.2,head_length=1.2',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(1.2*widthg/2., -3./4.*z.max()/5.), xycoords='data',
-            xytext=(1.2*widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.4,head_length=1.4',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(1.2*widthg/2., -1./2.*z.max()/5.), xycoords='data',
-            xytext=(1.2*widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.6,head_length=1.6',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(1.5*widthg/2., -1.*z.max()/5.), xycoords='data',
-            xytext=(1.5*widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.2,head_length=1.2',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(1.5*widthg/2., -3./4.*z.max()/5.), xycoords='data',
-            xytext=(1.5*widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.4,head_length=1.4',color='green',linewidth=2.)
-            )
-
-    ax.annotate("",
-            xy=(1.5*widthg/2., -1./2.*z.max()/5.), xycoords='data',
-            xytext=(1.5*widthg/2., 0.), textcoords='data',
-            arrowprops=dict(arrowstyle='->, head_width=1.6,head_length=1.6',color='green',linewidth=2.)
-            )
-
-
-    ax.invert_yaxis()
-
-    return ax
-
-#Propagate Up and Down component for a certain frequency & evaluate E and H field
-
-def Propagate(f,H,sig,chg,taux,c,mu,eps,n):
-
-    sigcm = np.zeros_like(sig,dtype='complex_')
-
-    for j in range(1,len(sig)):
-        sigcm[j]=PCC(sig[j],chg[j],taux[j],c[j],f)
-
-    K = k(f, sigcm, mu, eps)
-    Z = ImpZ(f,mu,K)
-
-    EH = np.matrix(np.zeros((2,n+1),dtype = 'complex_'),dtype = 'complex_')
-    UD = np.matrix(np.zeros((2,n+1),dtype = 'complex_'),dtype = 'complex_')
-
-    UD[1,-1] = 1.
-
-    for i in range(-2,-(n+2),-1):
-
-        UD[:,i] = Tinv(H[i+1],K[i])*Pinv(Z[i])*P(Z[i+1])*UD[:,i+1]
-        UD = UD/((np.abs(UD[0,:]+UD[1,:])).max())
-
-    for j in range(0,n+1):
-        EH[:,j] = np.matrix([[1.,1,],[-1./Z[j],1./Z[j]]])*UD[:,j]
-
-    return UD, EH, Z ,K
-
-
-#Evaluate the apparent resistivity and phase for a frequency range
-def appres(F,H,sig,chg,taux,c,mu,eps,n):
-
-    Res = np.zeros_like(F)
-    Phase = np.zeros_like(F)
-    App_ImpZ= np.zeros_like(F,dtype='complex_')
-
-    for i in range(0,len(F)):
-
-        UD,EH,Z ,K = Propagate(F[i],H,sig,chg,taux,c,mu,eps,n)
-
-        App_ImpZ[i] = EH[0,1]/EH[1,1]
-
-        Res[i] = np.abs(App_ImpZ[i])**2./(mu_0*omega(F[i]))
-        Phase[i] = np.angle(App_ImpZ[i], deg = True)
-
-    return Res,Phase
-
-#Evaluate Up, Down components, E and H field, for a frequency range,
-#a discretized depth range and a time range (use to calculate envelope)
-def calculateEHzt(F,H,sig,chg,taux,c,mu,eps,n,zsample,tsample):
-
-    topc = top(H)
-
-    layer = np.zeros(len(zsample),dtype=np.int)-1
-
-    Exzt = np.matrix(np.zeros((len(zsample),len(tsample)),dtype = 'complex_'),dtype = 'complex_')
-    Hyzt = np.matrix(np.zeros((len(zsample),len(tsample)),dtype = 'complex_'),dtype = 'complex_')
-    Uz = np.matrix(np.zeros((len(zsample),len(tsample)),dtype = 'complex_'),dtype = 'complex_')
-    Dz = np.matrix(np.zeros((len(zsample),len(tsample)),dtype = 'complex_'),dtype = 'complex_')
-    UDaux = np.matrix(np.zeros((2,len(zsample)),dtype = 'complex_'),dtype = 'complex_')
-
-    for i in range(0,n+1,1):
-        layer = layer+(zsample>=topc[i])*1
-
-    for j in range(0,len(F)):
-
-        UD,EH,Z ,K = Propagate(F[j],H,sig,chg,taux,c,mu,eps,n)
-
-        for p in range(0,len(zsample)):
-
-            UDaux[:,p] = UD_Z(UD[:,layer[p]],zsample[p],topc[layer[p]],K[layer[p]])
-
-            for q in range(0,len(tsample)):
-
-                Exzt[p,q]  = Exzt[p,q] + E_ZT(UDaux[0,p],UDaux[1,p],F[j],tsample[q])/len(F)
-                Hyzt[p,q] = Hyzt[p,q] + H_ZT(UDaux[0,p],UDaux[1,p],Z[layer[p]],F[j],tsample[q])/len(F)
-                Uz[p,q] = Uz[p,q] + UDaux[0,p]*np.exp(1j*omega(F[j])*tsample[q])/len(F)
-                Dz[p,q] = Dz[p,q] + UDaux[1,p]*np.exp(1j*omega(F[j])*tsample[q])/len(F)
-
-    return  Exzt,Hyzt,Uz,Dz,UDaux,layer
-
-
-#Function to Plot Apparent Resistivity and Phase
-def PlotAppRes(F,H,sig,chg,taux,c,mu,eps,n,fenvelope,PlotEnvelope):
-
-    Res, Phase = appres(F,H,sig,chg,taux,c,mu,eps,n)
-
-    fig,ax = plt.subplots(1,2,figsize=(16,10))
-
-    ax[0].scatter(Res,F,color='black')
-    ax[0].set_xscale('Log')
-    ax[0].set_yscale('Log')
-    ax[0].set_xlim([10.**(np.log10(Res.min())-1.),10.**(np.log10(Res.max())+1.)])
-    ax[0].set_ylim([F.min(),F.max()])
-    ax[0].set_xlabel('Apparent Resistivity (Ohm*m)',fontsize=16.,color="black")
-    ax[0].set_ylabel('Frequency (Hz)',fontsize=16.)
-    ax[0].grid(which='major')
-
-    ax0 = ax[0].twiny()
-
-    ax0.set_xlim([0.,90.])
-    ax0.set_ylim([F.min(),F.max()])
-    ax0.scatter(Phase,F,color='purple')
-    ax0.set_xlabel('Phase (Degrees)',fontsize=16.,color="purple")
-
-    zc=np.arange(-(H[1:].max()+10)*n,(H[1:].max()+10)*n,10.)
-
-    ax[0].tick_params(labelsize=16)
-    ax[1].tick_params(labelsize=16)
-    ax0.tick_params(labelsize=16)
-
-    if PlotEnvelope:
-
-        widthn=np.logspace(np.log10(Res.min())-1., np.log10(Res.max())+1., num=100, endpoint=True, base=10.0)
-        fenvelope1n=np.ones(100)*fenvelope
-        ax[0].plot(widthn,fenvelope1n,linestyle='dashed',color='black')
-
-        tc=np.arange(0.,1./fenvelope,0.01/(fenvelope))
-        Exzt,Hyzt,Uz,Dz,UDaux,layer = calculateEHzt(np.array([fenvelope]),H,sig,chg,taux,c,mu,eps,n,zc,tc)
-
-        ax1=ax[1].twiny()
-
-        ax[1].tick_params(labelsize=16)
-        ax1.tick_params(labelsize=16)
-
-        ax[1].set_xlabel('Amplitude Electric Field E (V/m)',color='blue',fontsize=16)
-
-        ax1.set_xlabel('Amplitude Magnetic Field H (A/m)',color='red',fontsize=16)
-
-        ax[1].fill_betweenx(zc,np.squeeze(np.asarray(np.real(Exzt.min(axis=1)))),
-                      np.squeeze(np.asarray(np.real(Exzt.max(axis=1)))),
-                      color='blue', alpha=0.1)
-
-        ax1.fill_betweenx(zc,np.squeeze(np.asarray(np.real(Hyzt.min(axis=1)))),
-                      np.squeeze(np.asarray(np.real(Hyzt.max(axis=1)))),
-                      color='red', alpha=0.1)
-
-        ax[1] = PlotConfiguration(H,sig,eps,mu,ax[1],(1.5*np.abs(Exzt).max()),zc)
-        ax1.set_xlim([-1.5*np.abs(Hyzt).max(),1.5*np.abs(Hyzt).max()])
-        ax1.set_xlim([-1.5*np.abs(Hyzt).max(),1.5*np.abs(Hyzt).max()])
-    else:
-        print 'No envelop (if True, might be slow)'
-        ax[1] = PlotConfiguration(H,sig,eps,mu,ax[1],1.,zc)
-        ax[1].get_xaxis().set_ticks([])
-
-    plt.show()
-
-#Interactive MT for Notebook
-def PlotAppRes3LayersInteract(h1,h2,sigl1,sigl2,sigl3,mul1,mul2,mul3,epsl1,epsl2,epsl3,PlotEnvelope,F_Envelope):
-
-    frangn=frange(-5,5,100.)
-    sig3= np.array([0.,0.001,0.1, 0.001])
-    thick3 = np.array([120000.,50.,50.])
-    eps3=np.array([1.,1.,1.,1])
-    mu3=np.array([1.,1.,1.,1])
-    chg3=np.array([0.,0.1,0.,0.2])
-    chg3_0=np.array([0.,0.1,0.,0.])
-    taux3=np.array([0.,0.1,0.,0.1])
-    c3=np.array([1.,1.,1.,1.])
-
-    sig3[1]=sigl1
-    sig3[1]=10.**sig3[1]
-    sig3[2]=sigl2
-    sig3[2]=10.**sig3[2]
-    sig3[3]=sigl3
-    sig3[3]=10.**sig3[3]
-    mu3[1]=mul1
-    mu3[2]=mul2
-    mu3[3]=mul3
-    eps3[1]=epsl1
-    eps3[2]=epsl2
-    eps3[3]=epsl3
-    thick3[1]=h1
-    thick3[2]=h2
-
-    PlotAppRes(frangn,thick3,sig3,chg3_0,taux3,c3,mu3,eps3,3,F_Envelope,PlotEnvelope)
-
-
-def run(n=3,plotIt=True):
-    # something to make a plot
-
-    F = frange(-5.,5.,20)
-    H = thick(50.,100.,n)
-    sign = sig(-5.,0.,n)
-    mun = mu(1.,2.,n)
-    epsn = eps(1.,9.,n)
-    chg = np.zeros_like(sign)
-    taux = np.zeros_like(sign)
-    c = np.zeros_like(sign)
-
-    Res, Phase = appres(F,H,sign,chg,taux,c,mun,epsn,n)
-
-    if plotIt:
-
-        PlotAppRes(F, H, sign, chg, taux, c, mun, epsn, n, fenvelope=1000., PlotEnvelope=True)
-
-    return Res, Phase
-
-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 NSEM
-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(NSEM.Rx(simpeg.mkvc(loc,2).T,rxType))
-    # Source list
-    srcList =[]
-    for freq in np.logspace(3,-3,nFreq):
-        srcList.append(NSEM.SrcNSEM.polxy_1Dprimary(rxList,freq))
-    # Survey MT
-    survey = NSEM.Survey(srcList)
-
-    ## Setup the problem object
-    problem = NSEM.Problem3D_ePrimSec(M, sigmaPrimary=sigBG)
-    problem.pair(survey)
-    problem.Solver = Solver
-
-    # Calculate the data
-    fields = problem.fields(sig)
-    dataVec = survey.eval(fields)
-
-    # Make the data
-    mtData = NSEM.Data(survey,dataVec)
-    # Add plots
-    if plotIt:
-        pass
-
-if __name__ == '__main__':
-    run()

SimPEG/Examples/Mesh_Basic_ForwardDC.py

@@ -1,58 +0,0 @@
-from SimPEG import Mesh, Utils, np, SolverLU
-
-def run(plotIt=True):
-
-    """
-        Mesh: Basic Forward 2D DC Resistivity
-        =====================================
-
-        2D DC forward modeling example with Tensor and Curvilinear Meshes
-    """
-
-    # Step1: Generate Tensor and Curvilinear Mesh
-    sz = [40,40]
-    tM = Mesh.TensorMesh(sz)
-    rM = Mesh.CurvilinearMesh(Utils.meshutils.exampleLrmGrid(sz,'rotate'))
-
-    # Step2: Direct Current (DC) operator
-    def DCfun(mesh, pts):
-        D = mesh.faceDiv
-        sigma = 1e-2*np.ones(mesh.nC)
-        MsigI = mesh.getFaceInnerProduct(sigma, invProp=True, invMat=True)
-        A = -D*MsigI*D.T
-        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
-
-    #Step4: Making Figure
-    fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
-    vmin, vmax = phitM.min(), phitM.max()
-    dat = tM.plotImage(phitM, ax=axes[0], clim=(vmin, vmax), grid=True)
-    dat = rM.plotImage(phirM, ax=axes[1], clim=(vmin, vmax), grid=True)
-    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)")
-
-    axes[0].set_title('TensorMesh')
-    axes[1].set_title('CurvilinearMesh')
-    plt.show()
-
-
-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/Utils_surface2ind_topo.py

@@ -1,41 +0,0 @@
-from SimPEG import *
-from SimPEG.Utils import surface2ind_topo
-
-
-def run(plotIt=False, nx = 5, ny = 5):
-    """
-        Here we show how to use :code:`Utils.surface2ind_topo` to identify cells below
-        a topographic surface.
-
-    """
-
-    mesh = Mesh.TensorMesh([nx,ny], x0='CC') # 2D mesh
-    xtopo = np.linspace(mesh.gridN[:,0].min(), mesh.gridN[:,0].max())
-    topo = 0.4*np.sin(xtopo*5) # define a topographic surface
-
-    Topo = np.hstack([Utils.mkvc(xtopo,2),Utils.mkvc(topo,2)]) #make it an array
-
-    indcc = surface2ind_topo(mesh, Topo,'CC')
-
-    if plotIt:
-        from matplotlib.pylab import plt
-        from scipy.interpolate import interp1d
-        fig, ax = plt.subplots(1,1,figsize=(6,6))
-        mesh.plotGrid(ax=ax, nodes=True, centers=True)
-        ax.plot(xtopo,topo,'k',linewidth=1)
-        # ax.plot(mesh.vectorNx, interp1d(xtopo,topo)(mesh.vectorNx),'--k',linewidth=3)
-        ax.plot(mesh.vectorCCx, interp1d(xtopo,topo)(mesh.vectorCCx),'--k',linewidth=3)
-
-
-        aveN2CC = Utils.sdiag(mesh.aveN2CC.T.sum(1))*mesh.aveN2CC.T
-        a = aveN2CC * indcc
-        a[a > 0] = 1.
-        a[a < 0.25] = np.nan
-        a = a.reshape(mesh.vnN, order='F')
-        masked_array = np.ma.array(a, mask=np.isnan(a))
-        ax.pcolor(mesh.vectorNx,mesh.vectorNy,masked_array.T, cmap = plt.cm.gray,alpha=0.2)
-        plt.show()
-
-
-if __name__ == '__main__':
-    run(plotIt=True)

SimPEG/Examples/__init__.py

@@ -1,114 +1 @@
-# Run this file to add imports.
-
-##### AUTOIMPORTS #####
-import EM_FDEM_1D_Inversion
-import Mesh_QuadTree_Creation
-import EM_TDEM_1D_Inversion
-import Mesh_QuadTree_FaceDiv
-import Mesh_Tensor_Creation
-import FLOW_Richards_1D_Celia1990
-import DC_Forward_PseudoSection
-import Mesh_Operators_CahnHilliard
-import Mesh_Basic_Types
-import Inversion_IRLS
-import Inversion_Linear
-import EM_Schenkel_Morrison_Casing
-import MT_3D_Foward
-import Mesh_Basic_ForwardDC
-import MT_1D_ForwardAndInversion
-import Utils_surface2ind_topo
-import MT_1D_analytic_nlayer_Earth
-import EM_FDEM_Analytic_MagDipoleWholespace
-import Mesh_Basic_PlotImage
-import DC_Analytic_Dipole
-import Mesh_QuadTree_HangingNodes
-
-__examples__ = ["EM_FDEM_1D_Inversion", "Mesh_QuadTree_Creation", "EM_TDEM_1D_Inversion", "Mesh_QuadTree_FaceDiv", "Mesh_Tensor_Creation", "FLOW_Richards_1D_Celia1990", "DC_Forward_PseudoSection", "Mesh_Operators_CahnHilliard", "Mesh_Basic_Types", "Inversion_IRLS", "Inversion_Linear", "EM_Schenkel_Morrison_Casing", "MT_3D_Foward", "Mesh_Basic_ForwardDC", "MT_1D_ForwardAndInversion", "Utils_surface2ind_topo", "MT_1D_analytic_nlayer_Earth", "EM_FDEM_Analytic_MagDipoleWholespace", "Mesh_Basic_PlotImage", "DC_Analytic_Dipole", "Mesh_QuadTree_HangingNodes"]
-
-##### 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/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,12 +495,76 @@ 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 ActiveCellsTopo(IdentityMap):
+    """
+        Active model parameters. Extend for cells on topography to air cell (only works for tensor mesh)
+
+    """
+
+    indActive   = None #: Active Cells
+    valInactive = None #: Values of inactive Cells
+    nC          = None #: Number of cells in the full model
+
+    def __init__(self, mesh, indActive, nC=None):
+        self.mesh  = mesh
+
+        self.nC = nC or mesh.nC
+
+        if indActive.dtype is not bool:
+            z = np.zeros(self.nC,dtype=bool)
+            z[indActive] = True
+            indActive = z
+        self.indActive = indActive
+
+        self.indInactive = np.logical_not(indActive)
+        inds = np.nonzero(self.indActive)[0]
+        self.P = sp.csr_matrix((np.ones(inds.size),(inds, range(inds.size))), shape=(self.nC, self.nP))
+
+    @property
+    def shape(self):
+        return (self.nC, self.nP)
+
+    @property
+    def nP(self):
+        """Number of parameters in the model."""
+        return self.indActive.sum()
+
+    def _transform(self, m):
+        val_temp = np.zeros(self.mesh.nC)
+        val_temp[self.indActive] = m
+        valInactive = np.zeros(self.mesh.nC)
+        #1D
+        if self.mesh.dim == 1:
+            z_temp = self.mesh.gridCC
+            val_temp[~self.indActive] = val_temp[np.argmax(z_temp[self.indActive])]
+        #2D
+        elif self.mesh.dim == 2:
+            act_temp = self.indActive.reshape((self.mesh.nCx, self.mesh.nCy), order = 'F')
+            val_temp = val_temp.reshape((self.mesh.nCx, self.mesh.nCy), order = 'F')
+            y_temp = self.mesh.gridCC[:,1].reshape((self.mesh.nCx, self.mesh.nCy), order = 'F')
+            for i in range(self.mesh.nCx):
+                act_tempx = act_temp[i,:] == 1
+                val_temp[i,~act_tempx] = val_temp[i,np.argmax(y_temp[i,act_tempx])]
+            valInactive[~self.indActive] = Utils.mkvc(val_temp)[~self.indActive]
+        #3D
+        elif self.mesh.dim == 3:
+            act_temp = self.indActive.reshape((self.mesh.nCx*self.mesh.nCy, self.mesh.nCz), order = 'F')
+            val_temp = val_temp.reshape((self.mesh.nCx*self.mesh.nCy, self.mesh.nCz), order = 'F')
+            z_temp = self.mesh.gridCC[:,2].reshape((self.mesh.nCx*self.mesh.nCy, self.mesh.nCz), order = 'F')
+            for i in range(self.mesh.nCx*self.mesh.nCy):
+                act_tempxy = act_temp[i,:] == 1
+                val_temp[i,~act_tempxy] = val_temp[i,np.argmax(z_temp[i,act_tempxy])]
+            valInactive[~self.indActive] = Utils.mkvc(val_temp)[~self.indActive]
+
+        self.valInactive = valInactive
+
+        return self.P*m + self.valInactive
+
+    def inverse(self, D):
+        return self.P.T*D
+
+    def deriv(self, m):
+        return self.P
 
 
 class Weighting(IdentityMap):
@@ -606,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
 
@@ -663,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/CurvilinearMesh.py

@@ -2,7 +2,6 @@ from SimPEG import Utils, np
 from BaseMesh import BaseRectangularMesh
 from DiffOperators import DiffOperators
 from InnerProducts import InnerProducts
-from View import CurvView
 
 # Some helper functions.
 length2D = lambda x: (x[:, 0]**2 + x[:, 1]**2)**0.5
@@ -11,7 +10,7 @@ normalize2D = lambda x: x/np.kron(np.ones((1, 2)), Utils.mkvc(length2D(x), 2))
 normalize3D = lambda x: x/np.kron(np.ones((1, 3)), Utils.mkvc(length3D(x), 2))
 
 
-class CurvilinearMesh(BaseRectangularMesh, DiffOperators, InnerProducts, CurvView):
+class CurvilinearMesh(BaseRectangularMesh, DiffOperators, InnerProducts):
     """
     CurvilinearMesh is a mesh class that deals with curvilinear meshes.
 
@@ -331,6 +330,102 @@ class CurvilinearMesh(BaseRectangularMesh, DiffOperators, InnerProducts, CurvVie
 
 
 
+    #############################################
+    #            Plotting Functions             #
+    #############################################
+
+    def plotGrid(self, ax=None, nodes=False, faces=False, centers=False, edges=False, lines=True,  showIt=False):
+        """Plot the nodal, cell-centered and staggered grids for 1,2 and 3 dimensions.
+
+
+        .. plot::
+            :include-source:
+
+            from SimPEG import Mesh, Utils
+            X, Y = Utils.exampleLrmGrid([3,3],'rotate')
+            M = Mesh.CurvilinearMesh([X, Y])
+            M.plotGrid(showIt=True)
+
+        """
+        import matplotlib.pyplot as plt
+        import matplotlib
+        from mpl_toolkits.mplot3d import Axes3D
+        mkvc = Utils.mkvc
+
+        axOpts = {'projection':'3d'} if self.dim == 3 else {}
+        if ax is None: ax = plt.subplot(111, **axOpts)
+
+        NN = self.r(self.gridN, 'N', 'N', 'M')
+        if self.dim == 2:
+
+            if lines:
+                X1 = np.c_[mkvc(NN[0][:-1, :]), mkvc(NN[0][1:, :]), mkvc(NN[0][:-1, :])*np.nan].flatten()
+                Y1 = np.c_[mkvc(NN[1][:-1, :]), mkvc(NN[1][1:, :]), mkvc(NN[1][:-1, :])*np.nan].flatten()
+
+                X2 = np.c_[mkvc(NN[0][:, :-1]), mkvc(NN[0][:, 1:]), mkvc(NN[0][:, :-1])*np.nan].flatten()
+                Y2 = np.c_[mkvc(NN[1][:, :-1]), mkvc(NN[1][:, 1:]), mkvc(NN[1][:, :-1])*np.nan].flatten()
+
+                X = np.r_[X1, X2]
+                Y = np.r_[Y1, Y2]
+
+                ax.plot(X, Y, 'b-')
+            if centers:
+                ax.plot(self.gridCC[:,0],self.gridCC[:,1],'ro')
+
+            # Nx = self.r(self.normals, 'F', 'Fx', 'V')
+            # Ny = self.r(self.normals, 'F', 'Fy', 'V')
+            # Tx = self.r(self.tangents, 'E', 'Ex', 'V')
+            # Ty = self.r(self.tangents, 'E', 'Ey', 'V')
+
+            # ax.plot(self.gridN[:, 0], self.gridN[:, 1], 'bo')
+
+            # nX = np.c_[self.gridFx[:, 0], self.gridFx[:, 0] + Nx[0]*length, self.gridFx[:, 0]*np.nan].flatten()
+            # nY = np.c_[self.gridFx[:, 1], self.gridFx[:, 1] + Nx[1]*length, self.gridFx[:, 1]*np.nan].flatten()
+            # ax.plot(self.gridFx[:, 0], self.gridFx[:, 1], 'rs')
+            # ax.plot(nX, nY, 'r-')
+
+            # nX = np.c_[self.gridFy[:, 0], self.gridFy[:, 0] + Ny[0]*length, self.gridFy[:, 0]*np.nan].flatten()
+            # nY = np.c_[self.gridFy[:, 1], self.gridFy[:, 1] + Ny[1]*length, self.gridFy[:, 1]*np.nan].flatten()
+            # #ax.plot(self.gridFy[:, 0], self.gridFy[:, 1], 'gs')
+            # ax.plot(nX, nY, 'g-')
+
+            # tX = np.c_[self.gridEx[:, 0], self.gridEx[:, 0] + Tx[0]*length, self.gridEx[:, 0]*np.nan].flatten()
+            # tY = np.c_[self.gridEx[:, 1], self.gridEx[:, 1] + Tx[1]*length, self.gridEx[:, 1]*np.nan].flatten()
+            # ax.plot(self.gridEx[:, 0], self.gridEx[:, 1], 'r^')
+            # ax.plot(tX, tY, 'r-')
+
+            # nX = np.c_[self.gridEy[:, 0], self.gridEy[:, 0] + Ty[0]*length, self.gridEy[:, 0]*np.nan].flatten()
+            # nY = np.c_[self.gridEy[:, 1], self.gridEy[:, 1] + Ty[1]*length, self.gridEy[:, 1]*np.nan].flatten()
+            # #ax.plot(self.gridEy[:, 0], self.gridEy[:, 1], 'g^')
+            # ax.plot(nX, nY, 'g-')
+
+        elif self.dim == 3:
+            X1 = np.c_[mkvc(NN[0][:-1, :, :]), mkvc(NN[0][1:, :, :]), mkvc(NN[0][:-1, :, :])*np.nan].flatten()
+            Y1 = np.c_[mkvc(NN[1][:-1, :, :]), mkvc(NN[1][1:, :, :]), mkvc(NN[1][:-1, :, :])*np.nan].flatten()
+            Z1 = np.c_[mkvc(NN[2][:-1, :, :]), mkvc(NN[2][1:, :, :]), mkvc(NN[2][:-1, :, :])*np.nan].flatten()
+
+            X2 = np.c_[mkvc(NN[0][:, :-1, :]), mkvc(NN[0][:, 1:, :]), mkvc(NN[0][:, :-1, :])*np.nan].flatten()
+            Y2 = np.c_[mkvc(NN[1][:, :-1, :]), mkvc(NN[1][:, 1:, :]), mkvc(NN[1][:, :-1, :])*np.nan].flatten()
+            Z2 = np.c_[mkvc(NN[2][:, :-1, :]), mkvc(NN[2][:, 1:, :]), mkvc(NN[2][:, :-1, :])*np.nan].flatten()
+
+            X3 = np.c_[mkvc(NN[0][:, :, :-1]), mkvc(NN[0][:, :, 1:]), mkvc(NN[0][:, :, :-1])*np.nan].flatten()
+            Y3 = np.c_[mkvc(NN[1][:, :, :-1]), mkvc(NN[1][:, :, 1:]), mkvc(NN[1][:, :, :-1])*np.nan].flatten()
+            Z3 = np.c_[mkvc(NN[2][:, :, :-1]), mkvc(NN[2][:, :, 1:]), mkvc(NN[2][:, :, :-1])*np.nan].flatten()
+
+            X = np.r_[X1, X2, X3]
+            Y = np.r_[Y1, Y2, Y3]
+            Z = np.r_[Z1, Z2, Z3]
+
+            ax.plot(X, Y, 'b', zs=Z)
+            ax.set_zlabel('x3')
+
+        ax.grid(True)
+        ax.set_xlabel('x1')
+        ax.set_ylabel('x2')
+
+        if showIt: plt.show()
+
+
 if __name__ == '__main__':
     nc = 5
     h1 = np.cumsum(np.r_[0, np.ones(nc)/(nc)])

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
 
@@ -330,7 +330,7 @@ class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
                 raise NotImplementedError('wrapping in the averaging is not yet implemented')
         return self._aveF2CCV
 
-    def getInterpolationMatCartMesh(self, Mrect, locType='CC', locTypeTo=None):
+    def getInterpolationMatCartMesh(self, Mrect, locType='CC'):
         """
             Takes a cartesian mesh and returns a projection to translate onto the cartesian grid.
         """
@@ -338,22 +338,19 @@ class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
         assert self.isSymmetric, "Currently we have not taken into account other projections for more complicated CylMeshes"
 
 
-        if locTypeTo is None:
-            locTypeTo = locType
-
         if locType == 'F':
             # do this three times for each component
-            X = self.getInterpolationMatCartMesh(Mrect, locType='Fx', locTypeTo=locTypeTo+'x')
-            Y = self.getInterpolationMatCartMesh(Mrect, locType='Fy', locTypeTo=locTypeTo+'y')
-            Z = self.getInterpolationMatCartMesh(Mrect, locType='Fz', locTypeTo=locTypeTo+'z')
+            X = self.getInterpolationMatCartMesh(Mrect, locType='Fx')
+            Y = self.getInterpolationMatCartMesh(Mrect, locType='Fy')
+            Z = self.getInterpolationMatCartMesh(Mrect, locType='Fz')
             return sp.vstack((X,Y,Z))
         if locType == 'E':
-            X = self.getInterpolationMatCartMesh(Mrect, locType='Ex', locTypeTo=locTypeTo+'x')
-            Y = self.getInterpolationMatCartMesh(Mrect, locType='Ey', locTypeTo=locTypeTo+'y')
-            Z = spzeros(getattr(Mrect, 'n' + locTypeTo + 'z'), self.nE)
+            X = self.getInterpolationMatCartMesh(Mrect, locType='Ex')
+            Y = self.getInterpolationMatCartMesh(Mrect, locType='Ey')
+            Z = spzeros(Mrect.nEz, self.nE)
             return sp.vstack((X,Y,Z))
 
-        grid = getattr(Mrect, 'grid' + locTypeTo)
+        grid = getattr(Mrect, 'grid' + locType)
         # This is unit circle stuff, 0 to 2*pi, starting at x-axis, rotating counter clockwise in an x-y slice
         theta = - np.arctan2(grid[:,0] - self.cartesianOrigin[0], grid[:,1] - self.cartesianOrigin[1]) + np.pi/2
         theta[theta < 0] += np.pi*2.0
@@ -369,7 +366,7 @@ class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
                         'Ex': Mrect.tangents[:Mrect.nEx,:],
                         'Ey': Mrect.tangents[Mrect.nEx:(Mrect.nEx+Mrect.nEy),:],
                         'Ez': Mrect.tangents[-Mrect.nEz:,:],
-                    }[locTypeTo]
+                    }[locType]
             if 'F' in locType:
                 normals = np.c_[np.cos(theta), np.sin(theta), np.zeros(theta.size)]
                 proj = ( normals * dotMe ).sum(axis=1)

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')
@@ -584,67 +565,7 @@ class DiffOperators(object):
 
         return Pbc, Pin, Pout
 
-    def getBCProjWF_simple(self, discretization='CC'):
-        """
 
-        The weak form boundary condition projection matrices
-        when mixed boundary condition is used
-
-
-        """
-
-        if discretization is not 'CC':
-            raise NotImplementedError('Boundary conditions only implemented for CC discretization.')
-
-        def projBC(n):
-            ij = ([0,n], [0,1])
-            vals = [0,0]
-            vals[0] = 1
-            vals[1] = 1
-            return sp.csr_matrix((vals, ij), shape=(n+1,2))
-
-        def projDirichlet(n, bc):
-            bc = checkBC(bc)
-            ij = ([0,n], [0,1])
-            vals = [0,0]
-            if(bc[0] == 'dirichlet'):
-                vals[0] = -1
-            if(bc[1] == 'dirichlet'):
-                vals[1] = 1
-            return sp.csr_matrix((vals, ij), shape=(n+1,2))
-
-        BC = [['dirichlet','dirichlet'],['dirichlet','dirichlet'],['dirichlet','dirichlet']]
-        n = self.vnC
-        indF = self.faceBoundaryInd
-        if(self.dim == 1):
-            Pbc = projDirichlet(n[0], BC[0])
-            B = projBC(n[0])
-            indF = indF[0] | indF[1]
-            Pbc = Pbc*sdiag(self.area[indF])
-
-        elif(self.dim == 2):
-            Pbc1 = sp.kron(speye(n[1]), projDirichlet(n[0], BC[0]))
-            Pbc2 = sp.kron(projDirichlet(n[1], BC[1]), speye(n[0]))
-            Pbc = sp.block_diag((Pbc1, Pbc2), format="csr")
-            B1 = sp.kron(speye(n[1]), projBC(n[0]))
-            B2 = sp.kron(projBC(n[1]), speye(n[0]))
-            B = sp.block_diag((B1, B2), format="csr")
-            indF = np.r_[(indF[0] | indF[1]), (indF[2] | indF[3])]
-            Pbc = Pbc*sdiag(self.area[indF])
-
-        elif(self.dim == 3):
-            Pbc1 = kron3(speye(n[2]), speye(n[1]), projDirichlet(n[0], BC[0]))
-            Pbc2 = kron3(speye(n[2]), projDirichlet(n[1], BC[1]), speye(n[0]))
-            Pbc3 = kron3(projDirichlet(n[2], BC[2]), speye(n[1]), speye(n[0]))
-            Pbc = sp.block_diag((Pbc1, Pbc2, Pbc3), format="csr")
-            B1 = kron3(speye(n[2]), speye(n[1]), projBC(n[0]))
-            B2 = kron3(speye(n[2]), projBC(n[1]), speye(n[0]))
-            B3 = kron3(projBC(n[2]), speye(n[1]), speye(n[0]))
-            B = sp.block_diag((B1, B2, B3), format="csr")
-            indF = np.r_[(indF[0] | indF[1]), (indF[2] | indF[3]), (indF[4] | indF[5])]
-            Pbc = Pbc*sdiag(self.area[indF])
-
-        return Pbc, B.T
     # --------------- Averaging ---------------------
 
     @property
@@ -825,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,458 +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])
-
-        # 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 _toVTRObj(mesh,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, 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])
-        return vtkObj
-
-    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()
-