Allow to forward G data without storing the kernel. Add figure-axes options to plot data function

Conflicts:
	.gitignore
	SimPEG/Examples/__init__.py

.bumpversion.cfg

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

.gitignore

@@ -39,3 +39,5 @@ nosetests.xml
 *.sublime-workspace
 docs/_build/
 Makefile
+docs/warnings.txt
+.DS_Store

.travis.yml

@@ -18,24 +18,32 @@ env:
     - TEST_DIR="tests/mesh tests/base tests/utils"
     - TEST_DIR=tests/em/fdem/inverse/derivs
     - TEST_DIR=tests/em/tdem
+    - TEST_DIR=tests/pf
     - 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
+    - TEST_DIR=tests/docs;
+      GAE_PYTHONPATH=${HOME}/.cache/google_appengine;
+      PATH=$PATH:${HOME}/google-cloud-sdk/bin;
+      PYTHONPATH=${PYTHONPATH}:${GAE_PYTHONPATH};
+      CLOUDSDK_CORE_DISABLE_PROMPTS=1
 
 # 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
+# Install packages
+  - 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
   - chmod +x miniconda.sh
   - ./miniconda.sh -b
   - export PATH=/home/travis/anaconda/bin:/home/travis/miniconda/bin:$PATH
   - conda update --yes conda
 
-# Install packages
 install:
-  - conda install --yes pip python=$TRAVIS_PYTHON_VERSION numpy scipy matplotlib cython ipython nose vtk
+  - conda install --yes pip python=$TRAVIS_PYTHON_VERSION numpy scipy matplotlib cython ipython nose vtk sphinx
   - pip install nose-cov python-coveralls
 
   - git clone https://github.com/rowanc1/pymatsolver.git
@@ -46,12 +54,28 @@ install:
 
 # Run test
 script:
+  # test docs
   - nosetests $TEST_DIR --with-cov --cov SimPEG --cov-config .coveragerc -v -s
 
 # Calculate coverage
 after_success:
   - coveralls --config_file .coveragerc
 
+  - if [ "$TRAVIS_BRANCH" = "master" -a "$TRAVIS_PULL_REQUEST" = "false" ]; then
+      if [ ${TEST_DIR} == "tests/docs" ]; then
+        python scripts/fetch_gae_sdk.py $(dirname "${GAE_PYTHONPATH}");
+        openssl aes-256-cbc -K $encrypted_93066031461c_key -iv $encrypted_93066031461c_iv
+          -in docs/credentials.tar.gz.enc -out credentials.tar.gz -d ;
+        if [ ! -d ${HOME}/google-cloud-sdk ]; then curl https://sdk.cloud.google.com | bash; fi ;
+        tar -xzf credentials.tar.gz ;
+        gcloud auth activate-service-account --key-file client-secret.json ;
+        gcloud config set project simpegdocs;
+        gcloud -q components update gae-python;
+        gcloud -q preview app deploy ./docs/app.yaml --version ${TRAVIS_COMMIT} --promote;
+      fi;
+    fi
+
+
 notifications:
   email:
     - rowanc1@gmail.com

README.rst

@@ -1,4 +1,4 @@
-.. image:: https://raw.github.com/simpeg/simpeg/master/docs/simpeg-logo.png
+.. image:: https://raw.github.com/simpeg/simpeg/master/docs/images/simpeg-logo.png
     :alt: SimPEG Logo
 
 ======
@@ -25,6 +25,10 @@ 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:

SimPEG/DCIP/BaseDC.py

@@ -162,8 +162,8 @@ class ProblemDC_CC(Problem.BaseProblem):
         """
             Makes the matrix A(m) for the DC resistivity problem.
 
-            :param numpy.array m: model
-            :rtype: scipy.csc_matrix
+            :param numpy.ndarray m: model
+            :rtype: scipy.sparse.csc_matrix
             :return: A(m)
 
             .. math::

SimPEG/DCIP/BaseIP.py

@@ -71,7 +71,7 @@ class ProblemIP(Problem.BaseProblem):
             Makes the matrix A(m) for the DC resistivity problem.
 
             :param numpy.array m: model
-            :rtype: scipy.csc_matrix
+            :rtype: scipy.sparse.csc_matrix
             :return: A(m)
 
             .. math::

SimPEG/DCIP/DCIPUtils.py

@@ -1,12 +1,16 @@
-from SimPEG import np
+from SimPEG import np, Utils
 import BaseDC as DC
 import BaseDC as IP
+import warnings
 
 def getActiveindfromTopo(mesh, topo):
 # def genActiveindfromTopo(mesh, topo):
     """
         Get active indices from topography
     """
+    warnings.warn(
+            "`getActiveindfromTopo` is deprecated and will be removed in future versions. Use `SimPEG.Utils.surface2ind_topo` instead",
+            FutureWarning)
     from scipy.interpolate import NearestNDInterpolator
     if mesh.dim==3:
         nCxy = mesh.nCx*mesh.nCy
@@ -28,6 +32,9 @@ def gettopoCC(mesh, airind):
     """
         Get topography from active indices of mesh.
     """
+    warnings.warn(
+            "`gettopoCC` is deprecated and will be removed in future versions. Use `SimPEG.Utils.surface2ind_topo` instead",
+            FutureWarning)
     mesh2D = Mesh.TensorMesh([mesh.hx, mesh.hy], mesh.x0[:2])
     zc = mesh.gridCC[:,2]
     AIRIND = airind.reshape((mesh.vnC[0]*mesh.vnC[1],mesh.vnC[2]), order='F')
@@ -118,34 +125,27 @@ def readUBC_DC3Dobstopo(filename,mesh,topo,probType="CC"):
 
 def readUBC_DC2DModel(fileName):
     """
-        Read UBC GIF 2DTensor model and generate 2D Tensor model in simpeg
+    Read UBC GIF 2DTensor model and generate 2D Tensor model in simpeg
 
-        Input:
-        :param fileName, path to the UBC GIF 2D model file
-
-        Output:
-        :param SimPEG TensorMesh 2D object
-        :return
-
-        Created on Thu Nov 12 13:14:10 2015
-
-        @author: dominiquef
+    :param string fileName: path to the UBC GIF 2D model file
+    :rtype: TensorMesh
+    :return: SimPEG TensorMesh 2D object
 
     """
     from SimPEG import np, mkvc
 
     # Open fileand skip header... assume that we know the mesh already
-    obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!')
+    obsfile = np.genfromtxt(fileName, delimiter=' \n', dtype=np.str, comments='!')
 
-    dim = np.array(obsfile[0].split(),dtype=float)
+    dim = np.array(obsfile[0].split(), dtype=float)
 
-    temp = np.array(obsfile[1].split(),dtype=float)
+    temp = np.array(obsfile[1].split(), dtype=float)
 
     if len(temp) > 1:
         model = np.zeros(dim)
 
         for ii in range(len(obsfile)-1):
-            mm = np.array(obsfile[ii+1].split(),dtype=float)
+            mm = np.array(obsfile[ii+1].split(), dtype=float)
             model[:,ii] = mm
 
         model = model[:,::-1]
@@ -153,10 +153,10 @@ def readUBC_DC2DModel(fileName):
     else:
 
         if len(obsfile[1:])==1:
-            mm = np.array(obsfile[1:].split(),dtype=float)
+            mm = np.array(obsfile[1:].split(), dtype=float)
 
         else:
-            mm = np.array(obsfile[1:],dtype=float)
+            mm = np.array(obsfile[1:], dtype=float)
 
         # Permute the second dimension to flip the order
         model = mm.reshape(dim[1],dim[0])
@@ -169,32 +169,25 @@ def readUBC_DC2DModel(fileName):
 
     return model
 
-def plot_pseudoSection(DCsurvey, axs, stype='dpdp', dtype="appc", clim=None):
+
+def plot_pseudoSection(DCsurvey, axs, surveyType='dipole-dipole', unitType='volt', clim=None, cblabel=True, axlabel = True, colorbar = True, contour = None):
     """
-        Read list of 2D tx-rx location and plot a speudo-section of apparent
-        resistivity.
+    Read list of 2D tx-rx location and plot a speudo-section of apparent
+    resistivity.
 
-        Assumes flat topo for now...
+    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
+    :param SurveyDC DCsurvey:
+    :param string surveyType: Either 'pole-dipole'  | 'dipole-dipole'
+    :param string unitType: Either 'appResistivity' | 'appConductivity'  | 'volt'
+    :rtype: matplotlib.plt
+    :return: figure scatter plot overlayed on image
 
     """
     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 = []
@@ -221,76 +214,92 @@ def plot_pseudoSection(DCsurvey, axs, stype='dpdp', dtype="appc", clim=None):
         Cmid = (Tx[0][0] + Tx[1][0])/2
         Pmid = (Rx[0][:,0] + Rx[1][:,0])/2
 
-        # Change output for dtype
-        if dtype == 'volt':
+        # Change output for unitType
+        if unitType == 'volt':
 
             rho = np.hstack([rho,data])
 
         else:
 
             # Compute pant leg of apparent rho
-            if stype == 'pdp':
+            if surveyType == 'pole-dipole':
 
                 leg =  data * 2*np.pi  * MA * ( MA + MN ) / MN
 
-            elif stype == 'dpdp':
+            elif surveyType == 'dipole-dipole':
 
                 leg = data * 2*np.pi / ( 1/MA - 1/MB - 1/NB + 1/NA )
 
             else:
-                print """dtype must be 'pdp'(pole-dipole) | 'dpdp' (dipole-dipole) """
+                print """unitType must be 'pole-dipole' | 'dipole-dipole' """
                 break
 
 
-            if dtype == 'appc':
+            if unitType == 'appConductivity':
 
                 leg = np.log10(abs(1./leg))
                 rho = np.hstack([rho,leg])
 
-            elif dtype == 'appr':
+            elif unitType == 'appResistivity':
 
                 leg = np.log10(abs(leg))
                 rho = np.hstack([rho,leg])
 
             else:
-                print """dtype must be 'appr' | 'appc' | 'volt' """
+                print """unitType must be 'appResistivity' | 'appConductivity' | 'volt' """
                 break
 
         midx = np.hstack([midx, ( Cmid + Pmid )/2 ])
-        midz = np.hstack([midz, -np.abs(Cmid-Pmid)/2 + z0 ])
-
-    ax = axs
+        midz = np.hstack([midz, -np.abs(Cmid-Pmid)/2 + (Tx[0][2] + Tx[1][2])/2 ])
 
     # 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')
 
+    # Scale the color scheme
     if clim == None:
         vmin, vmax = rho.min(), rho.max()
     else:
         vmin, vmax = clim[0], clim[1]
 
+    # Plot data
     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))
-    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([])
+    ph = plt.pcolormesh(grid_x[:,0],grid_z[0,:],grid_rho.T, vmin = vmin, vmax = vmax)
+    plt.gca().tick_params(axis='both', which='major', labelsize=8)
+
+    if contour is not None:
+        plt.contour(grid_x,grid_z,grid_rho,levels = contour,colors = 'r', vmin = vmin, vmax = vmax)
+
+    # Add scatter points
+    axs.scatter(midx,midz,s=10,c=rho.T, vmin = vmin, vmax = vmax)
+
+    if colorbar:
+
+        if unitType == 'volt':
+            cbar = plt.colorbar(ph, ax = axs, format="%4.1f",fraction=0.04,orientation="horizontal")
+
+        else:
+            cbar = plt.colorbar(ph, ax = axs, 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 unitType == 'appConductivity':
+                cbar.set_label("App.Cond",size=12)
+            elif unitType == 'appResistivity':
+                cbar.set_label("App.Res.",size=12)
+            elif unitType == 'volt':
+                cbar.set_label("Potential (V)",size=12)
+
+
+    if not axlabel:
+        axs.set_xticklabels([])
+        axs.set_yticklabels([])
 
     plt.gca().set_aspect('equal', adjustable='box')
 
@@ -298,27 +307,24 @@ def plot_pseudoSection(DCsurvey, axs, stype='dpdp', dtype="appc", clim=None):
 
     return ph
 
-def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
+def gen_DCIPsurvey(endl, mesh, surveyType, AM_sep, MN_sep, nrx):
     """
-        Load in endpoints and survey specifications to generate Tx, Rx location
-        stations.
+    Load in endpoints and survey specifications to generate Tx, Rx location
+    stations.
 
-        Assumes flat topo for now...
+    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
+    :param numpy.array endl: input endpoints [[x1, y1] , [x2, y2]]
+    :param Mesh mesh: SimPEG mesh object
+    :param string surveyType: 'dipole-dipole' | 'pole-dipole' | 'gradient'
+    :param float AM_sep: transmitter (A) - receiver (M) seperation
+    :param float b: receiver dipole seperation
+    :param float nrx: 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
+    :rtype: DC.Survey, Src, Rx
+    :returns: DC survey, Source
 
-        Created on Wed December 9th, 2015
-
-        @author: dominiquef
-        !! Require clean up to deal with DCsurvey
+    !! Require clean up to deal with DCsurvey
     """
 
     from SimPEG import np
@@ -334,17 +340,17 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
     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 )
+    nstn = np.floor( dl_len / AM_sep )
 
     # 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
+    stn_x = endl[0,0] + np.array(range(int(nstn)))*dl_x*AM_sep
+    stn_y = endl[0,1] + np.array(range(int(nstn)))*dl_y*AM_sep
 
     # Create line of P1 locations
     M = np.c_[stn_x, stn_y, np.ones(nstn).T*mesh.vectorNz[-1]]
 
     # Create line of P2 locations
-    N = np.c_[stn_x+a*dl_x, stn_y+a*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]]
+    N = np.c_[stn_x+AM_sep*dl_x, stn_y+AM_sep*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]]
 
     ## Build list of Tx-Rx locations depending on survey type
     # Dipole-dipole: Moving tx with [a] spacing -> [AB a MN1 a MN2 ... a MNn]
@@ -354,14 +360,14 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
     SrcList = []
 
 
-    if stype != 'gradient':
+    if surveyType != 'gradient':
 
         for ii in range(0, int(nstn)-1):
 
 
-            if stype == 'dpdp':
+            if surveyType == 'dipole-dipole':
                 tx = np.c_[M[ii,:],N[ii,:]]
-            elif stype == 'pdp':
+            elif surveyType == 'pole-dipole':
                 tx = np.c_[M[ii,:],M[ii,:]]
 
             # Rx.append(np.c_[M[ii+1:indx,:],N[ii+1:indx,:]])
@@ -370,33 +376,33 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
             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])
+            nstn = np.min([np.floor( (AB - MN_sep) / AM_sep ) , nrx])
 
             # 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
+            stn_x = N[ii,0] + dl_x*MN_sep + np.array(range(int(nstn)))*dl_x*AM_sep
+            stn_y = N[ii,1] + dl_y*MN_sep + np.array(range(int(nstn)))*dl_y*AM_sep
 
             # Create receiver poles
             # Create line of P1 locations
             P1 = np.c_[stn_x, stn_y, np.ones(nstn).T*mesh.vectorNz[-1]]
 
             # Create line of P2 locations
-            P2 = np.c_[stn_x+a*dl_x, stn_y+a*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]]
+            P2 = np.c_[stn_x+AM_sep*dl_x, stn_y+AM_sep*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]]
 
             Rx.append(np.c_[P1,P2])
             rxClass = DC.RxDipole(P1, P2)
             Tx.append(tx)
-            if stype == 'dpdp':
+            if surveyType == 'dipole-dipole':
                 srcClass = DC.SrcDipole([rxClass], M[ii,:],N[ii,:])
-            elif stype == 'pdp':
+            elif surveyType == 'pole-dipole':
                 srcClass = DC.SrcDipole([rxClass], M[ii,:],M[ii,:])
             SrcList.append(srcClass)
 
-    elif stype == 'gradient':
+    elif surveyType == '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
@@ -404,23 +410,23 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
         Tx.append(np.c_[M[0,:],N[-1,:]])
 
         # Get the edge limit of survey area
-        min_x = endl[0,0] + dl_x * b
-        min_y = endl[0,1] + dl_y * b
+        min_x = endl[0,0] + dl_x * MN_sep
+        min_y = endl[0,1] + dl_y * MN_sep
 
-        max_x = endl[1,0] - dl_x * b
-        max_y = endl[1,1] - dl_y * b
+        max_x = endl[1,0] - dl_x * MN_sep
+        max_y = endl[1,1] - dl_y * MN_sep
 
         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 )
+        nstn = np.floor( box_l / AM_sep )
 
         # 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
+        stn_x = min_x + np.array(range(int(nstn)))*dl_x*AM_sep
+        stn_y = min_y + np.array(range(int(nstn)))*dl_y*AM_sep
 
         # Define number of cross lines
-        nlin = int(np.floor( box_w / a ))
+        nlin = int(np.floor( box_w / AM_sep ))
         lind = range(-nlin,nlin+1)
 
         ngrad = nstn * len(lind)
@@ -429,12 +435,12 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
         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
+            lxx = stn_x - lind[ii]*AM_sep*dl_y
+            lyy = stn_y + lind[ii]*AM_sep*dl_x
 
 
             M = np.c_[ lxx, lyy , np.ones(nstn).T*mesh.vectorNz[-1]]
-            N = np.c_[ lxx+a*dl_x, lyy+a*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]]
+            N = np.c_[ lxx+AM_sep*dl_x, lyy+AM_sep*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]]
 
             rx[(ii*nstn):((ii+1)*nstn),:] = np.c_[M,N]
 
@@ -443,37 +449,37 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
         srcClass = DC.SrcDipole([rxClass], M[0,:], N[-1,:])
         SrcList.append(srcClass)
     else:
-        print """stype must be either 'pdp', 'dpdp' or 'gradient'. """
+        print """surveyType must be either 'pole-dipole', 'dipole-dipole' or 'gradient'. """
 
     survey = DC.SurveyDC(SrcList)
     return survey, Tx, Rx
 
-def writeUBC_DCobs(fileName, DCsurvey, dtype, stype):
+
+def writeUBC_DCobs(fileName, DCsurvey, dim, surveyType, iptype = 0):
     """
         Write UBC GIF DCIP 2D or 3D observation file
 
-        Input:
-        :string fileName -> including path where the file is written out
-        :DCsurvey -> DC survey class object
-        :string dtype ->  either '2D' | '3D'
-        :string  stype ->  either 'SURFACE' | 'GENERAL'
-
-        Output:
-        :param UBC2D-Data file
-        :return
-
-        Last edit: February 16th, 2016
-
-        @author: dominiquef
-
+        :param string fileName: including path where the file is written out
+        :param Survey DCsurvey: DC survey class object
+        :param string dim:  either '2D' | '3D'
+        :param string surveyType:  either 'SURFACE' | 'GENERAL'
+        :rtype: file
+        :return: UBC2D-Data file
     """
+
     from SimPEG import mkvc
 
-    assert (dtype=='2D') | (dtype=='3D'), "Data must be either '2D' | '3D'"
-    assert (stype=='SURFACE') | (stype=='GENERAL') | (stype=='SIMPLE'), "Data must be either 'SURFACE' | 'GENERAL' | 'SIMPLE'"
+    assert (dim=='2D') | (dim=='3D'), "Data must be either '2D' | '3D'"
+    assert (surveyType=='SURFACE') | (surveyType=='GENERAL') | (surveyType=='SIMPLE'), "Data must be either 'SURFACE' | 'GENERAL' | 'SIMPLE'"
 
     fid = open(fileName,'w')
-    fid.write('! ' + stype + ' FORMAT\n')
+    fid.write('! ' + surveyType + ' FORMAT\n')
+
+    if iptype!=0:
+        fid.write('IPTYPE=%i\n'%iptype)
+
+    else:
+        fid.write('! ' + stype + ' FORMAT\n')
 
     count = 0
 
@@ -488,10 +494,10 @@ def writeUBC_DCobs(fileName, DCsurvey, dtype, stype):
         M = rx[0]
         N = rx[1]
 
-        # Adapt source-receiver location for dtype and stype
-        if dtype=='2D':
+        # Adapt source-receiver location for dim and surveyType
+        if dim=='2D':
 
-            if stype == 'SIMPLE':
+            if surveyType == 'SIMPLE':
 
                 #fid.writelines("%e " % ii for ii in mkvc(tx[0,:]))
                 A = np.repeat(tx[0,0],M.shape[0],axis=0)
@@ -504,41 +510,49 @@ def writeUBC_DCobs(fileName, DCsurvey, dtype, stype):
 
             else:
 
-                if stype == 'SURFACE':
+                if surveyType == 'SURFACE':
 
-                    fid.writelines("%e " % ii for ii in mkvc(tx[0,:]))
+                    fid.writelines("%f " % ii for ii in mkvc(tx[0,:]))
                     M = M[:,0]
                     N = N[:,0]
 
-                if stype == 'GENERAL':
+                if surveyType == 'GENERAL':
+
+                    # Flip sign for z-elevation to depth
+                    tx[2::2,:] = -tx[2::2,:]
 
                     fid.writelines("%e " % ii for ii in mkvc(tx[::2,:]))
                     M = M[:,0::2]
                     N = N[:,0::2]
 
+                    # Flip sign for z-elevation to depth
+                    M[:,1::2] = -M[:,1::2]
+                    N[:,1::2] = -N[:,1::2]
+
                 fid.write('%i\n'% nD)
-                np.savetxt(fid, np.c_[ M, N , DCsurvey.dobs[count:count+nD], DCsurvey.std[count:count+nD] ], fmt='%e',delimiter=' ',newline='\n')
+                np.savetxt(fid, np.c_[ M, N , DCsurvey.dobs[count:count+nD], DCsurvey.std[count:count+nD] ], fmt='%f',delimiter=' ',newline='\n')
 
-        if dtype=='3D':
+        if dim=='3D':
 
-            if stype == 'SURFACE':
+            if surveyType == 'SURFACE':
 
                 fid.writelines("%e " % ii for ii in mkvc(tx[0:2,:]))
                 M = M[:,0:2]
                 N = N[:,0:2]
 
-            if stype == 'GENERAL':
+            if surveyType == 'GENERAL':
 
-                fid.writelines("%e " % ii for ii in mkvc(tx))
+                fid.writelines("%e " % ii for ii in mkvc(tx[0:3,:]))
 
             fid.write('%i\n'% nD)
             np.savetxt(fid, np.c_[ M, N , DCsurvey.dobs[count:count+nD], DCsurvey.std[count:count+nD] ], fmt='%e',delimiter=' ',newline='\n')
+            fid.write('\n')
 
         count += nD
 
     fid.close()
 
-def convertObs_DC3D_to_2D(DCsurvey,lineID, flag = 'local'):
+def convertObs_DC3D_to_2D(DCsurvey, lineID, flag='local'):
     """
         Read DC survey and projects the coordinate system
         according to the flag = 'Xloc' | 'Yloc' | 'local' (default)
@@ -547,15 +561,9 @@ def convertObs_DC3D_to_2D(DCsurvey,lineID, flag = 'local'):
 
         The Z value is preserved, but Y coordinates zeroed.
 
-        Input:
-        :param survey3D
-
-        Output:
-        :figure survey2D
-
-        Edited April 6th, 2016
-
-        @author: dominiquef
+        :param DC.Survey survey3D: 3D simpeg DC survey
+        :rtype: DC.Survey
+        :return: survey2D
 
     """
     from SimPEG import np
@@ -641,50 +649,53 @@ def convertObs_DC3D_to_2D(DCsurvey,lineID, flag = 'local'):
 
     return DCsurvey2D
 
-def readUBC_DC3Dobs(fileName):
+def readUBC_DC3Dobs(fileName, rtype = 'DC'):
     """
-        Read UBC GIF DCIP 3D observation file and generate survey
+        Read UBC GIF IP 3D observation file and generate survey
 
-        Input:
-        :param fileName, path to the UBC GIF 3D obs file
-
-        Output:
-        :param DCIPsurvey
-        :return
-
-        Created on Mon April 6th, 2015
-
-        @author: dominiquef
+        :param string fileName:, path to the UBC GIF 3D obs file
+        :rtype: Survey
+        :return: DCIPsurvey
 
     """
+    zflag = True # Flag for z value provided
 
     # Load file
-    obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!')
+    if rtype == 'IP':
+        obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='IPTYPE')
+
+    elif rtype == 'DC':
+        obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!')
+
+    else:
+        print "rtype must be 'DC'(default) | 'IP'"
 
     # Pre-allocate
     srcLists = []
     Rx = []
     d = []
     wd = []
-    zflag = True # Flag for z value provided
+
 
     # Countdown for number of obs/tx
     count = 0
     for ii in range(obsfile.shape[0]):
 
+        # Skip if blank line
         if not obsfile[ii]:
             continue
 
-        # First line is transmitter with number of receivers
+        # First line or end of a transmitter block, read transmitter info
         if count==0:
-
-            temp = (np.fromstring(obsfile[ii], dtype=float,sep=' ').T)
+            # Read the line
+            temp = (np.fromstring(obsfile[ii], dtype=float, sep=' ').T)
             count = int(temp[-1])
 
             # Check if z value is provided, if False -> nan
             if len(temp)==5:
-                tx = np.r_[temp[0:2],np.nan,temp[0:2],np.nan]
-                zflag = False
+                tx = np.r_[temp[0:2],np.nan,temp[2:4],np.nan]
+
+                zflag = False # Pass on the flag to the receiver loc
 
             else:
                 tx = temp[:-1]
@@ -692,8 +703,16 @@ def readUBC_DC3Dobs(fileName):
             rx = []
             continue
 
-        temp = np.fromstring(obsfile[ii], dtype=float,sep=' ')
+        temp = np.fromstring(obsfile[ii], dtype=float,sep=' ') # Get the string
 
+        # Filter out negative IP
+#        if temp[-2] < 0:
+#            count = count -1
+#            print "Negative!"
+#
+#        else:
+
+        # If the Z-location is provided, otherwise put nan
         if zflag:
 
             rx.append(temp[:-2])
@@ -703,7 +722,7 @@ def readUBC_DC3Dobs(fileName):
                 wd.append(temp[-1])
 
         else:
-            rx.append(np.r_[temp[0:2],np.nan,temp[0:2],np.nan] )
+            rx.append(np.r_[temp[0:2],np.nan,temp[2:4],np.nan] )
             # Check if there is data with the location
             if len(temp)==6:
                 d.append(temp[-2])
@@ -711,7 +730,7 @@ def readUBC_DC3Dobs(fileName):
 
         count = count -1
 
-        # Reach the end of transmitter block
+        # Reach the end of transmitter block, append the src, rx and continue
         if count == 0:
             rx = np.asarray(rx)
             Rx = DC.RxDipole(rx[:,:3],rx[:,3:])
@@ -730,17 +749,9 @@ def readUBC_DC2Dobs(fileName):
         ------- NEEDS TO BE UPDATED ------
         Read UBC GIF 2D observation file and generate arrays for tx-rx location
 
-        Input:
-        :param fileName, path to the UBC GIF 2D model file
-
-        Output:
-        :param rx, tx
-        :return
-
-        Created on Thu Nov 12 13:14:10 2015
-
-        @author: dominiquef
-
+        :param string fileName: path to the UBC GIF 2D model file
+        :rtype: (DC.Src, DC.Rx, ??, ??)
+        :return: source_locs, rx_locs, ??, ??
     """
 
     from SimPEG import np
@@ -780,11 +791,9 @@ def readUBC_DC2Dpre(fileName):
         Read UBC GIF DCIP 2D observation file and generate arrays for tx-rx location
 
         Input:
-        :param fileName, path to the UBC GIF 3D obs file
-
-        Output:
-        DCsurvey
-        :return
+        :param string fileName: path to the UBC GIF 3D obs file
+        :rtype: DC.Survey
+        :return: DCsurvey
 
         Created on Mon March 9th, 2016 << Doug's 70th Birthday !! >>
 
@@ -846,12 +855,9 @@ def readUBC_DC2DMesh(fileName):
     """
         Read UBC GIF 2DTensor mesh and generate 2D Tensor mesh in simpeg
 
-        Input:
-        :param fileName, path to the UBC GIF mesh file
-
-        Output:
-        :param SimPEG TensorMesh 2D object
-        :return
+        :param string fileName: path to the UBC GIF mesh file
+        :rtype: Mesh.TensorMesh
+        :return: SimPEG TensorMesh 2D object
 
         Created on Thu Nov 12 13:14:10 2015
 
@@ -917,12 +923,9 @@ def xy_2_lineID(DCsurvey):
         they were collected. May need to generalize for random
         point locations, but will be more expensive
 
-        Input:
-        :param DCdict Vectors of station location
-
-        Output:
-        :param LineID Vector of integers
-        :return
+        :param numpy.array DCdict: Vectors of station location
+        :rtype: numpy.array
+        :return: LineID Vector of integers
 
         Created on Thu Feb 11, 2015
 

SimPEG/Directives.py

@@ -144,12 +144,18 @@ 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:
-            self._target = self.survey.nD*0.5
+            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
         return self._target
     @target.setter
     def target(self, val):
@@ -161,7 +167,7 @@ class TargetMisfit(InversionDirective):
 
 
 
-class _SaveEveryIteration(InversionDirective):
+class SaveEveryIteration(InversionDirective):
     @property
     def name(self):
         if getattr(self, '_name', None) is None:
@@ -182,7 +188,7 @@ class _SaveEveryIteration(InversionDirective):
         self._fileName = value
 
 
-class SaveModelEveryIteration(_SaveEveryIteration):
+class SaveModelEveryIteration(SaveEveryIteration):
     """SaveModelEveryIteration"""
 
     def initialize(self):
@@ -192,7 +198,7 @@ class SaveModelEveryIteration(_SaveEveryIteration):
         np.save('%03d-%s' % (self.opt.iter, self.fileName), self.opt.xc)
 
 
-class SaveOutputEveryIteration(_SaveEveryIteration):
+class SaveOutputEveryIteration(SaveEveryIteration):
     """SaveModelEveryIteration"""
 
     def initialize(self):
@@ -206,7 +212,7 @@ class SaveOutputEveryIteration(_SaveEveryIteration):
         f.write(' %3d %1.4e %1.4e %1.4e %1.4e\n'%(self.opt.iter, self.invProb.beta, self.invProb.phi_d, self.invProb.phi_m, self.opt.f))
         f.close()
 
-class SaveOutputDictEveryIteration(_SaveEveryIteration):
+class SaveOutputDictEveryIteration(SaveEveryIteration):
     """SaveOutputDictEveryIteration"""
 
     def initialize(self):
@@ -222,7 +228,7 @@ class SaveOutputDictEveryIteration(_SaveEveryIteration):
             mref = 0
         mx = self.reg.Wx * ( self.reg.mapping * (self.invProb.curModel - mref) )
         phi_mx = 0.5 * mx.dot(mx)
-        if self.prob.mesh.dim==2:
+        if self.prob.mesh.dim >= 2:
             my = self.reg.Wy * ( self.reg.mapping * (self.invProb.curModel - mref) )
             phi_my = 0.5 * my.dot(my)
         else:
@@ -237,45 +243,6 @@ class SaveOutputDictEveryIteration(_SaveEveryIteration):
         # Save the file as a npz
         np.savez('{:03d}-{:s}'.format(self.opt.iter,self.fileName), iter=self.opt.iter, beta=self.invProb.beta, phi_d=self.invProb.phi_d, phi_m=self.invProb.phi_m, phi_ms=phi_ms, phi_mx=phi_mx, phi_my=phi_my, phi_mz=phi_mz,f=self.opt.f, m=self.invProb.curModel,dpred=self.invProb.dpred)
 
-class SaveOutputDictEveryIteration(_SaveEveryIteration):
-    """SaveOutputDictEveryIteration
-    A directive that saves some relevant information from the inversion run to a numpy .npz dictionary file (see numpy.savez function for further info).
-    """
-
-    def initialize(self):
-        print "SimPEG.SaveOutputDictEveryIteration will save your inversion progress as dictionary: '%s-###.npz'"%self.fileName
-
-    def endIter(self):
-        # Save the data.
-        ms = self.reg.Ws * ( self.reg.mapping * (self.invProb.curModel - self.reg.mref) )
-        phi_ms = 0.5*ms.dot(ms)
-        if self.reg.mrefInSmooth == True:
-            mref = self.reg.mref
-        else:
-            mref = 0
-        mx = self.reg.Wx * ( self.reg.mapping * (self.invProb.curModel - mref) )
-        phi_mx = 0.5 * mx.dot(mx)
-        if self.prob.mesh.dim==2:
-            my = self.reg.Wy * ( self.reg.mapping * (self.invProb.curModel - mref) )
-            phi_my = 0.5 * my.dot(my)
-        else:
-            phi_my = 'NaN'
-        if self.prob.mesh.dim==3 and 'CYL' not in self.prob.mesh._meshType:
-            mz = self.reg.Wz * ( self.reg.mapping * (self.invProb.curModel - mref) )
-            phi_mz = 0.5 * mz.dot(mz)
-        else:
-            phi_mz = 'NaN'
-
-
-        # Save the file as a npz
-        np.savez('{:s}-{:03d}'.format(self.fileName,self.opt.iter), iter=self.opt.iter, beta=self.invProb.beta, phi_d=self.invProb.phi_d, phi_m=self.invProb.phi_m, phi_ms=phi_ms, phi_mx=phi_mx, phi_my=phi_my, phi_mz=phi_mz,f=self.opt.f, m=self.invProb.curModel,dpred=self.invProb.dpred)
-
-
-# class UpdateReferenceModel(Parameter):
-
-#     mref0 = None
-
-#     def nextIter(self):
 #         mref = getattr(self, 'm_prev', None)
 #         if mref is None:
 #             if self.debug: print 'UpdateReferenceModel is using mref0'
@@ -283,62 +250,203 @@ class SaveOutputDictEveryIteration(_SaveEveryIteration):
 #         self.m_prev = self.invProb.m_current
 #         return mref
 
-class update_IRLS(InversionDirective):
+class Update_IRLS(InversionDirective):
 
     eps_min = None
+    eps = 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
+    prctile = 95
+
+    # 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):
 
-        # Scale the regularization for changes in norm
-        if getattr(self, 'phi_m_last', None) is not None:
-            self.reg.gamma = 1.
-            phim_new = self.reg.eval(self.invProb.curModel)
-            self.gamma = self.phi_m_last / phim_new
+        if self.mode == 1:
+            self.reg.norms = [2., 2., 2., 2.]
 
-        self.reg.curModel = self.invProb.curModel
-        self.reg.gamma = self.gamma
-        
-        if getattr(self, 'phi_d_last', None) is None:
+    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
+
+            # Either use the supplied epsilon, or fix base on distribution of
+            # model values
+            if getattr(self, 'eps', None) is None:
+                self.reg.eps_p = np.percentile(np.abs(self.invProb.curModel),self.prctile)
+            else:
+                self.reg.eps_p = self.eps[0]
+
+            if getattr(self, 'eps', None) is None:
+                self.reg.eps_q = np.percentile(np.abs(self.reg.regmesh.cellDiffxStencil*(self.reg.mapping * self.invProb.curModel)),self.prctile)
+            else:
+                self.reg.eps_q = self.eps[1]
+
+            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
+
+            print "L[p qx qy qz]-norm : " + str(self.reg.norms)
+            print "eps_p: " + str(self.reg.eps_p) + " eps_q: " + str(self.reg.eps_q)
+
+            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 getattr(self, 'factor', None) is not None:
-            eps = self.reg.eps / self.factor
+        if self.onlyOnStart==True:
+            return
 
-            if getattr(self, 'eps_min', None) is not None:
-                self.reg.eps = np.max([self.eps_min,eps])
-            else:
-                self.reg.eps = eps
+        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
 
-        # Get phi_m at the end of current iteration
-        self.phi_m_last = self.invProb.phi_m_last
-        
-         # Update the model used for the IRLS weights
-        self.reg.curModel = self.invProb.curModel
 
-        # Update the pre-conditioner
-        diagA = np.sum(self.prob.G**2.,axis=0) + self.invProb.beta*(self.reg.W.T*self.reg.W).diagonal() * (self.reg.mapping * np.ones(self.reg.curModel.size))**2.
-        PC     = Utils.sdiag(diagA**-1.)
-        self.opt.approxHinv = PC
-         
-        # Temporarely set gamma to 1.
-        self.reg.gamma = 1.
-        
-        # Compute change in model objective function and update scaling
-        phim_new = self.reg.eval(self.invProb.curModel)
-        self.reg.gamma = self.phi_m_last / phim_new
-        
-        # TO DO: Re-scale beta if too much change in misfit
-        self.invProb.beta = self.invProb.beta * self.phi_d_last / self.invProb.phi_d
-        
-#==============================================================================
-#          import pylab as plt
-#          plt.figure()
-#          ax = plt.subplot(221)
-#          self.prob.mesh.plotSlice(self.invProb.curModel, ax = ax, normal = 'Z', ind=-5, clim = (0, 0.005))
-#==============================================================================
+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

SimPEG/EM/Analytics/DC.py

@@ -0,0 +1,118 @@
+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/FDEMDipolarfields.py

@@ -0,0 +1,302 @@
+from __future__ import division
+import numpy as np
+from scipy.constants import mu_0, pi, epsilon_0
+from scipy.special import erf
+from SimPEG import Utils
+
+omega = lambda f: 2.*np.pi*f
+# TODO:
+# r = lambda dx, dy, dz: np.sqrt( dx**2. + dy**2. + dz**2.)
+# k = lambda f, mu, epsilon, sig: np.sqrt( omega(f)**2. *mu*epsilon -1j*omega(f)*mu*sig )
+
+def E_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=0., epsr=1.):
+
+    """
+        Computing Analytic Electric fields from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+    mu = mu_0*(1+kappa)
+    epsilon = epsilon_0*epsr
+    sig_hat = sig + 1j*omega(f)*epsilon
+
+    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
+    # Check
+    if XYZ.shape[0] > 1 & f.shape[0] > 1:
+        raise Exception("I/O type error: For multiple field locations only a single frequency can be specified.")
+
+    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 )
+    k  = np.sqrt( omega(f)**2. *mu*epsilon -1j*omega(f)*mu*sig )
+
+    front = current * length / (4.*np.pi*sig_hat* r**3) * np.exp(-1j*k*r)
+    mid   = -k**2 * r**2 + 3*1j*k*r + 3
+
+    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
+
+
+def E_galvanic_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Galvanic portion of Electric fields from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+    mu = mu_0*(1+kappa)
+    epsilon = epsilon_0*epsr
+    sig_hat = sig + 1j*omega(f)*epsilon
+
+    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
+    # Check
+    if XYZ.shape[0] > 1 & f.shape[0] > 1:
+        raise Exception("I/O type error: For multiple field locations only a single frequency can be specified.")
+
+    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 )
+    k  = np.sqrt( omega(f)**2. *mu*epsilon -1j*omega(f)*mu*sig )
+
+    front = current * length / (4.*np.pi*sig_hat* r**3) * np.exp(-1j*k*r)
+    mid   = -k**2 * r**2 + 3*1j*k*r + 3
+
+    if orientation.upper() == 'X':
+        Ex_galvanic = front*((dx**2 / r**2)*mid + (-1j*k*r-1.))
+        Ey_galvanic = front*(dx*dy  / r**2)*mid
+        Ez_galvanic = front*(dx*dz  / r**2)*mid
+        return Ex_galvanic, Ey_galvanic, Ez_galvanic
+
+    elif orientation.upper() == 'Y':
+        #  x--> y, y--> z, z-->x
+        Ey_galvanic = front*((dy**2 / r**2)*mid + (-1j*k*r-1.))
+        Ez_galvanic = front*(dy*dz  / r**2)*mid
+        Ex_galvanic = front*(dy*dx  / r**2)*mid
+        return Ex_galvanic, Ey_galvanic, Ez_galvanic
+
+    elif orientation.upper() == 'Z':
+        # x --> z, y --> x, z --> y
+        Ez_galvanic = front*((dz**2 / r**2)*mid + (-1j*k*r-1.))
+        Ex_galvanic = front*(dz*dx  / r**2)*mid
+        Ey_galvanic = front*(dz*dy  / r**2)*mid
+        return Ex_galvanic, Ey_galvanic, Ez_galvanic
+
+
+def E_inductive_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Inductive portion of Electric fields from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+    mu = mu_0*(1+kappa)
+    epsilon = epsilon_0*epsr
+    sig_hat = sig + 1j*omega(f)*epsilon
+
+    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
+    # Check
+    if XYZ.shape[0] > 1 & f.shape[0] > 1:
+        raise Exception("I/O type error: For multiple field locations only a single frequency can be specified.")
+
+    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 )
+    k  = np.sqrt( omega(f)**2. *mu*epsilon -1j*omega(f)*mu*sig )
+
+    front = current * length / (4.*np.pi*sig_hat* r**3) * np.exp(-1j*k*r)
+
+    if orientation.upper() == 'X':
+        Ex_inductive = front*(k**2 * r**2)
+        Ey_inductive = np.zeros_like(Ex_inductive)
+        Ez_inductive = np.zeros_like(Ex_inductive)
+        return Ex_inductive, Ey_inductive, Ez_inductive
+
+    elif orientation.upper() == 'Y':
+        #  x--> y, y--> z, z-->x
+        Ey_inductive = front*(k**2 * r**2)
+        Ez_inductive = np.zeros_like(Ey_inductive)
+        Ex_inductive = np.zeros_like(Ey_inductive)
+        return Ex_inductive, Ey_inductive, Ez_inductive
+
+    elif orientation.upper() == 'Z':
+        # x --> z, y --> x, z --> y
+        Ez_inductive = front*(k**2 * r**2)
+        Ex_inductive = np.zeros_like(Ez_inductive)
+        Ey_inductive = np.zeros_like(Ez_inductive)
+        return Ex_inductive, Ey_inductive, Ez_inductive
+
+
+def J_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Current densities from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+
+    Ex, Ey, Ez = E_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=current, length=length, orientation=orientation, kappa=kappa, epsr=epsr)
+    Jx = sig*Ex
+    Jy = sig*Ey
+    Jz = sig*Ez
+    return Jx, Jy, Jz
+
+
+def J_galvanic_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Galvanic portion of Current densities from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+
+    Ex_galvanic, Ey_galvanic, Ez_galvanic = E_galvanic_from_ElectricDipoleWholeSpaced(XYZ, srcLoc, sig, f, current=current, length=length, orientation=orientation, kappa=kappa, epsr=epsr)
+    Jx_galvanic = sig*Ex_galvanic
+    Jy_galvanic = sig*Ey_galvanic
+    Jz_galvanic = sig*Ez_galvanic
+    return Jx_galvanic, Jy_galvanic, Jz_galvanic
+
+
+def J_inductive_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Inductive portion of Current densities from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+
+    Ex_inductive, Ey_inductive, Ez_inductive = E_inductive_from_ElectricDipoleWholeSpaced(XYZ, srcLoc, sig, f, current=current, length=length, orientation=orientation, kappa=kappa, epsr=epsr)
+    Jx_inductive = sig*Ex_inductive
+    Jy_inductive = sig*Ey_inductive
+    Jz_inductive = sig*Ez_inductive
+    return Jx_inductive, Jy_inductive, Jz_inductive
+
+
+def H_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Magnetic fields from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+    mu = mu_0*(1+kappa)
+    epsilon = epsilon_0*epsr
+    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
+    # Check
+    if XYZ.shape[0] > 1 & f.shape[0] > 1:
+        raise Exception("I/O type error: For multiple field locations only a single frequency can be specified.")
+
+    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 )
+    k  = np.sqrt( omega(f)**2. *mu*epsilon -1j*omega(f)*mu*sig )
+
+    front = current * length / (4.*np.pi* r**2) * (-1j*k*r + 1) * np.exp(-1j*k*r)
+
+    if orientation.upper() == 'X':
+        Hy = front*(-dz  / r)
+        Hz = front*(dy  / r)
+        Hx = np.zeros_like(Hy)
+        return Hx, Hy, Hz
+
+    elif orientation.upper() == 'Y':
+        Hx = front*(dz  / r)
+        Hz = front*(-dx  / r)
+        Hy = np.zeros_like(Hx)
+        return Hx, Hy, Hz
+
+    elif orientation.upper() == 'Z':
+        Hx = front*(-dy / r)
+        Hy = front*(dx  / r)
+        Hz = np.zeros_like(Hx)
+        return Hx, Hy, Hz
+
+
+def B_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Magnetic flux densites from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+
+    Hx, Hy, Hz = H_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=current, length=length, orientation=orientation, kappa=kappa, epsr=epsr)
+    Bx = mu*Hx
+    By = mu*Hy
+    Bz = mu*Hz
+    return Bx, By, Bz
+
+
+def A_from_ElectricDipoleWholeSpace(XYZ, srcLoc, sig, f, current=1., length=1., orientation='X', kappa=1., epsr=1.):
+
+    """
+        Computing Electric vector potentials from Electrical Dipole in a Wholespace
+        TODO:
+            Add description of parameters
+    """
+    mu = mu_0*(1+kappa)
+    epsilon = epsilon_0*epsr
+    XYZ = Utils.asArray_N_x_Dim(XYZ, 3)
+    # Check
+    if XYZ.shape[0] > 1 & f.shape[0] > 1:
+        raise Exception("I/O type error: For multiple field locations only a single frequency can be specified.")
+
+    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( omega(f)**2. *mu*epsilon -1j*omega(f)*mu*sig )
+
+    front = current * length / (4.*np.pi*r)
+
+    if orientation.upper() == 'X':
+        Ax = front*np.exp(-1j*k*r)
+        Ay = np.zeros_like(Ax)
+        Az = np.zeros_like(Ax)
+        return Ax, Ay, Az
+
+    elif orientation.upper() == 'Y':
+        Ay = front*np.exp(-1j*k*r)
+        Ax = np.zeros_like(Ay)
+        Az = np.zeros_like(Ay)
+        return Ax, Ay, Az
+
+    elif orientation.upper() == 'Z':
+        Az = front*np.exp(-1j*k*r)
+        Ax = np.zeros_like(Ay)
+        Ay = np.zeros_like(Ay)
+        return Ax, Ay, Az
+
+
+
+
+

SimPEG/EM/Analytics/__init__.py

@@ -1,3 +1,5 @@
 from TDEM import hzAnalyticDipoleT
 from FDEM import hzAnalyticDipoleF
 from FDEMcasing import *
+from DC import DCAnalyticHalf, DCAnalyticSphere
+from FDEMDipolarfields import *

SimPEG/EM/Base.py

@@ -1,6 +1,7 @@
 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)
@@ -19,10 +20,10 @@ class BaseEMProblem(Problem.BaseProblem):
         Problem.BaseProblem.__init__(self, mesh, **kwargs)
 
 
-    surveyPair = Survey.BaseSurvey
-    dataPair = Survey.Data
+    surveyPair = Survey.BaseSurvey #: The survey to pair with.
+    dataPair = Survey.Data #: The data to pair with.
 
-    PropMap = EMPropMap
+    PropMap = EMPropMap #: The property mapping
 
     Solver = SimpegSolver
     solverOpts = {}
@@ -61,6 +62,15 @@ class BaseEMProblem(Problem.BaseProblem):
             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):
         """
@@ -70,6 +80,20 @@ class BaseEMProblem(Problem.BaseProblem):
             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
@@ -127,7 +151,6 @@ class BaseEMProblem(Problem.BaseProblem):
         """
         return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u) * self.curModel.sigmaDeriv
 
-
     @property
     def MeSigmaI(self):
         """
@@ -146,10 +169,7 @@ class BaseEMProblem(Problem.BaseProblem):
 
         dMeSigmaI_dI = -self.MeSigmaI**2
         dMe_dsig = self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u)
-        dsig_dm = self.curModel.sigmaDeriv
-        return dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm))
-        # return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma, invMat=True)(u)
-
+        return dMeSigmaI_dI * ( dMe_dsig * self.curModel.sigmaDeriv )
 
     @property
     def MfRho(self):
@@ -165,8 +185,7 @@ class BaseEMProblem(Problem.BaseProblem):
         """
             Derivative of :code:`MfRho` with respect to the model.
         """
-        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u) * (-Utils.sdiag(self.curModel.rho**2) * self.curModel.sigmaDeriv)
-        # self.curModel.rhoDeriv
+        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u) * self.curModel.rhoDeriv
 
     @property
     def MfRhoI(self):
@@ -183,7 +202,10 @@ class BaseEMProblem(Problem.BaseProblem):
         """
             Derivative of :code:`MfRhoI` with respect to the model.
         """
-        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho, invMat=True)(u) * self.curModel.rhoDeriv
+
+        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):
 
@@ -192,9 +214,10 @@ class BaseEMSurvey(Survey.BaseSurvey):
         self.srcList = srcList
         Survey.BaseSurvey.__init__(self, **kwargs)
 
-    def eval(self, u):
+    def eval(self, f):
         """
         Project fields to receiver locations
+
         :param Fields u: fields object
         :rtype: numpy.ndarray
         :return: data
@@ -202,8 +225,8 @@ class BaseEMSurvey(Survey.BaseSurvey):
         data = Survey.Data(self)
         for src in self.srcList:
             for rx in src.rxList:
-                data[src, rx] = rx.eval(src, self.mesh, u)
+                data[src, rx] = rx.eval(src, self.mesh, f)
         return data
 
-    def evalDeriv(self, u):
+    def evalDeriv(self, f):
         raise Exception('Use Receivers to project fields deriv.')

SimPEG/EM/FDEM/FieldsFDEM.py

@@ -6,11 +6,11 @@ from SimPEG.EM.Utils import omega
 from SimPEG.Utils import Zero, Identity, sdiag
 
 
-class Fields(SimPEG.Problem.Fields):
+class FieldsFDEM(SimPEG.Problem.Fields):
     """
 
     Fancy Field Storage for a FDEM survey. Only one field type is stored for
-    each problem, the rest are computed. The fields obejct acts like an array and is indexed by
+    each problem, the rest are computed. The fields object acts like an array and is indexed by
 
     .. code-block:: python
 
@@ -92,7 +92,7 @@ class Fields(SimPEG.Problem.Fields):
         """
         Total derivative of e with respect to the inversion model. Returns :math:`d\mathbf{e}/d\mathbf{m}` for forward and (:math:`d\mathbf{e}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint
 
-        :param Src src: sorce
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: source
         :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint)
         :param numpy.ndarray v: vector to take sensitivity product with
         :param bool adjoint: adjoint?
@@ -110,7 +110,7 @@ class Fields(SimPEG.Problem.Fields):
         """
         Total derivative of b with respect to the inversion model. Returns :math:`d\mathbf{b}/d\mathbf{m}` for forward and (:math:`d\mathbf{b}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint
 
-        :param Src src: sorce
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: source
         :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint)
         :param numpy.ndarray v: vector to take sensitivity product with
         :param bool adjoint: adjoint?
@@ -128,7 +128,7 @@ class Fields(SimPEG.Problem.Fields):
         """
         Total derivative of h with respect to the inversion model. Returns :math:`d\mathbf{h}/d\mathbf{m}` for forward and (:math:`d\mathbf{h}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint
 
-        :param Src src: sorce
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: source
         :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint)
         :param numpy.ndarray v: vector to take sensitivity product with
         :param bool adjoint: adjoint?
@@ -146,7 +146,7 @@ class Fields(SimPEG.Problem.Fields):
         """
         Total derivative of j with respect to the inversion model. Returns :math:`d\mathbf{j}/d\mathbf{m}` for forward and (:math:`d\mathbf{j}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint
 
-        :param Src src: sorce
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: source
         :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint)
         :param numpy.ndarray v: vector to take sensitivity product with
         :param bool adjoint: adjoint?
@@ -160,12 +160,12 @@ class Fields(SimPEG.Problem.Fields):
             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 = complex)
 
-class Fields_e(Fields):
+class Fields3D_e(FieldsFDEM):
     """
-    Fields object for Problem_e.
+    Fields object for Problem3D_e.
 
-    :param Mesh mesh: mesh
-    :param Survey survey: survey
+    :param BaseMesh mesh: mesh
+    :param SimPEG.EM.FDEM.SurveyFDEM.Survey survey: survey
     """
 
     knownFields = {'eSolution':'E'}
@@ -180,9 +180,6 @@ class Fields_e(Fields):
                     'h' : ['eSolution','CCV','_h'],
                   }
 
-    def __init__(self, mesh, survey, **kwargs):
-        Fields.__init__(self,mesh,survey,**kwargs)
-
     def startup(self):
         self.prob = self.survey.prob
         self._edgeCurl = self.survey.prob.mesh.edgeCurl
@@ -426,12 +423,12 @@ class Fields_e(Fields):
 
 
 
-class Fields_b(Fields):
+class Fields3D_b(FieldsFDEM):
     """
-    Fields object for Problem_b.
+    Fields object for Problem3D_b.
 
-    :param Mesh mesh: mesh
-    :param Survey survey: survey
+    :param BaseMesh mesh: mesh
+    :param SimPEG.EM.FDEM.SurveyFDEM.Survey survey: survey
     """
 
     knownFields = {'bSolution':'F'}
@@ -446,9 +443,6 @@ class Fields_b(Fields):
                     'h' : ['bSolution','CCV','_h'],
                   }
 
-    def __init__(self,mesh,survey,**kwargs):
-        Fields.__init__(self,mesh,survey,**kwargs)
-
     def startup(self):
         self.prob = self.survey.prob
         self._edgeCurl = self.survey.prob.mesh.edgeCurl
@@ -693,12 +687,12 @@ class Fields_b(Fields):
         return Zero()
 
 
-class Fields_j(Fields):
+class Fields3D_j(FieldsFDEM):
     """
-    Fields object for Problem_j.
+    Fields object for Problem3D_j.
 
-    :param Mesh mesh: mesh
-    :param Survey survey: survey
+    :param BaseMesh mesh: mesh
+    :param SimPEG.EM.FDEM.SurveyFDEM.Survey survey: survey
     """
 
     knownFields = {'jSolution':'F'}
@@ -713,9 +707,6 @@ class Fields_j(Fields):
                     'b' : ['jSolution','CCV','_b'],
                   }
 
-    def __init__(self,mesh,survey,**kwargs):
-        Fields.__init__(self,mesh,survey,**kwargs)
-
     def startup(self):
         self.prob = self.survey.prob
         self._edgeCurl = self.survey.prob.mesh.edgeCurl
@@ -988,12 +979,12 @@ class Fields_j(Fields):
         return 1./(1j * omega(src.freq)) * VI * (self._aveE2CCV * ( s_mDeriv(v) - self._edgeCurl.T * ( self._MfRhoDeriv(jSolution) * v ) ) )
 
 
-class Fields_h(Fields):
+class Fields3D_h(FieldsFDEM):
     """
-    Fields object for Problem_h.
+    Fields object for Problem3D_h.
 
-    :param Mesh mesh: mesh
-    :param Survey survey: survey
+    :param BaseMesh mesh: mesh
+    :param SimPEG.EM.FDEM.SurveyFDEM.Survey survey: survey
     """
 
     knownFields = {'hSolution':'E'}
@@ -1008,9 +999,6 @@ class Fields_h(Fields):
                     'b' : ['hSolution','CCV','_b'],
                   }
 
-    def __init__(self,mesh,survey,**kwargs):
-        Fields.__init__(self,mesh,survey,**kwargs)
-
     def startup(self):
         self.prob = self.survey.prob
         self._edgeCurl = self.survey.prob.mesh.edgeCurl

SimPEG/EM/FDEM/ProblemFDEM.py

@@ -1,7 +1,7 @@
 from SimPEG import Problem, Utils, np, sp, Solver as SimpegSolver
 from scipy.constants import mu_0
 from SurveyFDEM import Survey as SurveyFDEM
-from FieldsFDEM import Fields, Fields_e, Fields_b, Fields_h, Fields_j
+from FieldsFDEM import FieldsFDEM, Fields3D_e, Fields3D_b, Fields3D_h, Fields3D_j
 from SimPEG.EM.Base import BaseEMProblem
 from SimPEG.EM.Utils import omega
 
@@ -17,8 +17,8 @@ class BaseFDEMProblem(BaseEMProblem):
             \mathbf{C} \mathbf{e} + i \omega \mathbf{b} = \mathbf{s_m} \\\\
             {\mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e} \mathbf{e} = \mathbf{s_e}}
 
-        if using the E-B formulation (:code:`Problem_e`
-        or :code:`Problem_b`). Note that in this case, :math:`\mathbf{s_e}` is an integrated quantity.
+        if 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}\\\)
@@ -28,13 +28,14 @@ class BaseFDEMProblem(BaseEMProblem):
             \mathbf{C}^{\\top} \mathbf{M_{\\rho}^f} \mathbf{j} + i \omega \mathbf{M_{\mu}^e} \mathbf{h} = \mathbf{s_m} \\\\
             \mathbf{C} \mathbf{h} - \mathbf{j} = \mathbf{s_e}
 
-        if using the H-J formulation (:code:`Problem_j` or :code:`Problem_h`). Note that here, :math:`\mathbf{s_m}` is an integrated quantity.
+        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
+    fieldsPair = FieldsFDEM
 
     def fields(self, m):
         """
@@ -64,7 +65,7 @@ class BaseFDEMProblem(BaseEMProblem):
 
         :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
+        :param SimPEG.EM.FDEM.FieldsFDEM.FieldsFDEM u: fields object
         :rtype numpy.array:
         :return: Jv (ndata,)
         """
@@ -87,7 +88,7 @@ class BaseFDEMProblem(BaseEMProblem):
                 du_dm_v = Ainv * ( - dA_dm_v + dRHS_dm_v )
 
                 for rx in src.rxList:
-                    df_dmFun = getattr(f, '_%sDeriv'%rx.projField, None)
+                    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()
@@ -99,7 +100,7 @@ class BaseFDEMProblem(BaseEMProblem):
 
         :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
+        :param SimPEG.EM.FDEM.FieldsFDEM.FieldsFDEM u: fields object
         :rtype numpy.array:
         :return: Jv (ndata,)
         """
@@ -125,7 +126,7 @@ class BaseFDEMProblem(BaseEMProblem):
                 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_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
@@ -137,10 +138,9 @@ class BaseFDEMProblem(BaseEMProblem):
                     df_dmT = df_dmT + du_dmT
 
                     # TODO: this should be taken care of by the reciever?
-                    real_or_imag = rx.projComp
-                    if real_or_imag is 'real':
+                    if rx.component is 'real':
                         Jtv +=   np.array(df_dmT, dtype=complex).real
-                    elif real_or_imag is 'imag':
+                    elif rx.component is 'imag':
                         Jtv += - np.array(df_dmT, dtype=complex).real
                     else:
                         raise Exception('Must be real or imag')
@@ -154,8 +154,8 @@ class BaseFDEMProblem(BaseEMProblem):
         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)
+        :rtype: tuple
+        :return: (s_m, s_e) (nE or nF, nSrc)
         """
         Srcs = self.survey.getSrcByFreq(freq)
         if self._formulation is 'EB':
@@ -167,6 +167,7 @@ class BaseFDEMProblem(BaseEMProblem):
 
         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
 
@@ -177,7 +178,7 @@ class BaseFDEMProblem(BaseEMProblem):
 ################################ E-B Formulation #########################################
 ##########################################################################################
 
-class Problem_e(BaseFDEMProblem):
+class Problem3D_e(BaseFDEMProblem):
     """
     By eliminating the magnetic flux density using
 
@@ -194,12 +195,12 @@ class Problem_e(BaseFDEMProblem):
 
     which we solve for :math:`\mathbf{e}`.
 
-    :param SimPEG.Mesh mesh: mesh
+    :param SimPEG.Mesh.BaseMesh.BaseMesh mesh: mesh
     """
 
     _solutionType = 'eSolution'
     _formulation  = 'EB'
-    fieldsPair    = Fields_e
+    fieldsPair    = Fields3D_e
 
     def __init__(self, mesh, **kwargs):
         BaseFDEMProblem.__init__(self, mesh, **kwargs)
@@ -269,7 +270,7 @@ class Problem_e(BaseFDEMProblem):
         Derivative of the right hand side with respect to the model
 
         :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: FDEM source
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
         :rtype: numpy.ndarray
@@ -288,7 +289,7 @@ class Problem_e(BaseFDEMProblem):
             return C.T * (MfMui * s_mDeriv(v)) -1j * omega(freq) * s_eDeriv(v)
 
 
-class Problem_b(BaseFDEMProblem):
+class Problem3D_b(BaseFDEMProblem):
     """
     We eliminate :math:`\mathbf{e}` using
 
@@ -305,12 +306,12 @@ class Problem_b(BaseFDEMProblem):
     .. note ::
         The inverse problem will not work with full anisotropy
 
-    :param SimPEG.Mesh mesh: mesh
+    :param SimPEG.Mesh.BaseMesh.BaseMesh mesh: mesh
     """
 
     _solutionType = 'bSolution'
     _formulation  = 'EB'
-    fieldsPair    = Fields_b
+    fieldsPair    = Fields3D_b
 
     def __init__(self, mesh, **kwargs):
         BaseFDEMProblem.__init__(self, mesh, **kwargs)
@@ -400,7 +401,7 @@ class Problem_b(BaseFDEMProblem):
         Derivative of the right hand side with respect to the model
 
         :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: FDEM source
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
         :rtype: numpy.ndarray
@@ -436,7 +437,7 @@ class Problem_b(BaseFDEMProblem):
 ##########################################################################################
 
 
-class Problem_j(BaseFDEMProblem):
+class Problem3D_j(BaseFDEMProblem):
     """
     We eliminate \\\(\\\mathbf{h}\\\) using
 
@@ -444,6 +445,7 @@ class Problem_j(BaseFDEMProblem):
 
         \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 ::
@@ -453,12 +455,12 @@ class Problem_j(BaseFDEMProblem):
     .. note::
         This implementation does not yet work with full anisotropy!!
 
-    :param SimPEG.Mesh mesh: mesh
+    :param SimPEG.Mesh.BaseMesh.BaseMesh mesh: mesh
     """
 
     _solutionType = 'jSolution'
     _formulation  = 'HJ'
-    fieldsPair    = Fields_j
+    fieldsPair    = Fields3D_j
 
     def __init__(self, mesh, **kwargs):
         BaseFDEMProblem.__init__(self, mesh, **kwargs)
@@ -529,8 +531,8 @@ class Problem_j(BaseFDEMProblem):
             \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
+        :rtype: numpy.ndarray
+        :return: RHS (nE, nSrc)
         """
 
         s_m, s_e = self.getSourceTerm(freq)
@@ -549,7 +551,7 @@ class Problem_j(BaseFDEMProblem):
         Derivative of the right hand side with respect to the model
 
         :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: FDEM source
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
         :rtype: numpy.ndarray
@@ -577,7 +579,7 @@ class Problem_j(BaseFDEMProblem):
 
 
 
-class Problem_h(BaseFDEMProblem):
+class Problem3D_h(BaseFDEMProblem):
     """
     We eliminate \\\(\\\mathbf{j}\\\) using
 
@@ -591,12 +593,12 @@ class Problem_h(BaseFDEMProblem):
 
         \\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
+    :param SimPEG.Mesh.BaseMesh.BaseMesh mesh: mesh
     """
 
     _solutionType = 'hSolution'
     _formulation  = 'HJ'
-    fieldsPair    = Fields_h
+    fieldsPair    = Fields3D_h
 
     def __init__(self, mesh, **kwargs):
         BaseFDEMProblem.__init__(self, mesh, **kwargs)
@@ -608,9 +610,11 @@ class Problem_h(BaseFDEMProblem):
         .. 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
@@ -653,6 +657,7 @@ class Problem_h(BaseFDEMProblem):
         :param float freq: Frequency
         :rtype: numpy.ndarray
         :return: RHS (nE, nSrc)
+
         """
 
         s_m, s_e = self.getSourceTerm(freq)
@@ -666,7 +671,7 @@ class Problem_h(BaseFDEMProblem):
         Derivative of the right hand side with respect to the model
 
         :param float freq: frequency
-        :param SimPEG.EM.FDEM.Src src: FDEM source
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: FDEM source
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
         :rtype: numpy.ndarray

SimPEG/EM/FDEM/RxFDEM.py

@@ -0,0 +1,126 @@
+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 receivers to get data.
+
+        :param SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: FDEM source
+        :param BaseMesh 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 SimPEG.EM.FDEM.SrcFDEM.BaseSrc src: FDEM source
+        :param BaseMesh 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

@@ -9,17 +9,22 @@ class BaseSrc(Survey.BaseSrc):
     """
 
     freq = None
-    # rxPair = RxFDEM
-    integrate = True
+    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):
         """
-        Evaluate the source terms.
         - :math:`s_m` : magnetic source term
         - :math:`s_e` : electric source term
 
-        :param Problem prob: FDEM Problem
-        :rtype: (numpy.ndarray, numpy.ndarray)
+        :param BaseFDEMProblem prob: FDEM Problem
+        :rtype: tuple
         :return: tuple with magnetic source term and electric source term
         """
         s_m = self.s_m(prob)
@@ -32,10 +37,10 @@ class BaseSrc(Survey.BaseSrc):
         - :code:`s_mDeriv` : derivative of the magnetic source term
         - :code:`s_eDeriv` : derivative of the electric source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
-        :rtype: (numpy.ndarray, numpy.ndarray)
+        :rtype: tuple
         :return: tuple with magnetic source term and electric source term derivatives times a vector
         """
         if v is not None:
@@ -47,47 +52,55 @@ class BaseSrc(Survey.BaseSrc):
         """
         Primary magnetic flux density
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: primary magnetic flux density
         """
-        return Zero()
+        if self._bPrimary is None:
+            return Zero()
+        return self._bPrimary
 
     def hPrimary(self, prob):
         """
         Primary magnetic field
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
-        return Zero()
+        if self._hPrimary is None:
+            return Zero()
+        return self._hPrimary
 
     def ePrimary(self, prob):
         """
         Primary electric field
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: primary electric field
         """
-        return Zero()
+        if self._ePrimary is None:
+            return Zero()
+        return self._ePrimary
 
     def jPrimary(self, prob):
         """
         Primary current density
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: primary current density
         """
-        return Zero()
+        if self._jPrimary is None:
+            return Zero()
+        return self._jPrimary
 
     def s_m(self, prob):
         """
         Magnetic source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: magnetic source term on mesh
         """
@@ -97,7 +110,7 @@ class BaseSrc(Survey.BaseSrc):
         """
         Electric source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: electric source term on mesh
         """
@@ -107,7 +120,7 @@ class BaseSrc(Survey.BaseSrc):
         """
         Derivative of magnetic source term with respect to the inversion model
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
         :rtype: numpy.ndarray
@@ -120,7 +133,7 @@ class BaseSrc(Survey.BaseSrc):
         """
         Derivative of electric source term with respect to the inversion model
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :param numpy.ndarray v: vector to take product with
         :param bool adjoint: adjoint?
         :rtype: numpy.ndarray
@@ -136,21 +149,20 @@ class RawVec_e(BaseSrc):
     :param list rxList: receiver list
     :param float freq: frequency
     :param numpy.array s_e: electric source term
-    :param bool integrate: Integrate the source term (multiply by Me) [True]
+    :param bool integrate: Integrate the source term (multiply by Me) [False]
     """
 
-    def __init__(self, rxList, freq, s_e, integrate=True): #, ePrimary=None, bPrimary=None, hPrimary=None, jPrimary=None):
+    def __init__(self, rxList, freq, s_e, **kwargs):
         self._s_e = np.array(s_e, dtype=complex)
         self.freq = float(freq)
-        self.integrate = integrate
 
-        BaseSrc.__init__(self, rxList)
+        BaseSrc.__init__(self, rxList, **kwargs)
 
     def s_e(self, prob):
         """
         Electric source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: electric source term on mesh
         """
@@ -166,21 +178,20 @@ class RawVec_m(BaseSrc):
     :param float freq: frequency
     :param rxList: receiver list
     :param numpy.array s_m: magnetic source term
-    :param bool integrate: Integrate the source term (multiply by Me) [True]
+    :param bool integrate: Integrate the source term (multiply by Me) [False]
     """
 
-    def __init__(self, rxList, freq, s_m, integrate=True):  #ePrimary=Zero(), bPrimary=Zero(), hPrimary=Zero(), jPrimary=Zero()):
+    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)
-        self.integrate = integrate
 
-        BaseSrc.__init__(self, rxList)
+        BaseSrc.__init__(self, rxList, **kwargs)
 
     def s_m(self, prob):
         """
         Magnetic source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: magnetic source term on mesh
         """
@@ -197,20 +208,19 @@ class RawVec(BaseSrc):
     :param float freq: frequency
     :param numpy.array s_m: magnetic source term
     :param numpy.array s_e: electric source term
-    :param bool integrate: Integrate the source term (multiply by Me) [True]
+    :param bool integrate: Integrate the source term (multiply by Me) [False]
     """
-    def __init__(self, rxList, freq, s_m, s_e, integrate=True):
+    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)
-        self.integrate = integrate
-        BaseSrc.__init__(self, rxList)
+        BaseSrc.__init__(self, rxList, **kwargs)
 
     def s_m(self, prob):
         """
         Magnetic source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: magnetic source term on mesh
         """
@@ -222,7 +232,7 @@ class RawVec(BaseSrc):
         """
         Electric source term
 
-        :param Problem prob: FDEM Problem
+        :param BaseFDEMProblem prob: FDEM Problem
         :rtype: numpy.ndarray
         :return: electric source term on mesh
         """
@@ -278,21 +288,20 @@ class MagDipole(BaseSrc):
     :param float mu: background magnetic permeability
     """
 
-    def __init__(self, rxList, freq, loc, orientation='Z', moment=1., mu=mu_0):
+    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
-        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
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -330,7 +339,7 @@ class MagDipole(BaseSrc):
         """
         The primary magnetic field from a magnetic vector potential
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -341,7 +350,7 @@ class MagDipole(BaseSrc):
         """
         The magnetic source term
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -355,7 +364,7 @@ class MagDipole(BaseSrc):
         """
         The electric source term
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -407,7 +416,7 @@ class MagDipole_Bfield(BaseSrc):
         """
         The primary magnetic flux density from the analytic solution for magnetic fields from a dipole
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -446,7 +455,7 @@ class MagDipole_Bfield(BaseSrc):
         """
         The primary magnetic field from a magnetic vector potential
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -457,7 +466,7 @@ class MagDipole_Bfield(BaseSrc):
         """
         The magnetic source term
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -470,7 +479,7 @@ class MagDipole_Bfield(BaseSrc):
         """
         The electric source term
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -521,7 +530,7 @@ class CircularLoop(BaseSrc):
         """
         The primary magnetic flux density from a magnetic vector potential
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -543,7 +552,7 @@ class CircularLoop(BaseSrc):
             if not prob.mesh.isSymmetric:
                 # TODO ?
                 raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            a = MagneticDipoleVectorPotential(self.loc, gridY, 'y', moment=self.radius, mu=self.mu)
+            a = MagneticLoopVectorPotential(self.loc, gridY, 'y', moment=self.radius, mu=self.mu)
 
         else:
             srcfct = MagneticDipoleVectorPotential
@@ -558,7 +567,7 @@ class CircularLoop(BaseSrc):
         """
         The primary magnetic field from a magnetic vector potential
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -569,7 +578,7 @@ class CircularLoop(BaseSrc):
         """
         The magnetic source term
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """
@@ -582,7 +591,7 @@ class CircularLoop(BaseSrc):
         """
         The electric source term
 
-        :param Problem prob: FDEM problem
+        :param BaseFDEMProblem prob: FDEM problem
         :rtype: numpy.ndarray
         :return: primary magnetic field
         """

SimPEG/EM/FDEM/SurveyFDEM.py

@@ -4,126 +4,9 @@ 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
 
-
-####################################################
-# Receivers
-####################################################
-
-class Rx(SimPEG.Survey.BaseRx):
-    """
-    Frequency domain receivers
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string rxType: reciever type from knownRxTypes
-    """
-
-    knownRxTypes = {
-                    'exr':['e', 'x', 'real'],
-                    'eyr':['e', 'y', 'real'],
-                    'ezr':['e', 'z', 'real'],
-                    'exi':['e', 'x', 'imag'],
-                    'eyi':['e', 'y', 'imag'],
-                    'ezi':['e', 'z', 'imag'],
-
-                    'bxr':['b', 'x', 'real'],
-                    'byr':['b', 'y', 'real'],
-                    'bzr':['b', 'z', 'real'],
-                    'bxi':['b', 'x', 'imag'],
-                    'byi':['b', 'y', 'imag'],
-                    'bzi':['b', 'z', 'imag'],
-
-                    'jxr':['j', 'x', 'real'],
-                    'jyr':['j', 'y', 'real'],
-                    'jzr':['j', 'z', 'real'],
-                    'jxi':['j', 'x', 'imag'],
-                    'jyi':['j', 'y', 'imag'],
-                    'jzi':['j', 'z', 'imag'],
-
-                    'hxr':['h', 'x', 'real'],
-                    'hyr':['h', 'y', 'real'],
-                    'hzr':['h', 'z', 'real'],
-                    'hxi':['h', 'x', 'imag'],
-                    'hyi':['h', 'y', 'imag'],
-                    'hzi':['h', 'z', 'imag'],
-                   }
-    radius = None
-
-    def __init__(self, locs, rxType):
-        SimPEG.Survey.BaseRx.__init__(self, locs, rxType)
-
-    @property
-    def projField(self):
-        """Field Type projection (e.g. e b ...)"""
-        return self.knownRxTypes[self.rxType][0]
-
-    @property
-    def projComp(self):
-        """Component projection (real/imag)"""
-        return self.knownRxTypes[self.rxType][2]
-
-    def projGLoc(self, u):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        return u._GLoc(self.rxType[0]) + self.knownRxTypes[self.rxType][1]
-
-    def eval(self, src, mesh, f):
-        """
-        Project fields to recievers to get data.
-
-        :param Source src: FDEM source
-        :param Mesh mesh: mesh used
-        :param Fields f: fields object
-        :rtype: numpy.ndarray
-        :return: fields projected to recievers
-        """
-        # projGLoc = u._GLoc(self.knownRxTypes[self.rxType][0])
-        # projGLoc += self.knownRxTypes[self.rxType][1]
-
-        P = self.getP(mesh, self.projGLoc(f))
-        f_part_complex = f[src, self.projField]
-        # get the real or imag component
-        real_or_imag = self.projComp
-        f_part = getattr(f_part_complex, real_or_imag)
-
-        return P*f_part
-
-    def evalDeriv(self, src, mesh, f, v, adjoint=False):
-        """
-        Derivative of projected fields with respect to the inversion model times a vector.
-
-        :param Source src: FDEM source
-        :param Mesh mesh: mesh used
-        :param Fields f: fields object
-        :param numpy.ndarray v: vector to multiply
-        :rtype: numpy.ndarray
-        :return: fields projected to recievers
-        """
-
-        P = self.getP(mesh, self.projGLoc(f))
-
-        if not adjoint:
-            Pv_complex = P * v
-            real_or_imag = self.projComp
-            Pv = getattr(Pv_complex, real_or_imag)
-        elif adjoint:
-            Pv_real = P.T * v
-
-            real_or_imag = self.projComp
-            if real_or_imag == 'imag':
-                Pv = 1j*Pv_real
-            elif real_or_imag == 'real':
-                Pv = Pv_real.astype(complex)
-            else:
-                raise NotImplementedError('must be real or imag')
-
-        return Pv
-
-
-####################################################
-# Survey
-####################################################
-
 class Survey(BaseEMSurvey):
     """
     Frequency domain electromagnetic survey
@@ -132,7 +15,7 @@ class Survey(BaseEMSurvey):
     """
 
     srcPair = Src.BaseSrc
-    rxPair = Rx
+    rxPair = Rx.BaseRx
 
     def __init__(self, srcList, **kwargs):
         # Sort these by frequency

SimPEG/EM/FDEM/__init__.py

@@ -1,3 +1,5 @@
-from SurveyFDEM import Rx, Src, Survey
-from FDEM import BaseFDEMProblem, Problem_e, Problem_b, Problem_j, Problem_h
-from FieldsFDEM import *
+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

@@ -0,0 +1,160 @@
+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

@@ -0,0 +1,148 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,296 @@
+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

@@ -0,0 +1,349 @@
+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

@@ -0,0 +1,129 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,372 @@
+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

@@ -0,0 +1,23 @@
+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

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

SimPEG/EM/Static/SIP/ProblemSIP.py

@@ -0,0 +1,445 @@
+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

@@ -0,0 +1,204 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,317 @@
+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

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

SimPEG/EM/Static/__init__.py

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

SimPEG/EM/TDEM/BaseTDEM.py

@@ -112,7 +112,7 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem):
         """
             :param numpy.array m: Conductivity model
             :param numpy.ndarray v: vector (model object)
-            :param simpegEM.TDEM.FieldsTDEM f: Fields resulting from m
+            :param FieldsTDEM f: Fields resulting from m
             :rtype: numpy.ndarray
             :return: w (data object)
 
@@ -136,8 +136,8 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem):
     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
+            :param numpy.ndarray v: vector (or a :class:`SimPEG.Survey.Data` object)
+            :param FieldsTDEM u: Fields resulting from m
             :rtype: numpy.ndarray
             :return: w (model object)
 

SimPEG/EM/TDEM/SurveyTDEM.py

@@ -87,7 +87,7 @@ class SrcTDEM_VMD_MVP(SrcTDEM):
     def getInitialFields(self, mesh):
         """Vertical magnetic dipole, magnetic vector potential"""
         if self.waveformType == "STEPOFF":
-            print ">> Step waveform: Non-zero initial condition"        
+            print ">> Step waveform: Non-zero initial condition"
             if mesh._meshType is 'CYL':
                 if mesh.isSymmetric:
                     MVP = MagneticDipoleVectorPotential(self.loc, mesh, 'Ey')
@@ -96,8 +96,8 @@ class SrcTDEM_VMD_MVP(SrcTDEM):
             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}               
+                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)}
@@ -113,7 +113,7 @@ class SrcTDEM_VMD_MVP(SrcTDEM):
         elif mesh._meshType is 'TENSOR':
             MVP = MagneticDipoleVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'])
         else:
-            raise Exception('Unknown mesh for VMD')            
+            raise Exception('Unknown mesh for VMD')
         return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP
 
 
@@ -122,7 +122,7 @@ class SrcTDEM_CircularLoop_MVP(SrcTDEM):
         self.loc = loc
         self.radius = radius
         self.waveformType = waveformType
-        SrcTDEM.__init__(self,rxList)        
+        SrcTDEM.__init__(self,rxList)
 
     def getInitialFields(self, mesh):
         """Circular Loop, magnetic vector potential"""
@@ -153,7 +153,7 @@ class SrcTDEM_CircularLoop_MVP(SrcTDEM):
         elif mesh._meshType is 'TENSOR':
             MVP = MagneticLoopVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'], self.radius)
         else:
-            raise Exception('Unknown mesh for CircularLoop')            
+            raise Exception('Unknown mesh for CircularLoop')
         return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP
 
 

SimPEG/EM/TDEM/TDEM_b.py

@@ -87,8 +87,8 @@ class ProblemTDEM_b(BaseTDEMProblem):
         """
             :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
+            :param FieldsTDEM u: Fields resulting from m
+            :rtype: FieldsTDEM
             :return: f
 
             Multiply G by a vector
@@ -125,9 +125,9 @@ class ProblemTDEM_b(BaseTDEMProblem):
         """
             :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
+            :param FieldsTDEM u: Fields resulting from m
+            :rtype: numpy.ndarray
+            :return: p (like a model)
 
             Multiply G.T by a vector
         """
@@ -153,8 +153,8 @@ class ProblemTDEM_b(BaseTDEMProblem):
     def solveAh(self, m, p):
         """
             :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM p: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
+            :param FieldsTDEM p: Fields object
+            :rtype: FieldsTDEM
             :return: y
 
             Solve the block-matrix system \\\(\\\hat{A} \\\hat{y} = \\\hat{p}\\\):
@@ -200,8 +200,8 @@ class ProblemTDEM_b(BaseTDEMProblem):
     def solveAht(self, m, p):
         """
             :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM p: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
+            :param FieldsTDEM p: Fields object
+            :rtype: FieldsTDEM
             :return: y
 
             Solve the block-matrix system \\\(\\\hat{A}^\\\\top \\\hat{y} = \\\hat{p}\\\):
@@ -270,8 +270,8 @@ class ProblemTDEM_b(BaseTDEMProblem):
     def _AhVec(self, m, vec):
         """
             :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM vec: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
+            :param FieldsTDEM vec: Fields object
+            :rtype: FieldsTDEM
             :return: f
 
             Multiply the matrix \\\(\\\hat{A}\\\) by a fields vector where
@@ -315,8 +315,8 @@ class ProblemTDEM_b(BaseTDEMProblem):
     def _AhtVec(self, m, vec):
         """
             :param numpy.array m: Conductivity model
-            :param simpegEM.TDEM.FieldsTDEM vec: Fields object
-            :rtype: simpegEM.TDEM.FieldsTDEM
+            :param FieldsTDEM vec: Fields object
+            :rtype: FieldsTDEM
             :return: f
 
             Multiply the matrix \\\(\\\hat{A}\\\) by a fields vector where

SimPEG/EM/Utils/testingUtils.py

@@ -20,56 +20,61 @@ def getFDEMProblem(fdemType, comp, SrcList, freq, useMu=False, verbose=False):
     mesh = Mesh.TensorMesh([hx,hy,hz],['C','C','C'])
 
     if useMu is True:
-        mapping = [('sigma', Maps.ExpMap(mesh)), ('mu', Maps.IdentityMap(mesh))] 
+        mapping = [('sigma', Maps.ExpMap(mesh)), ('mu', Maps.IdentityMap(mesh))]
     else:
         mapping = Maps.ExpMap(mesh)
 
     x = np.array([np.linspace(-5.*cs,-2.*cs,3),np.linspace(5.*cs,2.*cs,3)]) + cs/4. #don't sample right by the source, slightly off alignment from either staggered grid
     XYZ = Utils.ndgrid(x,x,np.linspace(-2.*cs,2.*cs,5))
-    Rx0 = EM.FDEM.Rx(XYZ, comp)
+    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.]))
+            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.]))
+            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.]))
+            Src.append(EM.FDEM.Src.CircularLoop([rx0], freq=freq, loc=np.r_[0.,0.,0.]))
         elif SrcType is 'RawVec':
             if fdemType is 'e' or fdemType is 'b':
                 S_m = np.zeros(mesh.nF)
                 S_e = np.zeros(mesh.nE)
                 S_m[Utils.closestPoints(mesh,[0.,0.,0.],'Fz') + np.sum(mesh.vnF[:1])] = 1e-3
                 S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Ez') + np.sum(mesh.vnE[:1])] = 1e-3
-                Src.append(EM.FDEM.Src.RawVec([Rx0], freq, S_m, S_e))
+                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, S_m, S_e))
+                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.Problem_e(mesh, mapping=mapping)
+        prb = EM.FDEM.Problem3D_e(mesh, mapping=mapping)
 
     elif fdemType == 'b':
         survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_b(mesh, mapping=mapping)
+        prb = EM.FDEM.Problem3D_b(mesh, mapping=mapping)
 
     elif fdemType == 'j':
         survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_j(mesh, mapping=mapping)
+        prb = EM.FDEM.Problem3D_j(mesh, mapping=mapping)
 
     elif fdemType == 'h':
         survey = EM.FDEM.Survey(Src)
-        prb = EM.FDEM.Problem_h(mesh, mapping=mapping)
+        prb = EM.FDEM.Problem3D_h(mesh, mapping=mapping)
 
     else:
         raise NotImplementedError()
@@ -90,7 +95,7 @@ def crossCheckTest(SrcList, fdemType1, fdemType2, comp, addrandoms = False, useM
     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
 

SimPEG/EM/__init__.py

@@ -1,5 +1,6 @@
 import TDEM
 import FDEM
+import Static
 import Base
 import Analytics
 import Utils

SimPEG/Examples/DC_Analytic_Dipole.py

@@ -1,7 +1,7 @@
 from SimPEG import *
-import SimPEG.DCIP as DC
+import SimPEG.EM.Static.DC as DC
 
-def run(plotIt=False):
+def run(plotIt=True):
     cs = 25.
     hx = [(cs,7, -1.3),(cs,21),(cs,7, 1.3)]
     hy = [(cs,7, -1.3),(cs,21),(cs,7, 1.3)]
@@ -21,10 +21,10 @@ def run(plotIt=False):
     #     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)
+    rx = DC.Rx.Dipole(xyz_rxP, xyz_rxN)
+    src = DC.Src.Dipole([rx], np.r_[-200, 0, -12.5], np.r_[+200, 0, -12.5])
+    survey = DC.Survey([src])
+    problem = DC.Problem3D_CC(mesh)
     problem.pair(survey)
     try:
         from pymatsolver import MumpsSolver
@@ -65,4 +65,4 @@ def run(plotIt=False):
 
 
 if __name__ == '__main__':
-    print run(plotIt=True)
+    print run()

SimPEG/Examples/DC_Forward_PseudoSection.py

@@ -2,27 +2,27 @@ from SimPEG import Mesh, Utils, np, sp
 import SimPEG.DCIP as DC
 import time
 
-def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', dtype='appc', plotIt=True):
+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 
+        Forward model two conductive spheres in a half-space and plot a
         pseudo-section. Assumes an infinite line source and measures along the
         center of the spheres.
-        
+
         INPUT:
         loc     = Location of spheres [[x1,y1,z1],[x2,y2,z2]]
         radi    = Radius of spheres [r1,r2]
         param   = Conductivity of background and two spheres [m0,m1,m2]
-        stype   = survey type "pdp" (pole dipole) or "dpdp" (dipole dipole)
-        dtype   = Data type "appr" (app res) | "appc" (app cond) | "volt" (potential)
-        Created by @fourndo on Mon Feb 01 19:28:06 2016
+        surveyType = survey type 'pole-dipole' or 'dipole-dipole'
+        unitType = Data type "appResistivity" | "appConductivity"  | "volt"
+        Created by @fourndo
 
     """
 
-    assert stype in ['pdp', 'dpdp'], "Source type (stype) must be pdp or dpdp (pole dipole or dipole dipole)"
-    assert dtype in ['appr', 'appc', 'volt'], "Data type (dtype) must be appr (app res) or appc (app cond) or volt (potential)"
+    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.]]
@@ -73,8 +73,8 @@ def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', dtype='appc', p
     locs = np.c_[mesh.gridCC[indx,0],mesh.gridCC[indx,1],np.ones(2).T*mesh.vectorNz[-1]]
 
     # We will handle the geometry of the survey for you and create all the combination of tx-rx along line
-    # [Tx, Rx] = DC.gen_DCIPsurvey(locs, mesh, stype, param[0], param[1], param[2])
-    survey, Tx, Rx = DC.gen_DCIPsurvey(locs, mesh, stype, param[0], param[1], param[2])
+    # [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) )
@@ -118,8 +118,8 @@ def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', dtype='appc', p
         rxloc_N = np.asarray(Rx[ii][:,3:])
 
 
-        # For usual cases "dpdp" or "gradient"
-        if stype == 'pdp':
+        # 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
@@ -157,12 +157,12 @@ def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', dtype='appc', p
         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)
+        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',
+        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')
@@ -188,15 +188,13 @@ def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', dtype='appc', p
         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)
+        circle1=plt.Circle((loc[0,0], loc[2,0]), radi[0], color='w', fill=False, lw=3)
+        circle2=plt.Circle((loc[0,1], loc[2,1]), radi[1], color='k', fill=False, lw=3)
         ax2.add_artist(circle1)
         ax2.add_artist(circle2)
 
         # Add the speudo section
-        dat = DC.plot_pseudoSection(survey2D,ax2,stype=stype, dtype = dtype)
-
-        # plt.scatter(Tx2d[0][:],Tx[0][2,:],s=40,c='g', marker='v')
+        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')

SimPEG/Examples/EM_FDEM_1D_Inversion.py

@@ -42,8 +42,8 @@ def run(plotIt=True):
         ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
 
 
-    rxOffset=10. 
-    bzi = EM.FDEM.Rx(np.array([[rxOffset, 0., 1e-3]]), 'bzi')
+    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.])
@@ -51,7 +51,7 @@ def run(plotIt=True):
     srcList = [EM.FDEM.Src.MagDipole([bzi],freq, srcLoc,orientation='Z') for freq in freqs]
 
     survey = EM.FDEM.Survey(srcList)
-    prb = EM.FDEM.Problem_b(mesh, mapping=mapping)
+    prb = EM.FDEM.Problem3D_b(mesh, mapping=mapping)
 
     try:
         from pymatsolver import MumpsSolver

SimPEG/Examples/EM_Schenkel_Morrison_Casing.py

@@ -19,10 +19,13 @@ def run(plotIt=True):
         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.
+        .. code-block:: text
+
+            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
@@ -215,7 +218,7 @@ def run(plotIt=True):
     # ------------ Problem and Survey ---------------
     survey = FDEM.Survey(sg_p + dg_p)
     mapping = [('sigma', Maps.IdentityMap(mesh))]
-    problem = FDEM.Problem_h(mesh, mapping=mapping)
+    problem = FDEM.Problem3D_h(mesh, mapping=mapping, Solver=solver)
     problem.pair(survey)
 
     # ------------- Solve ---------------------------

SimPEG/Examples/Inversion_IRLS.py

@@ -0,0 +1,102 @@
+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)
+
+    wd = np.ones(nk) * std_noise
+
+    # Distance weighting
+    wr = np.sum(prob.G**2.,axis=0)**0.5
+    wr = ( wr/np.max(wr) )
+
+    dmis = DataMisfit.l2_DataMisfit(survey)
+    dmis.Wd = 1./wd
+
+    betaest = Directives.BetaEstimate_ByEig()
+
+    reg = Regularization.Sparse(mesh)
+    reg.mref = mref
+    reg.cell_weights = wr
+
+    reg.mref = np.zeros(mesh.nC)
+    
+
+    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()
+    
+    # Set the IRLS directive, penalize the lowest 25 percentile of model values
+    # Start with an l2-l2, then switch to lp-norms
+    norms   = [0., 0., 2., 2.]    
+    IRLS = Directives.Update_IRLS( norms=norms, prctile = 25, maxIRLSiter = 15, minGNiter=3)
+
+    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/MT_1D_ForwardAndInversion.py

@@ -7,7 +7,7 @@ import matplotlib.pyplot as plt
 def run(plotIt=True):
     """
         MT: 1D: Inversion
-        =======================
+        =================
 
         Forward model 1D MT data.
         Setup and run a MT 1D inversion.
@@ -50,7 +50,7 @@ def run(plotIt=True):
     m_0 = np.log(sigma_0[active])
 
     # Set the mapping
-    actMap = simpeg.Maps.ActiveCells(m1d, active, np.log(1e-8), nC=m1d.nCx)
+    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
@@ -76,7 +76,7 @@ def run(plotIt=True):
     survey.dobs = survey.dtrue + 0.025*abs(survey.dtrue)*np.random.randn(*survey.dtrue.shape)
 
     if plotIt:
-        fig = MT.Utils.dataUtils.plotMT1DModelData(problem)
+        fig = MT.Utils.dataUtils.plotMT1DModelData(problem, [m_0])
         fig.suptitle('Target - smooth true')
 
 

SimPEG/Examples/MT_3D_Foward.py

@@ -12,7 +12,7 @@ except:
 def run(plotIt=True, nFreq=1):
     """
         MT: 3D: Forward
-        =======================
+        ===============
 
         Forward model 3D MT data.
 
@@ -46,16 +46,15 @@ def run(plotIt=True, nFreq=1):
     survey = MT.Survey(srcList)
 
     ## Setup the problem object
-    problem = MT.Problem3D.eForm_ps(M, sigmaPrimary=sigBG)
+    problem = MT.Problem3D.eForm_ps(M, sigmaPrimary=sigBG, Solver=Solver)
     problem.pair(survey)
-    problem.Solver = Solver
 
     # Calculate the data
     fields = problem.fields(sig)
     dataVec = survey.eval(fields)
 
     # Make the data
-    mtData = MT.Data(survey,dataVec)
+    mtData = MT.Data(survey, dataVec)
     # Add plots
     if plotIt:
         pass

SimPEG/Examples/Maps_ComboMaps.py

@@ -0,0 +1,62 @@
+from SimPEG import Mesh, Maps, np
+
+def run(plotIt=True):
+    """
+
+        Maps: ComboMaps
+        ===============
+
+        We will use an example where we want a 1D layered earth as
+        our model, but we want to map this to a 2D discretization to do our forward
+        modeling. We will also assume that we are working in log conductivity still,
+        so after the transformation we want to map to conductivity space.
+        To do this we will introduce the vertical 1D map (:class:`SimPEG.Maps.SurjectVertical1D`),
+        which does the first part of what we just described. The second part will be
+        done by the :class:`SimPEG.Maps.ExpMap` described above.
+
+        .. code-block:: python
+            :linenos:
+
+            M = Mesh.TensorMesh([7,5])
+            v1dMap = Maps.SurjectVertical1D(M)
+            expMap = Maps.ExpMap(M)
+            myMap = expMap * v1dMap
+            m = np.r_[0.2,1,0.1,2,2.9] # only 5 model parameters!
+            sig = myMap * m
+
+        If you noticed, it was pretty easy to combine maps. What is even cooler is
+        that the derivatives also are made for you (if everything goes right).
+        Just to be sure that the derivative is correct, you should always run the test
+        on the mapping that you create.
+
+    """
+
+
+    M = Mesh.TensorMesh([7,5])
+    v1dMap = Maps.SurjectVertical1D(M)
+    expMap = Maps.ExpMap(M)
+    myMap = expMap * v1dMap
+    m = np.r_[0.2,1,0.1,2,2.9] # only 5 model parameters!
+    sig = myMap * m
+
+    if not plotIt: return
+
+    import matplotlib.pyplot as plt
+    figs, axs = plt.subplots(1,2)
+    axs[0].plot(m, M.vectorCCy, 'b-o')
+    axs[0].set_title('Model')
+    axs[0].set_ylabel('Depth, y')
+    axs[0].set_xlabel('Value, $m_i$')
+    axs[0].set_xlim(0,3)
+    axs[0].set_ylim(0,1)
+    clbar = plt.colorbar(M.plotImage(sig,ax=axs[1],grid=True,gridOpts=dict(color='grey'))[0])
+    axs[1].set_title('Physical Property')
+    axs[1].set_ylabel('Depth, y')
+    clbar.set_label('$\sigma = \exp(\mathbf{P}m)$')
+    plt.tight_layout()
+    plt.show()
+
+
+if __name__ == '__main__':
+    run()
+

SimPEG/Examples/Maps_Mesh2Mesh.py

@@ -0,0 +1,41 @@
+from SimPEG import Mesh, Maps, Utils
+
+def run(plotIt=True):
+    """
+
+        Maps: Mesh2Mesh
+        ===============
+
+        This mapping allows you to go from one mesh to another.
+
+    """
+
+    M = Mesh.TensorMesh([100,100])
+    h1 = Utils.meshTensor([(6,7,-1.5),(6,10),(6,7,1.5)])
+    h1 = h1/h1.sum()
+    M2 = Mesh.TensorMesh([h1,h1])
+    V = Utils.ModelBuilder.randomModel(M.vnC, seed=79, its=50)
+    v = Utils.mkvc(V)
+    modh = Maps.Mesh2Mesh([M,M2])
+    modH = Maps.Mesh2Mesh([M2,M])
+    H = modH * v
+    h = modh * H
+
+    if not plotIt: return
+
+    import matplotlib.pyplot as plt
+    ax = plt.subplot(131)
+    M.plotImage(v, ax=ax)
+    ax.set_title('Fine Mesh (Original)')
+    ax = plt.subplot(132)
+    M2.plotImage(H,clim=[0,1],ax=ax)
+    ax.set_title('Course Mesh')
+    ax = plt.subplot(133)
+    M.plotImage(h,clim=[0,1],ax=ax)
+    ax.set_title('Fine Mesh (Interpolated)')
+    plt.show()
+
+
+if __name__ == '__main__':
+    run()
+

SimPEG/Examples/Mesh_Basic_ForwardDC.py

@@ -1,22 +1,25 @@
 from SimPEG import Mesh, Utils, np, SolverLU
 
-## 2D DC forward modeling example with Tensor and Curvilinear Meshes
-
 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]
-    # 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
+        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)
@@ -37,39 +40,17 @@ def run(plotIt=True):
     if not plotIt: return
 
     import matplotlib.pyplot as plt
-    import matplotlib
-    from matplotlib.mlab import griddata
 
     #Step4: Making Figure
     fig, axes = plt.subplots(1,2,figsize=(12*1.2,4*1.2))
-    label = ["(a)", "(b)"]
-    opts = {}
     vmin, vmax = phitM.min(), phitM.max()
     dat = tM.plotImage(phitM, ax=axes[0], clim=(vmin, vmax), grid=True)
-
-    #TODO: At the moment Curvilinear Mesh do not have plotimage
-
-    Xi = tM.gridCC[:,0].reshape(sz[0], sz[1], order='F')
-    Yi = tM.gridCC[:,1].reshape(sz[0], sz[1], order='F')
-    PHIrM = griddata(rM.gridCC[:,0], rM.gridCC[:,1], phirM, Xi, Yi, interp='linear')
-    axes[1].contourf(Xi, Yi, PHIrM, 100, vmin=vmin, vmax=vmax)
-
+    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)")
 
-    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/Mesh_Basic_Types.py

@@ -1,4 +1,5 @@
-from SimPEG import *
+from SimPEG import Mesh, Utils, np
+
 
 def run(plotIt=True):
     """
@@ -8,15 +9,15 @@ def run(plotIt=True):
         Here we show SimPEG used to create three different types of meshes.
 
     """
-    sz = [16,16]
+    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'))
+    rM = Mesh.CurvilinearMesh(Utils.meshutils.exampleLrmGrid(sz, 'rotate'))
 
     if plotIt:
         import matplotlib.pyplot as plt
-        fig, axes = plt.subplots(1,3,figsize=(14,5))
+        fig, axes = plt.subplots(1, 3, figsize=(14, 5))
         opts = {}
         tM.plotGrid(ax=axes[0], **opts)
         axes[0].set_title('TensorMesh')

SimPEG/Examples/PF_Magnetics_Analytics.py

@@ -0,0 +1,65 @@
+from SimPEG import Mesh, np, PF
+
+
+def run(plotIt=True):
+    """
+        PF: Magnetics: Analytics
+        ========================
+
+        Comparing the magnetics field in Vancouver to Seoul
+
+    """
+
+    xr = np.linspace(-300, 300, 41)
+    yr = np.linspace(-300, 300, 41)
+    X, Y = np.meshgrid(xr, yr)
+    Z = np.ones((np.size(xr), np.size(yr)))*150
+
+    # Bz component in Korea
+    inckr = -8. + 3./60
+    deckr = 54. + 9./60
+    btotkr = 50898.6
+    Bokr = PF.MagAnalytics.IDTtoxyz(inckr, deckr, btotkr)
+
+    bx, by, bz = PF.MagAnalytics.MagSphereAnaFunA(
+        X, Y, Z, 100., 0., 0., 0., 0.01, Bokr, 'secondary'
+    )
+    Bzkr = np.reshape(bz, (np.size(xr), np.size(yr)), order='F')
+
+    # Bz component in Canada
+    incca = 16. + 49./60
+    decca = 70. + 19./60
+    btotca = 54692.1
+    Boca = PF.MagAnalytics.IDTtoxyz(incca, decca, btotca)
+
+    bx, by, bz = PF.MagAnalytics.MagSphereAnaFunA(
+        X, Y, Z, 100., 0., 0., 0., 0.01, Boca, 'secondary'
+    )
+    Bzca = np.reshape(bz, (np.size(xr), np.size(yr)), order='F')
+
+    if plotIt:
+        import matplotlib.pyplot as plt
+        from mpl_toolkits.axes_grid1 import make_axes_locatable
+        fig = plt.figure(figsize=(14, 5))
+
+        ax1 = plt.subplot(121)
+        dat1 = plt.imshow(Bzkr, extent=[min(xr), max(xr), min(yr), max(yr)])
+        divider = make_axes_locatable(ax1)
+        cax1 = divider.append_axes("right", size="5%", pad=0.05)
+        ax1.set_xlabel('East-West (m)')
+        ax1.set_ylabel('South-North (m)')
+        plt.colorbar(dat1, cax=cax1)
+        ax1.set_title('$B_z$ field at Seoul, South Korea')
+
+        ax2 = plt.subplot(122)
+        dat2 = plt.imshow(Bzca, extent=[min(xr), max(xr), min(yr), max(yr)])
+        divider = make_axes_locatable(ax2)
+        cax2 = divider.append_axes("right", size="5%", pad=0.05)
+        ax2.set_xlabel('East-West (m)')
+        ax2.set_ylabel('South-North (m)')
+        plt.colorbar(dat2, cax=cax2)
+        ax2.set_title('$B_z$ field at Vancouver, Canada')
+        plt.show()
+
+if __name__ == '__main__':
+    run()

SimPEG/Examples/Utils_surface2ind_topo.py

@@ -0,0 +1,43 @@
+from SimPEG import *
+from SimPEG.Utils import surface2ind_topo
+
+
+def run(plotIt=True, nx=5, ny=5):
+    """
+
+        Utils: surface2ind_topo
+        =======================
+
+        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.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

@@ -8,8 +8,11 @@ import EM_FDEM_Analytic_MagDipoleWholespace
 import EM_Schenkel_Morrison_Casing
 import EM_TDEM_1D_Inversion
 import FLOW_Richards_1D_Celia1990
-import Forward_BasicDirectCurrent
+import Inversion_IRLS
 import Inversion_Linear
+import Maps_ComboMaps
+import Maps_Mesh2Mesh
+import Mesh_Basic_ForwardDC
 import Mesh_Basic_PlotImage
 import Mesh_Basic_Types
 import Mesh_Operators_CahnHilliard
@@ -19,8 +22,9 @@ import Mesh_QuadTree_HangingNodes
 import Mesh_Tensor_Creation
 import MT_1D_ForwardAndInversion
 import MT_3D_Foward
+import Utils_surface2ind_topo
 
-__examples__ = ["DC_Analytic_Dipole", "DC_Forward_PseudoSection", "EM_FDEM_1D_Inversion", "EM_FDEM_Analytic_MagDipoleWholespace", "EM_Schenkel_Morrison_Casing", "EM_TDEM_1D_Inversion", "FLOW_Richards_1D_Celia1990", "Forward_BasicDirectCurrent", "Inversion_Linear", "Mesh_Basic_PlotImage", "Mesh_Basic_Types", "Mesh_Operators_CahnHilliard", "Mesh_QuadTree_Creation", "Mesh_QuadTree_FaceDiv", "Mesh_QuadTree_HangingNodes", "Mesh_Tensor_Creation", "MT_1D_ForwardAndInversion", "MT_3D_Foward"]
+__examples__ = ["DC_Analytic_Dipole", "DC_Forward_PseudoSection", "EM_FDEM_1D_Inversion", "EM_FDEM_Analytic_MagDipoleWholespace", "EM_Schenkel_Morrison_Casing", "EM_TDEM_1D_Inversion", "FLOW_Richards_1D_Celia1990", "Inversion_IRLS", "Inversion_Linear", "Maps_ComboMaps", "Maps_Mesh2Mesh", "Mesh_Basic_ForwardDC", "Mesh_Basic_PlotImage", "Mesh_Basic_Types", "Mesh_Operators_CahnHilliard", "Mesh_QuadTree_Creation", "Mesh_QuadTree_FaceDiv", "Mesh_QuadTree_HangingNodes", "Mesh_Tensor_Creation", "MT_1D_ForwardAndInversion", "MT_3D_Foward", "Utils_surface2ind_topo"]
 
 ##### AUTOIMPORTS #####
 
@@ -36,7 +40,7 @@ if __name__ == '__main__':
 
     # 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'])
+    docExamplesDir = os.path.sep.join(fName.split(os.path.sep)[:-3] + ['docs', 'content', 'examples'])
     shutil.rmtree(docExamplesDir)
     os.makedirs(docExamplesDir)
 
@@ -93,12 +97,12 @@ if __name__ == '__main__':
     from SimPEG import Examples
     Examples.%s.run()
 
-.. literalinclude:: ../../SimPEG/Examples/%s.py
+.. 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']))
+        rst = os.path.sep.join((filePath.split(os.path.sep)[:-3] + ['docs', 'content', 'examples', name + '.rst']))
 
         print 'Creating: %s.rst'%name
         f = open(rst, 'w')

SimPEG/FLOW/Richards/Empirical.py

@@ -31,7 +31,7 @@ class NonLinearMap(object):
         """
             :param numpy.array u: fields
             :param numpy.array m: model
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: derivative of transformed model
 
             The *transform* changes the model into the physical property.
@@ -44,7 +44,7 @@ class NonLinearMap(object):
         """
             :param numpy.array u: fields
             :param numpy.array m: model
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: derivative of transformed model
 
             The *transform* changes the model into the physical property.

SimPEG/Inversion.py

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

SimPEG/MT/BaseMT.py

@@ -1,5 +1,5 @@
 from SimPEG import SolverLU as SimpegSolver, PropMaps, Utils, mkvc, sp, np
-from SimPEG.EM.FDEM.FDEM import BaseFDEMProblem
+from SimPEG.EM.FDEM.ProblemFDEM import BaseFDEMProblem
 from SurveyMT import Survey, Data
 from FieldsMT import BaseMTFields
 

SimPEG/MT/SrcMT.py

@@ -86,7 +86,7 @@ class polxy_1Dprimary(BaseMTSrc):
         Get the electrical field source
         """
         e_p = self.ePrimary(problem)
-        Map_sigma_p = Maps.Vertical1DMap(problem.mesh)
+        Map_sigma_p = Maps.SurjectVertical1D(problem.mesh)
         sigma_p = Map_sigma_p._transform(self.sigma1d)
         # Make mass matrix
         # Note: M(sig) - M(sig_p) = M(sig - sig_p)
@@ -163,7 +163,7 @@ class polxy_3Dprimary(BaseMTSrc):
         Get the electrical field source
         """
         e_p = self.ePrimary(problem)
-        Map_sigma_p = Maps.Vertical1DMap(problem.mesh)
+        Map_sigma_p = Maps.SurjectVertical1D(problem.mesh)
         sigma_p = Map_sigma_p._transform(self.sigma1d)
         # Make mass matrix
         # Note: M(sig) - M(sig_p) = M(sig - sig_p)

SimPEG/MT/Utils/dataUtils.py

@@ -19,7 +19,7 @@ def getAppRes(MTdata):
         zList.append(zc)
     return [appResPhs(zList[i][0],np.sum(zList[i][1:3])) for i in np.arange(len(zList))]
 
-def rotateData(MTdata,rotAngle):
+def rotateData(MTdata, rotAngle):
     '''
     Function that rotates clockwist by rotAngle (- negative for a counter-clockwise rotation)
     '''
@@ -44,19 +44,19 @@ def rotateData(MTdata,rotAngle):
     return MT.Data.fromRecArray(outRec)
 
 
-def appResPhs(freq,z):
+def appResPhs(freq, z):
     app_res = ((1./(8e-7*np.pi**2))/freq)*np.abs(z)**2
     app_phs = np.arctan2(z.imag,z.real)*(180/np.pi)
     return app_res, app_phs
 
-def skindepth(rho,freq):
+def skindepth(rho, freq):
     ''' Function to calculate the skindepth of EM waves'''
     return np.sqrt( (rho*((1/(freq * mu_0 * np.pi )))))
 
-def rec2ndarr(x,dt=float):
+def rec2ndarr(x, dt=float):
     return x.view((dt, len(x.dtype.names)))
 
-def makeAnalyticSolution(mesh,model,elev,freqs):
+def makeAnalyticSolution(mesh, model, elev, freqs):
     from SimPEG import MT
     data1D = []
     for freq in freqs:
@@ -70,7 +70,7 @@ def makeAnalyticSolution(mesh,model,elev,freqs):
     dataRec = np.array(data1D,dtype=[('freq',float),('x',float),('y',float),('z',float),('zyx',complex)])
     return dataRec
 
-def plotMT1DModelData(problem,models,symList=None):
+def plotMT1DModelData(problem, models, symList=None):
     from SimPEG import MT
     # Setup the figure
     fontSize = 15

SimPEG/MT/Utils/ediFilesUtils.py

@@ -7,17 +7,16 @@ from SimPEG.MT.Utils.dataUtils import rec2ndarr
 # Import modules
 import numpy as np
 import os, sys, re
-try:
-    import osr
-except ImportError as e:
-    print 'Could not import osr, missing the gdal package'
-    pass
+
 
 class EDIimporter:
     """
     A class to import EDIfiles.
 
     """
+
+
+    # Define data converters
     _impUnitEDI2SI = 4*np.pi*1e-4 # Convert Z[mV/km/nT] (as in EDI)to Z[V/A] SI unit
     _impUnitSI2EDI = 1./_impUnitEDI2SI # ConvertZ[V/A] SI unit to Z[mV/km/nT] (as in EDI)
 
@@ -26,8 +25,8 @@ class EDIimporter:
     comps = None
 
     # Hidden properties
-    _outEPSG = None
-    _2out = None
+    _outEPSG = None # Project info
+    _2out = None    # The projection operator
 
 
     def __init__(self, EDIfilesList, compList=None, outEPSG=None):
@@ -113,6 +112,12 @@ class EDIimporter:
     # nOutData=length(obj.data);
     # obj.data(nOutData+1:nOutData+length(TEMP.data),:) = TEMP.data;
     def _transfromPoints(self,longD,latD):
+        # Import the coordinate projections
+        try:
+            import osr
+        except ImportError as e:
+            print 'Could not import osr, missing the gdal package\nCan not project coordinates'
+            raise e
         # Coordinates convertor
         if self._2out is None:
             src = osr.SpatialReference()

SimPEG/Maps.py

@@ -41,8 +41,8 @@ class IdentityMap(object):
             If this is a meshless mapping (i.e. nP is defined independently)
             the shape will be the the shape (nP,nP).
 
-            :rtype: (int,int)
-            :return: shape of the operator as a tuple
+            :rtype: tuple
+            :return: shape of the operator as a tuple (int,int)
         """
         if self._nP is not None:
             return (self.nP, self.nP)
@@ -86,7 +86,7 @@ class IdentityMap(object):
             The derivative of the transformation.
 
             :param numpy.array m: model
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: derivative of transformed model
 
         """
@@ -216,7 +216,7 @@ class ExpMap(IdentityMap):
     def deriv(self, m):
         """
             :param numpy.array m: model
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: derivative of transformed model
 
             The *transform* changes the model into the physical property.
@@ -366,7 +366,7 @@ class SurjectVertical1D(IdentityMap):
     def deriv(self, m):
         """
             :param numpy.array m: model
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: derivative of transformed model
         """
         repNum = self.mesh.vnC[:self.mesh.dim-1].prod()
@@ -427,7 +427,7 @@ class Surject2Dto3D(IdentityMap):
     def deriv(self, m):
         """
             :param numpy.array m: model
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: derivative of transformed model
         """
         inds = self * np.arange(self.nP)
@@ -502,7 +502,9 @@ class InjectActiveCells(IdentityMap):
         if Utils.isScalar(valInactive):
             self.valInactive = np.ones(self.nC)*float(valInactive)
         else:
-            self.valInactive = valInactive.copy()
+            self.valInactive = np.ones(self.nC)
+            self.valInactive[self.indInactive] = valInactive.copy()
+            
         self.valInactive[self.indActive] = 0
 
         inds = np.nonzero(self.indActive)[0]
@@ -533,83 +535,6 @@ class ActiveCells(InjectActiveCells):
             FutureWarning)
         InjectActiveCells.__init__(self, mesh, indActive, valInactive, nC)
 
-class InjectActiveCellsTopo(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 ActiveCellsTopo(InjectActiveCellsTopo):
-    def __init__(self, mesh, indActive, valInactive, nC=None):
-        warnings.warn(
-            "`ActiveCellsTopo` is deprecated and will be removed in future versions. Use `InjectActiveCellsTopo` instead",
-            FutureWarning)
-        InjectActiveCellsTopo.__init__(self, mesh, indActive, valInactive, nC)
 
 class Weighting(IdentityMap):
     """
@@ -759,15 +684,29 @@ class PolyMap(IdentityMap):
 
             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'):
+    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):
@@ -785,8 +724,8 @@ class PolyMap(IdentityMap):
             sig1, sig2 = np.exp(sig1), np.exp(sig2)
         #2D
         if self.mesh.dim == 2:
-            X = self.mesh.gridCC[:,0]
-            Y = self.mesh.gridCC[:,1]
+            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':
@@ -795,9 +734,9 @@ class PolyMap(IdentityMap):
                 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]
+            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':
@@ -806,6 +745,7 @@ class PolyMap(IdentityMap):
                 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"))
 
@@ -819,8 +759,8 @@ class PolyMap(IdentityMap):
             sig1, sig2 = np.exp(sig1), np.exp(sig2)
         #2D
         if self.mesh.dim == 2:
-            X = self.mesh.gridCC[:,0]
-            Y = self.mesh.gridCC[:,1]
+            X = self.mesh.gridCC[self.actInd,0]
+            Y = self.mesh.gridCC[self.actInd,1]
 
             if self.normal =='X':
                 f = polynomial.polyval(Y, c) - X
@@ -832,9 +772,9 @@ class PolyMap(IdentityMap):
                 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]
+            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

SimPEG/Mesh/BaseMesh.py

@@ -7,8 +7,8 @@ class BaseMesh(object):
     BaseMesh does all the counting you don't want to do.
     BaseMesh should be inherited by meshes with a regular structure.
 
-    :param numpy.array,list n: number of cells in each direction (dim, )
-    :param numpy.array,list x0: Origin of the mesh (dim, )
+    :param numpy.array n: (or list) number of cells in each direction (dim, )
+    :param numpy.array x0: (or list) Origin of the mesh (dim, )
 
     """
 
@@ -34,8 +34,8 @@ class BaseMesh(object):
         """
         Origin of the mesh
 
-        :rtype: numpy.array (dim, )
-        :return: x0
+        :rtype: numpy.array
+        :return: x0, (dim, )
         """
         return self._x0
 
@@ -116,8 +116,8 @@ class BaseMesh(object):
         """
         Total number of edges in each direction
 
-        :rtype: numpy.array (dim, )
-        :return: [nEx, nEy, nEz]
+        :rtype: numpy.array
+        :return: [nEx, nEy, nEz], (dim, )
 
         .. plot::
             :include-source:
@@ -173,8 +173,8 @@ class BaseMesh(object):
         """
         Total number of faces in each direction
 
-        :rtype: numpy.array (dim, )
-        :return: [nFx, nFy, nFz]
+        :rtype: numpy.array
+        :return: [nFx, nFy, nFz], (dim, )
 
         .. plot::
             :include-source:
@@ -200,8 +200,8 @@ class BaseMesh(object):
         """
         Face Normals
 
-        :rtype: numpy.array (sum(nF), dim)
-        :return: normals
+        :rtype: numpy.array
+        :return: normals, (sum(nF), dim)
         """
         if self.dim == 2:
             nX = np.c_[np.ones(self.nFx), np.zeros(self.nFx)]
@@ -218,8 +218,8 @@ class BaseMesh(object):
         """
         Edge Tangents
 
-        :rtype: numpy.array (sum(nE), dim)
-        :return: normals
+        :rtype: numpy.array
+        :return: normals, (sum(nE), dim)
         """
         if self.dim == 2:
             tX = np.c_[np.ones(self.nEx), np.zeros(self.nEx)]
@@ -236,8 +236,9 @@ class BaseMesh(object):
         Given a vector, fV, in cartesian coordinates, this will project it onto the mesh using the normals
 
         :param numpy.array fV: face vector with shape (nF, dim)
-        :rtype: numpy.array with shape (nF, )
-        :return: projected face vector
+        :rtype: numpy.array
+        :return: projected face vector, (nF, )
+
         """
         assert isinstance(fV, np.ndarray), 'fV must be an ndarray'
         assert len(fV.shape) == 2 and fV.shape[0] == self.nF and fV.shape[1] == self.dim, 'fV must be an ndarray of shape (nF x dim)'
@@ -248,8 +249,9 @@ class BaseMesh(object):
         Given a vector, eV, in cartesian coordinates, this will project it onto the mesh using the tangents
 
         :param numpy.array eV: edge vector with shape (nE, dim)
-        :rtype: numpy.array with shape (nE, )
-        :return: projected edge vector
+        :rtype: numpy.array
+        :return: projected edge vector, (nE, )
+
         """
         assert isinstance(eV, np.ndarray), 'eV must be an ndarray'
         assert len(eV.shape) == 2 and eV.shape[0] == self.nE and eV.shape[1] == self.dim, 'eV must be an ndarray of shape (nE x dim)'
@@ -295,7 +297,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Total number of cells in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: [nCx, nCy, nCz]
         """
         return np.array([x for x in [self.nCx, self.nCy, self.nCz] if not x is None])
@@ -335,7 +337,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Total number of nodes in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: [nNx, nNy, nNz]
         """
         return np.array([x for x in [self.nNx, self.nNy, self.nNz] if not x is None])
@@ -345,7 +347,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Number of x-edges in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: vnEx
         """
         return np.array([x for x in [self.nCx, self.nNy, self.nNz] if not x is None])
@@ -355,7 +357,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Number of y-edges in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: vnEy or None if dim < 2
         """
         return None if self.dim < 2 else np.array([x for x in [self.nNx, self.nCy, self.nNz] if not x is None])
@@ -365,7 +367,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Number of z-edges in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: vnEz or None if dim < 3
         """
         return None if self.dim < 3 else np.array([x for x in [self.nNx, self.nNy, self.nCz] if not x is None])
@@ -375,7 +377,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Number of x-faces in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: vnFx
         """
         return np.array([x for x in [self.nNx, self.nCy, self.nCz] if not x is None])
@@ -385,7 +387,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Number of y-faces in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: vnFy or None if dim < 2
         """
         return None if self.dim < 2 else np.array([x for x in [self.nCx, self.nNy, self.nCz] if not x is None])
@@ -395,7 +397,7 @@ class BaseRectangularMesh(BaseMesh):
         """
         Number of z-faces in each direction
 
-        :rtype: numpy.array (dim, )
+        :rtype: numpy.array
         :return: vnFz or None if dim < 3
         """
         return None if self.dim < 3 else np.array([x for x in [self.nCx, self.nCy, self.nNz] if not x is None])

SimPEG/Mesh/CurvilinearMesh.py

@@ -2,6 +2,7 @@ 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
@@ -10,7 +11,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):
+class CurvilinearMesh(BaseRectangularMesh, DiffOperators, InnerProducts, CurvView):
     """
     CurvilinearMesh is a mesh class that deals with curvilinear meshes.
 
@@ -330,102 +331,6 @@ class CurvilinearMesh(BaseRectangularMesh, DiffOperators, InnerProducts):
 
 
 
-    #############################################
-    #            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

@@ -68,8 +68,8 @@ class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
         """
         Number of x-faces in each direction
 
-        :rtype: numpy.array (dim, )
-        :return: vnFx
+        :rtype: numpy.array 
+        :return: vnFx, (dim, )
         """
         return self.vnC
 
@@ -78,8 +78,8 @@ class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
         """
         Number of y-edges in each direction
 
-        :rtype: numpy.array (dim, )
-        :return: vnEy or None if dim < 2
+        :rtype: numpy.array 
+        :return: vnEy or None if dim < 2, (dim, )
         """
         nNx = self.nNx if self.isSymmetric else self.nNx - 1
         return np.r_[nNx, self.nCy, self.nNz]
@@ -89,8 +89,8 @@ class CylMesh(BaseTensorMesh, BaseRectangularMesh, InnerProducts, CylView):
         """
         Number of z-edges in each direction
 
-        :rtype: numpy.array (dim, )
-        :return: vnEz or None if nCy > 1
+        :rtype: numpy.array 
+        :return: vnEz or None if nCy > 1, (dim, )
         """
         if self.isSymmetric:
             return np.r_[self.nNx, self.nNy, self.nCz]
@@ -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'):
+    def getInterpolationMatCartMesh(self, Mrect, locType='CC', locTypeTo=None):
         """
             Takes a cartesian mesh and returns a projection to translate onto the cartesian grid.
         """
@@ -338,19 +338,22 @@ 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')
-            Y = self.getInterpolationMatCartMesh(Mrect, locType='Fy')
-            Z = self.getInterpolationMatCartMesh(Mrect, locType='Fz')
+            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')
             return sp.vstack((X,Y,Z))
         if locType == 'E':
-            X = self.getInterpolationMatCartMesh(Mrect, locType='Ex')
-            Y = self.getInterpolationMatCartMesh(Mrect, locType='Ey')
-            Z = spzeros(Mrect.nEz, self.nE)
+            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)
             return sp.vstack((X,Y,Z))
 
-        grid = getattr(Mrect, 'grid' + locType)
+        grid = getattr(Mrect, 'grid' + locTypeTo)
         # 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
@@ -366,7 +369,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:,:],
-                    }[locType]
+                    }[locTypeTo]
             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/InnerProducts.py

@@ -16,7 +16,7 @@ class InnerProducts(object):
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
             :param bool doFast: do a faster implementation if available.
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: M, the inner product matrix (nF, nF)
         """
         return self._getInnerProduct('F', prop=prop, invProp=invProp, invMat=invMat, doFast=doFast)
@@ -27,7 +27,7 @@ class InnerProducts(object):
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
             :param bool doFast: do a faster implementation if available.
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: M, the inner product matrix (nE, nE)
         """
         return self._getInnerProduct('E', prop=prop, invProp=invProp, invMat=invMat, doFast=doFast)
@@ -39,7 +39,7 @@ class InnerProducts(object):
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
             :param bool doFast: do a faster implementation if available.
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: M, the inner product matrix (nE, nE)
         """
         assert projType in ['F', 'E'], "projType must be 'F' for faces or 'E' for edges"
@@ -115,13 +115,12 @@ class InnerProducts(object):
             :param bool doFast: do a faster implementation if available.
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
-            :rtype: function
             :return: dMdmu(u), the derivative of the inner product matrix (u)
 
             Given u, dMdmu returns (nF, nC*nA)
 
-            :param np.ndarray u: vector that multiplies dMdmu
-            :rtype: scipy.csr_matrix
+            :param numpy.ndarray u: vector that multiplies dMdmu
+            :rtype: scipy.sparse.csr_matrix
             :return: dMdmu, the derivative of the inner product matrix for a certain u
         """
         return self._getInnerProductDeriv(prop, 'F', doFast=doFast, invProp=invProp, invMat=invMat)
@@ -133,7 +132,7 @@ class InnerProducts(object):
             :param bool doFast: do a faster implementation if available.
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: dMdm, the derivative of the inner product matrix (nE, nC*nA)
         """
         return self._getInnerProductDeriv(prop, 'E', doFast=doFast, invProp=invProp, invMat=invMat)
@@ -145,7 +144,7 @@ class InnerProducts(object):
             :param bool doFast: do a faster implementation if available.
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: dMdm, the derivative of the inner product matrix (nE, nC*nA)
         """
         fast = None
@@ -169,7 +168,7 @@ class InnerProducts(object):
             :param numpy.array v: vector to multiply (required in the general implementation)
             :param list P: list of projection matrices
             :param str projType: 'F' for faces 'E' for edges
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: dMdm, the derivative of the inner product matrix (n, nC*nA)
         """
         assert projType in ['F', 'E'], "projType must be 'F' for faces or 'E' for edges"

SimPEG/Mesh/MeshIO.py

@@ -6,13 +6,11 @@ class TensorMeshIO(object):
     @classmethod
     def readUBC(TensorMesh, fileName):
         """
-            Read UBC GIF 3DTensor mesh and generate 3D Tensor mesh in simpegTD
+            Read UBC GIF 3D tensor mesh and generate 3D TensorMesh in SimPEG.
 
-            Input:
-            :param fileName, path to the UBC GIF mesh file
-
-            Output:
-            :param SimPEG TensorMesh object
+            :param string fileName: path to the UBC GIF mesh file
+            :rtype: TensorMesh
+            :return: The tensor mesh for the fileName.
         """
 
         # Interal function to read cell size lines for the UBC mesh files.
@@ -24,7 +22,6 @@ class TensorMeshIO(object):
                     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='!')
 
@@ -49,11 +46,9 @@ class TensorMeshIO(object):
             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
+            :param string fileName: path to the vtr model file to read
+            :rtype: tuple
+            :return: (TensorMesh, modelDictionary)
 
         """
         # Import
@@ -103,9 +98,8 @@ class TensorMeshIO(object):
         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
+        :param string fileName: path to the output vtk file
+        :param dict models: dictionary of numpy.array - Name('s) and array('s). Match number of cells
 
         """
         # Import
@@ -163,12 +157,9 @@ class TensorMeshIO(object):
         """
             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
+            :param string fileName: path to the UBC GIF mesh file to read
+            :rtype: numpy.ndarray
+            :return: model with TensorMesh ordered
         """
         f = open(fileName, 'r')
         model = np.array(map(float, f.readlines()))
@@ -184,8 +175,7 @@ class TensorMeshIO(object):
             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 string fileName: File to write to
             :param numpy.ndarray model: The model
         """
 
@@ -202,8 +192,8 @@ class TensorMeshIO(object):
         """
             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
+            :param string fileName: File to write to
+            :param dict models: A dictionary of the models
 
         """
         assert mesh.dim == 3
@@ -232,9 +222,8 @@ class TreeMeshIO(object):
         """
             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
+            :param string fileName: File to write to
+            :param dict 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.
@@ -287,10 +276,9 @@ class TreeMeshIO(object):
 
             Input:
             :param str meshFile: path to the UBC GIF OcTree mesh file to read
+            :rtype: SimPEG.Mesh.TreeMesh
+            :return: The octree mesh
 
-            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
@@ -336,11 +324,9 @@ class TreeMeshIO(object):
         """
             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
+            :param string fileName: path to the UBC GIF model file to read
+            :rtype: numpy.ndarray
+            :return: OcTree model
         """
 
         if type(fileName) is list:

SimPEG/Mesh/TensorMesh.py

@@ -198,8 +198,8 @@ class BaseTensorMesh(BaseMesh):
         Determines if a set of points are inside a mesh.
 
         :param numpy.ndarray pts: Location of points to test
-        :rtype numpy.ndarray
-        :return inside, numpy array of booleans
+        :rtype numpy.ndarray:
+        :return: inside, numpy array of booleans
         """
         pts = Utils.asArray_N_x_Dim(pts, self.dim)
 
@@ -221,7 +221,7 @@ class BaseTensorMesh(BaseMesh):
 
         :param numpy.ndarray loc: Location of points to interpolate to
         :param str locType: What to interpolate (see below)
-        :rtype: scipy.sparse.csr.csr_matrix
+        :rtype: scipy.sparse.csr_matrix
         :return: M, the interpolation matrix
 
         locType can be::
@@ -289,7 +289,7 @@ class BaseTensorMesh(BaseMesh):
             :param bool returnP: returns the projection matrices
             :param bool invProp: inverts the material property
             :param bool invMat: inverts the matrix
-            :rtype: scipy.csr_matrix
+            :rtype: scipy.sparse.csr_matrix
             :return: M, the inner product matrix (nF, nF)
         """
         assert projType in ['F', 'E'], "projType must be 'F' for faces or 'E' for edges"

SimPEG/Mesh/TreeMesh.py

@@ -1875,7 +1875,7 @@ class TreeMesh(BaseTensorMesh, InnerProducts, TreeMeshIO):
 
         :param numpy.ndarray locs: Location of points to interpolate to
         :param str locType: What to interpolate (see below)
-        :rtype: scipy.sparse.csr.csr_matrix
+        :rtype: scipy.sparse.csr_matrix
         :return: M, the interpolation matrix
 
         locType can be::
@@ -2131,10 +2131,16 @@ class TreeMesh(BaseTensorMesh, InnerProducts, TreeMeshIO):
     def plotSlice(self, v, vType='CC',
         normal='Z', ind=None, grid=True, view='real',
         ax=None, clim=None, showIt=False,
-        pcolorOpts={},
-        streamOpts={'color':'k'},
-        gridOpts={'color':'k', 'alpha':0.5}):
+        pcolorOpts=None,
+        streamOpts=None,
+        gridOpts=None):
 
+        if pcolorOpts is None:
+            pcolorOpts = {}
+        if streamOpts is None:
+            streamOpts = {'color':'k'}
+        if gridOpts is None:
+            gridOpts = {'color':'k', 'alpha':0.5}
         assert vType in ['CC','F','E']
         assert self.dim == 3
 

SimPEG/Mesh/View.py

@@ -42,9 +42,9 @@ class TensorView(object):
 
     def plotImage(self, v, vType='CC', grid=False, view='real',
               ax=None, clim=None, showIt=False,
-              pcolorOpts={},
-              streamOpts={'color':'k'},
-              gridOpts={'color':'k'},
+              pcolorOpts=None,
+              streamOpts=None,
+              gridOpts=None,
               numbering=True, annotationColor='w'
               ):
         """
@@ -84,6 +84,12 @@ class TensorView(object):
             M.plotImage(v, annotationColor='k', showIt=True)
 
         """
+        if pcolorOpts is None:
+            pcolorOpts = {}
+        if streamOpts is None:
+            streamOpts = {'color':'k'}
+        if gridOpts is None:
+            gridOpts = {'color':'k'}
 
         if ax is None:
             fig = plt.figure()
@@ -174,9 +180,9 @@ class TensorView(object):
     def plotSlice(self, v, vType='CC',
                   normal='Z', ind=None, grid=False, view='real',
                   ax=None, clim=None, showIt=False,
-                  pcolorOpts={},
-                  streamOpts={'color':'k'},
-                  gridOpts={'color':'k', 'alpha':0.5}
+                  pcolorOpts=None,
+                  streamOpts=None,
+                  gridOpts=None
                   ):
 
         """
@@ -197,6 +203,12 @@ class TensorView(object):
             M.plotSlice(M.cellGrad*b, 'F', view='vec', grid=True, showIt=True, pcolorOpts={'alpha':0.8})
 
         """
+        if pcolorOpts is None:
+            pcolorOpts = {}
+        if streamOpts is None:
+            streamOpts = {'color':'k'}
+        if gridOpts is None:
+            gridOpts = {'color':'k', 'alpha':0.5}
         if type(vType) in [list, tuple]:
             assert ax is None, "cannot specify an axis to plot on with this function."
             fig, axs = plt.subplots(1,len(vType))
@@ -206,7 +218,7 @@ class TensorView(object):
             return out
         viewOpts = ['real','imag','abs','vec']
         normalOpts = ['X', 'Y', 'Z']
-        vTypeOpts = ['CC', 'CCv','F','E','Fx','Fy','Fz','E','Ex','Ey','Ez']
+        vTypeOpts = ['CC', 'CCv','N','F','E','Fx','Fy','Fz','E','Ex','Ey','Ez']
 
         # Some user error checking
         assert vType in vTypeOpts, "vType must be in ['%s']" % "','".join(vTypeOpts)
@@ -289,11 +301,17 @@ class TensorView(object):
 
     def _plotImage2D(self, v, vType='CC', grid=False, view='real',
               ax=None, clim=None, showIt=False,
-              pcolorOpts={},
-              streamOpts={'color':'k'},
-              gridOpts={'color':'k'}
+              pcolorOpts=None,
+              streamOpts=None,
+              gridOpts=None
               ):
 
+        if pcolorOpts is None:
+            pcolorOpts = {}
+        if streamOpts is None:
+            streamOpts = {'color':'k'}
+        if gridOpts is None:
+            gridOpts = {'color':'k'}
         vTypeOptsCC = ['N','CC','Fx','Fy','Ex','Ey']
         vTypeOptsV = ['CCv','F','E']
         vTypeOpts = vTypeOptsCC + vTypeOptsV
@@ -534,7 +552,8 @@ class CurvView(object):
     def __init__(self):
         pass
 
-    def plotGrid(self, length=0.05, showIt=False):
+
+    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.
 
 
@@ -542,60 +561,63 @@ class CurvView(object):
             :include-source:
 
             from SimPEG import Mesh, Utils
-            X, Y = Utils.exampleCurvGird([3,3],'rotate')
+            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
+
+        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:
-            fig = plt.figure(2)
-            fig.clf()
-            ax = plt.subplot(111)
-            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()
+            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()
 
-            X = np.r_[X1, X2]
-            Y = np.r_[Y1, Y2]
+                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()
 
-            plt.plot(X, Y)
+                X = np.r_[X1, X2]
+                Y = np.r_[Y1, Y2]
 
-            plt.hold(True)
-            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(X, Y, 'b-')
+            if centers:
+                ax.plot(self.gridCC[:,0],self.gridCC[:,1],'ro')
 
-            plt.plot(self.gridN[:, 0], self.gridN[:, 1], 'bo')
+            # 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')
 
-            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()
-            plt.plot(self.gridFx[:, 0], self.gridFx[:, 1], 'rs')
-            plt.plot(nX, nY, 'r-')
+            # ax.plot(self.gridN[:, 0], self.gridN[:, 1], 'bo')
 
-            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()
-            #plt.plot(self.gridFy[:, 0], self.gridFy[:, 1], 'gs')
-            plt.plot(nX, nY, 'g-')
+            # 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-')
 
-            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()
-            plt.plot(self.gridEx[:, 0], self.gridEx[:, 1], 'r^')
-            plt.plot(tX, tY, '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-')
 
-            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()
-            #plt.plot(self.gridEy[:, 0], self.gridEy[:, 1], 'g^')
-            plt.plot(nX, nY, 'g-')
-            plt.axis('equal')
+            # 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:
-            fig = plt.figure(3)
-            fig.clf()
-            ax = fig.add_subplot(111, projection='3d')
             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()
@@ -612,16 +634,50 @@ class CurvView(object):
             Y = np.r_[Y1, Y2, Y3]
             Z = np.r_[Z1, Z2, Z3]
 
-            plt.plot(X, Y, 'b', zs=Z)
+            ax.plot(X, Y, 'b', zs=Z)
             ax.set_zlabel('x3')
 
         ax.grid(True)
-        ax.hold(False)
         ax.set_xlabel('x1')
         ax.set_ylabel('x2')
 
         if showIt: plt.show()
 
+    def plotImage(self, I, ax=None, showIt=False, grid=False, clim=None):
+        if self.dim == 3: raise NotImplementedError('This is not yet done!')
+
+        import matplotlib.pyplot as plt
+        import matplotlib
+        from mpl_toolkits.mplot3d import Axes3D
+        import matplotlib.colors as colors
+        import matplotlib.cm as cmx
+
+        if ax is None: ax = plt.subplot(111)
+        jet = cm = plt.get_cmap('jet')
+        cNorm  = colors.Normalize(
+            vmin=I.min() if clim is None else clim[0],
+            vmax=I.max() if clim is None else clim[1])
+
+        scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
+        # ax.set_xlim((self.x0[0], self.h[0].sum()))
+        # ax.set_ylim((self.x0[1], self.h[1].sum()))
+
+        Nx = self.r(self.gridN[:,0],'N','N','M')
+        Ny = self.r(self.gridN[:,1],'N','N','M')
+        cell = self.r(I,'CC','CC','M')
+
+        for ii in range(self.nCx):
+            for jj in range(self.nCy):
+                I = [ii,ii+1,ii+1,ii]
+                J = [jj,jj,jj+1,jj+1]
+                ax.add_patch(plt.Polygon(np.c_[Nx[I,J],Ny[I,J]], facecolor=scalarMap.to_rgba(cell[ii,jj]), edgecolor='k' if grid else 'none'))
+
+        scalarMap._A = []  # http://stackoverflow.com/questions/8342549/matplotlib-add-colorbar-to-a-sequence-of-line-plots
+        ax.set_xlabel('x')
+        ax.set_ylabel('y')
+        if showIt: plt.show()
+        return [scalarMap]
+
 
 if __name__ == '__main__':
     from SimPEG import *

SimPEG/Optimization.py

@@ -131,7 +131,7 @@ class Minimize(object):
 
         Minimizes the function (evalFunction) starting at the location x0.
 
-        :param def evalFunction: function handle that evaluates: f, g, H = F(x)
+        :param callable evalFunction: function handle that evaluates: f, g, H = F(x)
         :param numpy.ndarray x0: starting location
         :rtype: numpy.ndarray
         :return: x, the last iterate of the optimization algorithm
@@ -372,8 +372,8 @@ class Minimize(object):
             Else, a modifySearchDirectionBreak call is preformed.
 
             :param numpy.ndarray p: searchDirection
-            :rtype: numpy.ndarray,bool
-            :return: (xt, passLS)
+            :rtype: tuple
+            :return: (xt, passLS) numpy.ndarray, bool
         """
         # Projected Armijo linesearch
         self._LS_t = 1
@@ -408,8 +408,8 @@ class Minimize(object):
             evalFunction returns a False indicating the break was not caught.
 
             :param numpy.ndarray p: searchDirection
-            :rtype: numpy.ndarray,bool
-            :return: (xt, breakCaught)
+            :rtype: tuple
+            :return: (xt, breakCaught) numpy.ndarray, bool
         """
         self.printDone(inLS=True)
         print 'The linesearch got broken. Boo.'
@@ -1003,8 +1003,9 @@ class ProjectedGNCG(BFGS, Minimize, Remember):
                 # perturb inactive set off of bounds so that they are included in the step
                 delx = delx + self.stepOffBoundsFact * (rhs_a * dm_i / dm_a)
 
+
             # Only keep gradients going in the right direction on the active set
             indx = ((self.xc<=self.lower) & (delx < 0)) | ((self.xc>=self.upper) & (delx > 0))
             delx[indx] = 0.
 
-            return delx
+            return delx

SimPEG/PF/BaseGrav.py

@@ -0,0 +1,53 @@
+from SimPEG import Maps, Survey, Utils, np, sp
+from scipy.constants import mu_0
+import re
+
+
+class LinearSurvey(Survey.BaseSurvey):
+    """Base Magnetics Survey"""
+
+    rxLoc = None #: receiver locations
+    rxType = None #: receiver type
+
+    def __init__(self, srcField, **kwargs):
+        self.srcField = srcField
+        Survey.BaseSurvey.__init__(self, **kwargs)
+
+    def eval(self, u):
+        return u
+
+    @property
+    def nD(self):
+        return self.prob.G.shape[0]
+
+    @property
+    def nRx(self):
+        return self.srcField.rxList[0].locs.shape[0]
+    # def setBackgroundField(self, SrcField):
+
+    #     if getattr(self, 'B0', None) is None:
+    #         self._B0 = SrcField.param[0] * dipazm_2_xyz(SrcField.param[1],SrcField.param[2])
+
+    #     return self._B0
+
+
+class SrcField(Survey.BaseSrc):
+    """ Define the inducing field """
+
+    param = None #: Inducing field param (Amp, Incl, Decl)
+
+    def __init__(self, rxList, **kwargs):
+        super(SrcField, self).__init__(rxList, **kwargs)
+
+
+class RxObs(Survey.BaseRx):
+    """A station location must have be located in 3-D"""
+    def __init__(self, locsXYZ, **kwargs):
+        locs = locsXYZ
+        assert locsXYZ.shape[1] == 3, 'locs must in 3-D (x,y,z).'
+        super(RxObs, self).__init__(locs, 'tmi', storeProjections=False, **kwargs)
+
+    @property
+    def nD(self):
+        """Number of data in the receiver."""
+        return self.locs[0].shape[0]

SimPEG/PF/BaseMag.py

@@ -0,0 +1,194 @@
+from SimPEG import Maps, Survey, Utils, np, sp
+from scipy.constants import mu_0
+import re
+
+
+class BaseMagSurvey(Survey.BaseSurvey):
+    """Base Magnetics Survey"""
+
+    rxLoc = None   #: receiver locations
+    rxType = None   #: receiver type
+
+    def __init__(self, **kwargs):
+        Survey.BaseSurvey.__init__(self, **kwargs)
+
+    def setBackgroundField(self, Inc, Dec, Btot):
+
+        Bx = Btot*np.cos(Inc/180.*np.pi)*np.sin(Dec/180.*np.pi)
+        By = Btot*np.cos(Inc/180.*np.pi)*np.cos(Dec/180.*np.pi)
+        Bz = -Btot*np.sin(Inc/180.*np.pi)
+
+        self.B0 = np.r_[Bx, By, Bz]
+
+    @property
+    def Qfx(self):
+        if getattr(self, '_Qfx', None) is None:
+            self._Qfx = self.prob.mesh.getInterpolationMat(self.rxLoc, 'Fx')
+        return self._Qfx
+
+    @property
+    def Qfy(self):
+        if getattr(self, '_Qfy', None) is None:
+            self._Qfy = self.prob.mesh.getInterpolationMat(self.rxLoc, 'Fy')
+        return self._Qfy
+
+    @property
+    def Qfz(self):
+        if getattr(self, '_Qfz', None) is None:
+            self._Qfz = self.prob.mesh.getInterpolationMat(self.rxLoc, 'Fz')
+        return self._Qfz
+
+    def projectFields(self, u):
+        """
+            This function projects the fields onto the data space.
+
+            Especially, here for we use total magnetic intensity (TMI) data,
+            which is common in practice.
+
+            First we project our B on to data location
+
+            .. math::
+
+                \mathbf{B}_{rec} = \mathbf{P} \mathbf{B}
+
+            then we take the dot product between B and b_0
+
+            .. math ::
+
+                \\text{TMI} = \\vec{B}_s \cdot \hat{B}_0
+
+        """
+        # TODO: There can be some different tyes of data like |B| or B
+
+        bfx = self.Qfx*u['B']
+        bfy = self.Qfy*u['B']
+        bfz = self.Qfz*u['B']
+
+        # Generate unit vector
+        B0 = self.prob.survey.B0
+        Bot = np.sqrt(B0[0]**2+B0[1]**2+B0[2]**2)
+        box = B0[0]/Bot
+        boy = B0[1]/Bot
+        boz = B0[2]/Bot
+
+        # return bfx*box + bfx*boy + bfx*boz
+        return bfx*box + bfy*boy + bfz*boz
+
+    @Utils.count
+    def projectFieldsDeriv(self, B):
+        """
+            This function projects the fields onto the data space.
+
+            .. math::
+
+                \\frac{\partial d_\\text{pred}}{\partial \mathbf{B}} = \mathbf{P}
+
+            Especially, this function is for TMI data type
+
+        """
+        # Generate unit vector
+        B0 = self.prob.survey.B0
+        Bot = np.sqrt(B0[0]**2+B0[1]**2+B0[2]**2)
+        box = B0[0]/Bot
+        boy = B0[1]/Bot
+        boz = B0[2]/Bot
+
+        return self.Qfx*box+self.Qfy*boy+self.Qfz*boz
+
+    def projectFieldsAsVector(self, B):
+
+        bfx = self.Qfx*B
+        bfy = self.Qfy*B
+        bfz = self.Qfz*B
+
+        return np.r_[bfx, bfy, bfz]
+
+
+class LinearSurvey(Survey.BaseSurvey):
+    """Base Magnetics Survey"""
+
+    rxLoc = None #: receiver locations
+    rxType = None #: receiver type
+
+    def __init__(self, srcField, **kwargs):
+        self.srcField = srcField
+        Survey.BaseSurvey.__init__(self, **kwargs)
+
+    def eval(self, u):
+        return u
+
+    @property
+    def nD(self):
+        return self.prob.G.shape[0]
+
+    @property
+    def nRx(self):
+        return self.srcField.rxList[0].locs.shape[0]
+    # def setBackgroundField(self, SrcField):
+
+    #     if getattr(self, 'B0', None) is None:
+    #         self._B0 = SrcField.param[0] * dipazm_2_xyz(SrcField.param[1],SrcField.param[2])
+
+    #     return self._B0
+
+
+class SrcField(Survey.BaseSrc):
+    """ Define the inducing field """
+
+    param = None #: Inducing field param (Amp, Incl, Decl)
+
+    def __init__(self, rxList, **kwargs):
+        super(SrcField, self).__init__(rxList, **kwargs)
+
+
+class RxObs(Survey.BaseRx):
+    """A station location must have be located in 3-D"""
+    def __init__(self, locsXYZ, **kwargs):
+        locs = locsXYZ
+        assert locsXYZ.shape[1] == 3, 'locs must in 3-D (x,y,z).'
+        super(RxObs, self).__init__(locs, 'tmi', storeProjections=False, **kwargs)
+
+    @property
+    def nD(self):
+        """Number of data in the receiver."""
+        return self.locs[0].shape[0]
+
+
+class MagSurveyBx(object):
+    """docstring for MagSurveyBx"""
+    def __init__(self, **kwargs):
+        Survey.BaseData.__init__(self, **kwargs)
+
+    def projectFields(self, B):
+        bfx = self.Qfx*B
+        return bfx
+
+
+class BaseMagMap(Maps.IdentityMap):
+    """BaseMagMap"""
+
+    def __init__(self, mesh, **kwargs):
+        Maps.IdentityMap.__init__(self, mesh)
+
+    def _transform(self, m):
+
+        return mu_0*(1 + m)
+
+    def deriv(self, m):
+
+        return mu_0*sp.identity(self.nP)
+
+
+class WeightMap(Maps.IdentityMap):
+    """Weighted Map for distributed parameters"""
+
+    def __init__(self, nP, weight, **kwargs):
+        Maps.IdentityMap.__init__(self, nP)
+        self.mesh = None
+        self.weight = weight
+
+    def _transform(self, m):
+        return m*self.weight
+
+    def deriv(self, m):
+        return Utils.sdiag(self.weight)

SimPEG/PF/Gravity.py

@@ -0,0 +1,576 @@
+from SimPEG import *
+import BaseGrav as GRAV
+import re
+
+
+class GravityIntegral(Problem.BaseProblem):
+
+    # surveyPair = Survey.LinearSurvey
+    forwardOnly = False #: Determine if the forward matrix is stored (defaut:yes)
+    actInd = None #: Active cell indices provided
+    rtype       = 'z'
+
+    def __init__(self, mesh, mapping=None, **kwargs):
+        Problem.BaseProblem.__init__(self, mesh, mapping=mapping, **kwargs)
+
+    def fwr_op(self):
+        # Add forward function
+        # kappa = self.curModel.kappa TODO
+        rho = self.mapping*self.curModel
+
+        if self.forwardOnly:
+
+            if getattr(self, 'actInd', None) is not None:
+
+                if self.actInd.dtype=='bool':
+                    inds = np.asarray([inds for inds, elem in enumerate(self.actInd, 1) if elem], dtype = int) - 1
+                else:
+                    inds = self.actInd
+
+            else:
+
+                inds = np.asarray(range(self.mesh.nC))
+
+            nC = len(inds)
+
+            # Create active cell projector
+            P = sp.csr_matrix(
+                (np.ones(nC), (inds, range(nC))),
+                shape=(self.mesh.nC, nC)
+            )
+
+            # Create vectors of nodal location (lower and upper corners for each cell)
+            xn = self.mesh.vectorNx
+            yn = self.mesh.vectorNy
+            zn = self.mesh.vectorNz
+
+            yn2, xn2, zn2 = np.meshgrid(yn[1:], xn[1:], zn[1:])
+            yn1, xn1, zn1 = np.meshgrid(yn[0:-1], xn[0:-1], zn[0:-1])
+
+            Yn = P.T*np.c_[mkvc(yn1), mkvc(yn2)]
+            Xn = P.T*np.c_[mkvc(xn1), mkvc(xn2)]
+            Zn = P.T*np.c_[mkvc(zn1), mkvc(zn2)]
+
+            rxLoc = self.survey.srcField.rxList[0].locs
+            ndata = rxLoc.shape[0]
+
+
+            # Pre-allocate space and create magnetization matrix if required
+            # Pre-allocate space
+            if self.rtype == 'z':
+
+                fwr_d = np.zeros(self.survey.nRx)
+
+            elif self.rtype == 'xyz':
+
+                fwr_d = np.zeros(3*self.survey.nRx)
+
+            else:
+
+                print """Flag must be either 'z' | 'xyz', please revised"""
+                return
+
+
+            # Add counter to dsiplay progress. Good for large problems
+            count = -1;
+            for ii in range(ndata):
+
+
+                tx, ty, tz = get_T_mat(Xn, Yn, Zn, rxLoc[ii, :])
+
+
+                if self.rtype =='z':
+                    fwr_d[ii] =tz.dot(rho)
+
+                elif self.rtype =='xyz':
+                    fwr_d[ii] = tx.dot(rho)
+                    fwr_d[ii+ndata] = ty.dot(rho)
+                    fwr_d[ii+2*ndata] = tz.dot(rho)
+
+
+            # Display progress
+                count = progress(ii,count,ndata)
+
+            print "Done 100% ...forward operator completed!!\n"
+
+            return fwr_d
+
+        else:
+            return self.G.dot(rho)
+
+    def fields(self, m):
+        self.curModel = m
+
+        fields = self.fwr_op()
+
+        return fields
+
+        # return self.G.dot(self.mapping*(m))
+
+    def Jvec(self, m, v, f=None):
+        dmudm = self.mapping.deriv(m)
+        return self.G.dot(dmudm*v)
+
+    def Jtvec(self, m, v, f=None):
+        dmudm = self.mapping.deriv(m)
+        return dmudm.T * (self.G.T.dot(v))
+
+    @property
+    def G(self):
+        if not self.ispaired:
+            raise Exception('Need to pair!')
+
+        if getattr(self, '_G', None) is None:
+            self._G = self.Intrgl_Fwr_Op( 'z' )
+
+        return self._G
+
+    def Intrgl_Fwr_Op(self, flag):
+
+        """
+
+        Gravity forward operator in integral form
+
+        flag        = 'z' | 'xyz'
+
+        Return
+        _G        = Linear forward modeling operation
+
+        Created on March, 15th 2016
+
+        @author: dominiquef
+
+         """
+        # Find non-zero cells
+        # inds = np.nonzero(actv)[0]
+        if getattr(self, 'actInd', None) is not None:
+
+            if self.actInd.dtype=='bool':
+                inds = np.asarray([inds for inds, elem in enumerate(self.actInd, 1) if elem], dtype = int) - 1
+            else:
+                inds = self.actInd
+
+        else:
+
+            inds = np.asarray(range(self.mesh.nC))
+
+        nC = len(inds)
+
+        # Create active cell projector
+        P = sp.csr_matrix(
+            (np.ones(nC), (inds, range(nC))),
+            shape=(self.mesh.nC, nC)
+        )
+
+        # Create vectors of nodal location (lower and upper corners for each cell)
+        xn = self.mesh.vectorNx
+        yn = self.mesh.vectorNy
+        zn = self.mesh.vectorNz
+
+        yn2, xn2, zn2 = np.meshgrid(yn[1:], xn[1:], zn[1:])
+        yn1, xn1, zn1 = np.meshgrid(yn[0:-1], xn[0:-1], zn[0:-1])
+
+        Yn = P.T*np.c_[mkvc(yn1), mkvc(yn2)]
+        Xn = P.T*np.c_[mkvc(xn1), mkvc(xn2)]
+        Zn = P.T*np.c_[mkvc(zn1), mkvc(zn2)]
+
+        rxLoc = self.survey.srcField.rxList[0].locs
+        ndata = rxLoc.shape[0]
+
+        # Pre-allocate space and create magnetization matrix if required
+        # Pre-allocate space
+        if flag == 'z':
+
+            G = np.zeros((ndata, nC))
+
+        elif flag == 'xyz':
+
+            G = np.zeros((int(3*ndata), nC))
+
+        else:
+
+            print """Flag must be either 'z' | 'xyz', please revised"""
+            return
+
+
+        # Loop through all observations and create forward operator (ndata-by-nC)
+        print "Begin calculation of forward operator: " + flag
+
+        # Add counter to dsiplay progress. Good for large problems
+        count = -1;
+        for ii in range(ndata):
+
+            if flag=='z':
+                tt = get_T_mat(Xn, Yn, Zn, rxLoc[ii, :])
+                G[ii, :] = tt
+
+            elif flag == 'xyz':
+                print "Sorry 3-component not implemented yet"
+
+            # Display progress
+            count = progress(ii, count, ndata)
+
+        print "Done 100% ...forward operator completed!!\n"
+
+        return G
+
+
+def get_T_mat(Xn, Yn, Zn, rxLoc):
+    """
+    Load in the active nodes of a tensor mesh and computes the gravity tensor
+    for a given observation location rxLoc[obsx, obsy, obsz]
+
+    INPUT:
+    Xn, Yn, Zn: Node location matrix for the lower and upper most corners of
+                all cells in the mesh shape[nC,2]
+    M
+    OUTPUT:
+    Tx = [Txx Txy Txz]
+    Ty = [Tyx Tyy Tyz]
+    Tz = [Tzx Tzy Tzz]
+
+    where each elements have dimension 1-by-nC.
+    Only the upper half 5 elements have to be computed since symetric.
+    Currently done as for-loops but will eventually be changed to vector
+    indexing, once the topography has been figured out.
+
+    """
+    NewtG=6.6738e-3
+    eps = 1e-10 # add a small value to the locations to avoid /0
+
+    nC = Xn.shape[0]
+
+    # Pre-allocate space for 1D array
+    tx = np.zeros((1,nC))
+    ty = np.zeros((1,nC))
+    tz = np.zeros((1,nC))
+
+    dz = rxLoc[2] - Zn + eps
+
+    dy = Yn - rxLoc[1] + eps
+
+    dx = Xn - rxLoc[0] + eps
+
+    # Compute contribution from each corners
+    for aa in range(2):
+        for bb in range(2):
+            for cc in range(2):
+
+                r = (
+                        dx[:, aa] ** 2 +
+                        dy[:, bb] ** 2 +
+                        dz[:, cc] ** 2
+                    ) ** (0.50)
+
+                tx = tx - NewtG * (-1) ** aa * (-1) ** bb * (-1) ** cc * (
+                    dy[:, bb] * np.log(dz[:, cc] + r) +
+                    dz[:, cc] * np.log(dy[:, bb] + r) -
+                    dx[:, aa] * np.arctan(dy[:, bb] * dz[:, cc] / (dx[:, aa] * r)))
+
+                ty = ty - NewtG * (-1) ** aa * (-1) ** bb * (-1) ** cc * (
+                    dx[:, aa] * np.log(dz[:, cc] + r) +
+                    dz[:, cc] * np.log(dx[:, aa] + r) -
+                    dy[:, bb] * np.arctan(dx[:, aa] * dz[:, cc] / (dy[:, bb] * r)))
+
+                tz = tz - NewtG * (-1) ** aa * (-1) ** bb * (-1) ** cc * (
+                    dx[:, aa] * np.log(dy[:, bb] + r) +
+                    dy[:, bb] * np.log(dx[:, aa] + r) -
+                    dz[:, cc] * np.arctan(dx[:, aa] * dy[:, bb] / (dz[:, cc] * r)))
+
+    return tx,ty,tz
+
+
+def progress(iter, prog, final):
+    """
+    progress(iter,prog,final)
+
+    Function measuring the progress of a process and print to screen the %.
+    Useful to estimate the remaining runtime of a large problem.
+
+    Created on Dec, 20th 2015
+
+    @author: dominiquef
+    """
+    arg = np.floor(float(iter)/float(final)*10.)
+
+    if  arg > prog:
+
+        strg = "Done " + str(arg*10) + " %"
+        print strg
+        prog = arg
+
+    return prog
+
+
+def writeUBCobs(filename, survey, d):
+    """
+    writeUBCobs(filename,survey,d)
+
+    Function writing an observation file in UBC-GRAV3D format.
+
+    INPUT
+    filename    : Name of out file including directory
+    survey
+    flag          : dobs | dpred
+
+    OUTPUT
+    Obsfile
+
+    """
+
+    rxLoc = survey.srcField.rxList[0].locs
+
+    wd = survey.std
+
+    data = np.c_[rxLoc, d, wd]
+
+    with file(filename, 'w') as fid:
+        fid.write('%i\n' % len(d))
+        np.savetxt(fid, data, fmt='%e', delimiter=' ', newline='\n')
+
+    print "Observation file saved to: " + filename
+
+
+def getActiveTopo(mesh, topo, flag):
+    """
+    getActiveTopo(mesh,topo)
+
+    Function creates an active cell model from topography
+
+    INPUT
+    mesh        : Mesh in SimPEG format
+    topo        : Scatter points defining topography [x,y,z]
+
+    OUTPUT
+    actv        : Active cell model
+
+    """
+    import scipy.interpolate as interpolation
+
+    if flag == 'N':
+        Zn = np.zeros((mesh.nNx, mesh.nNy))
+        # wght    = np.zeros((mesh.nNx,mesh.nNy))
+        cx = mesh.vectorNx
+        cy = mesh.vectorNy
+
+    F = interpolation.NearestNDInterpolator(topo[:, 0:2], topo[:, 2])
+    [Y, X] = np.meshgrid(cy, cx)
+
+    Zn = F(X, Y)
+
+    actv = np.zeros((mesh.nCx, mesh.nCy, mesh.nCz))
+
+    if flag == 'N':
+        Nz = mesh.vectorNz[1:]
+
+    for jj in range(mesh.nCy):
+
+        for ii in range(mesh.nCx):
+
+            temp = [kk for kk in range(len(Nz)) if np.all(Zn[ii:(ii+2), jj:(jj+2)] > Nz[kk]) ]
+            actv[ii, jj, temp] = 1
+
+    actv = mkvc(actv == 1)
+
+    inds = np.asarray([inds for inds, elem in enumerate(actv, 1) if elem], dtype = int) - 1
+
+    return inds
+
+def plot_obs_2D(survey,varstr, fig = None):
+    """ Function plot_obs(rxLoc,d,wd)
+    Generate a 2d interpolated plot from scatter points of data
+
+    INPUT
+    rxLoc       : Observation locations [x,y,z]
+    d           : Data vector
+    wd          : Uncertainty vector
+
+    OUTPUT
+    figure()
+
+    Created on Dec, 27th 2015
+
+    @author: dominiquef
+
+    """
+
+    from scipy.interpolate import griddata
+    import pylab as plt
+
+    rxLoc   = survey.srcField.rxList[0].locs
+    d       = survey.dobs
+    wd      = survey.std
+
+    # Create grid of points
+    x = np.linspace(rxLoc[:,0].min(), rxLoc[:,0].max(), 100)
+    y = np.linspace(rxLoc[:,1].min(), rxLoc[:,1].max(), 100)
+
+    X, Y = np.meshgrid(x,y)
+
+    # Interpolate
+    d_grid = griddata(rxLoc[:,0:2],d,(X,Y), method ='linear')
+
+    # Plot result
+    if fig is None:
+        fig = plt.figure()
+
+    ax = plt.subplot()
+    plt.imshow(d_grid, extent=[x.min(), x.max(), y.min(), y.max()],origin = 'lower', cmap='plasma')
+    plt.colorbar(fraction=0.02)
+    plt.contour(X,Y, d_grid,10)
+    plt.scatter(rxLoc[:,0],rxLoc[:,1], c=d, s=20)
+    plt.title(varstr)
+    plt.gca().set_aspect('equal', adjustable='box')
+
+def readUBCgravObs(obs_file):
+
+    """
+    Read UBC grav file format
+
+    INPUT:
+    :param fileName, path to the UBC obs grav file
+
+    OUTPUT:
+    :param survey
+
+    """
+
+    fid = open(obs_file,'r')
+
+    # First line has the number of rows
+    line = fid.readline()
+    ndat = np.array(line.split(),dtype=int)
+
+    # Pre-allocate space for obsx, obsy, obsz, data, uncert
+    line = fid.readline()
+    temp = np.array(line.split(),dtype=float)
+
+    d  = np.zeros(ndat, dtype=float)
+    wd = np.zeros(ndat, dtype=float)
+    locXYZ = np.zeros( (ndat,3), dtype=float)
+
+    for ii in range(ndat):
+
+        temp = np.array(line.split(),dtype=float)
+        locXYZ[ii,:] = temp[:3]
+        d[ii] = temp[3]
+        wd[ii] = temp[4]
+        line = fid.readline()
+
+    rxLoc = GRAV.RxObs(locXYZ)
+    srcField = GRAV.SrcField([rxLoc])
+    survey = GRAV.LinearSurvey(srcField)
+    survey.dobs =  d
+    survey.std =  wd
+    return survey
+
+
+def read_GRAVinv_inp(input_file):
+    """Read input files for forward modeling MAG data with integral form
+    INPUT:
+    input_file: File name containing the forward parameter
+
+    OUTPUT:
+    mshfile
+    obsfile
+    topofile
+    start model
+    ref model
+    weightfile
+    chi_target
+    as, ax ,ay, az
+    upper, lower bounds
+    lp, lqx, lqy, lqz
+
+    # All files should be in the working directory, otherwise the path must
+    # be specified.
+
+    Created on Dec 21th, 2015
+
+    @author: dominiquef
+    """
+
+
+    fid = open(input_file,'r')
+
+    # Line 1
+    line = fid.readline()
+    l_input  = line.split('!')
+    mshfile = l_input[0].rstrip()
+
+    # Line 2
+    line = fid.readline()
+    l_input  = line.split('!')
+    obsfile = l_input[0].rstrip()
+
+    # Line 3
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    if l_input=='null':
+        topofile = []
+
+    else:
+        topofile = l_input[0].rstrip()
+
+
+    # Line 4
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    if l_input[0]=='VALUE':
+        mstart = float(l_input[1])
+
+    else:
+        mstart = l_input[0].rstrip()
+
+    # Line 5
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    if l_input[0]=='VALUE':
+        mref = float(l_input[1])
+
+    else:
+        mref = l_input[0].rstrip()
+
+
+    # Line 7
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    if l_input[0]=='DEFAULT':
+        wgtfile = None
+
+    else:
+        wgtfile = l_input[0].rstrip()
+
+    # Line 8
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    chi = float(l_input[0])
+
+    # Line 9
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    val = np.array(l_input[0:4])
+    alphas = val.astype(np.float)
+
+    # Line 10
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    if l_input[0]=='VALUE':
+        val   = np.array(l_input[1:3])
+        bounds = val.astype(np.float)
+
+    else:
+        bounds = l_input[0].rstrip()
+
+    # Line 11
+    line = fid.readline()
+    l_input = re.split('[!\s]',line)
+    if l_input[0]=='VALUE':
+        val   = np.array(l_input[1:6])
+        lpnorms = val.astype(np.float)
+
+    else:
+        lpnorms = l_input[0].rstrip()
+
+    return mshfile, obsfile, topofile, mstart, mref, wgtfile, chi, alphas, bounds, lpnorms
+

SimPEG/PF/GravityDriver.py

@@ -0,0 +1,295 @@
+import re, os
+from SimPEG import Mesh, np, Utils
+import BaseGrav, Gravity
+
+
+class GravityDriver_Inv(object):
+    """docstring for GravityDriver_Inv"""
+
+    def __init__(self, input_file=None):
+        if input_file is not None:
+            self.basePath = os.path.sep.join(input_file.split(os.path.sep)[:-1])
+            if len(self.basePath) > 0:
+                self.basePath += os.path.sep
+            self.readDriverFile(input_file.split(os.path.sep)[-1])
+
+    def readDriverFile(self, input_file):
+        """
+            Read input files for forward modeling GRAV data with integral form
+            INPUT:
+            input_file: File name containing the forward parameter
+
+            OUTPUT:
+            mshfile
+            obsfile
+            topofile
+            start model
+            ref model
+            active cells model
+            weightfile
+            chi_target
+            as, ax ,ay, az
+            upper, lower bounds
+            lp, lqx, lqy, lqz
+            eps_p, eps_q
+            # All files should be in the working directory, otherwise the path must
+            # be specified.
+
+        """
+
+        fid = open(self.basePath + input_file, 'r')
+
+        # Line 1
+        line = fid.readline()
+        l_input  = line.split('!')
+        mshfile = l_input[0].rstrip()
+
+        # Line 2
+        line = fid.readline()
+        l_input  = line.split('!')
+        obsfile = l_input[0].rstrip()
+
+        # Line 3
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input=='null':
+            topofile = []
+
+        else:
+            topofile = l_input[0].rstrip()
+
+
+        # Line 4
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input[0]=='VALUE':
+            mstart = float(l_input[1])
+
+        else:
+            mstart = l_input[0].rstrip()
+
+        # Line 5
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            mref = float(l_input[1])
+
+        else:
+            mref = l_input[0].rstrip()
+
+        # Line 6
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input[0]=='VALUE':
+            staticInput = float(l_input[1])
+
+        elif l_input[0]=='DEFAULT':
+            staticInput = None
+
+        else:
+            staticInput = l_input[0].rstrip()
+
+        # Line 7
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input=='DEFAULT':
+            wgtfile = []
+
+        else:
+            wgtfile = l_input[0].rstrip()
+
+        # Line 8
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        chi = float(l_input[0])
+
+        # Line 9
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        val = np.array(l_input[0:4])
+        alphas = val.astype(np.float)
+
+        # Line 10
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input[0]=='VALUE':
+            val   = np.array(l_input[1:3])
+            bounds = val.astype(np.float)
+
+        else:
+            bounds = l_input[0].rstrip()
+
+        # Line 11
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input[0]=='VALUE':
+            val   = np.array(l_input[1:6])
+            lpnorms = val.astype(np.float)
+
+        else:
+            lpnorms = l_input[0].rstrip()
+
+        # Line 12
+        line = fid.readline()
+        l_input = re.split('[!\s]', line)
+        if l_input[0]=='VALUE':
+            val   = np.array(l_input[1:3])
+            eps = val.astype(np.float)
+
+        else:
+            eps = [None, None]
+
+        self.mshfile  = mshfile
+        self.obsfile  = obsfile
+        self.topofile = topofile
+        self.mstart   = mstart
+        self._mrefInput = mref
+        self._staticInput = staticInput
+        self.wgtfile  = wgtfile
+        self.chi      = chi
+        self.alphas   = alphas
+        self.bounds   = bounds
+        self.lpnorms  = lpnorms
+        self.eps      = eps
+
+    @property
+    def mesh(self):
+        if getattr(self, '_mesh', None) is None:
+            self._mesh = Mesh.TensorMesh.readUBC(self.basePath + self.mshfile)
+        return self._mesh
+
+    @property
+    def survey(self):
+        if getattr(self, '_survey', None) is None:
+            self._survey = self.readGravityObservations(self.basePath + self.obsfile)
+        return self._survey
+
+    @property
+    def activeCells(self):
+        if getattr(self, '_activeCells', None) is None:
+            if self.topofile == 'null':
+                self._activeCells = np.arange(mesh.nC)
+            else:
+                topo = np.genfromtxt(self.basePath + self.topofile, skip_header=1)
+                # Find the active cells
+                active = Utils.surface2ind_topo(self.mesh,topo,'N')
+                inds = np.asarray([inds for inds, elem in enumerate(active, 1) if elem], dtype = int) - 1
+                self._activeCells = inds
+
+        return self._activeCells
+
+    @property
+    def staticCells(self):
+        if getattr(self, '_staticCells', None) is None:
+
+            if getattr(self, '_staticInput', None) is None:
+                # All cells are dynamic: 1's
+                self._dynamicCells = np.arange(len(self.m0))
+                self._staticCells = []
+
+            # Cells with specific value are static: 0's
+            else:
+                if isinstance(self._staticInput, float):
+                    staticCells = self.m0 == self._staticInput
+
+                else:
+                    # Read from file active cells with 0:air, 1:dynamic, -1 static
+                    staticCells = Mesh.TensorMesh.readModelUBC(self.mesh, self.basePath + self._staticInput)
+                    staticCells = staticCells[self.activeCells] == -1
+
+                inds = np.asarray([inds for inds, elem in enumerate(staticCells, 1) if elem], dtype = int) - 1
+                self._staticCells = inds
+
+        return self._staticCells
+
+    @property
+    def dynamicCells(self):
+        if getattr(self, '_dynamicCells', None) is None:
+
+            if getattr(self, '_staticInput', None) is None:
+                # All cells are dynamic: 1's
+                self._dynamicCells = np.arange(len(self.m0))
+
+            # Cells with specific value are static: 0's
+            else:
+                if isinstance(self._staticInput, float):
+                    dynamicCells = self.m0 != self._staticInput
+
+                else:
+                    # Read from file active cells with 0:air, 1:dynamic, -1 static
+                    dynamicCells = Mesh.TensorMesh.readModelUBC(self.mesh, self.basePath + self._staticInput)
+                    dynamicCells = dynamicCells[self.activeCells] == 1
+
+                inds = np.asarray([inds for inds, elem in enumerate(dynamicCells, 1) if elem], dtype = int) - 1
+                self._dynamicCells = inds
+
+        return self._dynamicCells
+
+    @property
+    def nC(self):
+        if getattr(self, '_nC', None) is None:
+            self._nC = len(self.activeCells)
+        return self._nC
+
+    @property
+    def m0(self):
+        if getattr(self, '_m0', None) is None:
+            if isinstance(self.mstart, float):
+                self._m0 = np.ones(self.nC) * self.mstart
+            else:
+
+                self._m0 = Mesh.TensorMesh.readModelUBC(self.mesh, self.basePath + self.mstart)
+                self._m0 = self._m0[self.activeCells]
+
+        return self._m0
+
+    @property
+    def mref(self):
+        if getattr(self, '_mref', None) is None:
+            if isinstance(self._mrefInput, float):
+                self._mref = np.ones(self.nC) * self._mrefInput
+            else:
+                self._mref = Mesh.TensorMesh.readModelUBC(self.mesh, self.basePath + self._mrefInput)
+                self._mref = self._mref[self.activeCells]
+        return self._mref
+
+    def readGravityObservations(self, obs_file):
+        """
+        Read UBC grav file format
+
+        INPUT:
+        :param fileName, path to the UBC obs grav file
+
+        OUTPUT:
+        :param survey
+
+        """
+
+        fid = open(obs_file,'r')
+
+        # First line has the number of rows
+        line = fid.readline()
+        ndat = np.array(line.split(),dtype=int)
+
+        # Pre-allocate space for obsx, obsy, obsz, data, uncert
+        line = fid.readline()
+        temp = np.array(line.split(),dtype=float)
+
+        d  = np.zeros(ndat, dtype=float)
+        wd = np.zeros(ndat, dtype=float)
+        locXYZ = np.zeros( (ndat,3), dtype=float)
+
+        for ii in range(ndat):
+
+            temp = np.array(line.split(),dtype=float)
+            locXYZ[ii,:] = temp[:3]
+            d[ii] = temp[3]
+            wd[ii] = temp[4]
+            line = fid.readline()
+
+        rxLoc = BaseGrav.RxObs(locXYZ)
+        srcField = BaseGrav.SrcField([rxLoc])
+        survey = BaseGrav.LinearSurvey(srcField)
+        survey.dobs =  d
+        survey.std =  wd
+        return survey

SimPEG/PF/MagAnalytics.py

@@ -0,0 +1,278 @@
+from scipy.constants import mu_0
+from SimPEG import *
+from SimPEG.Utils import kron3, speye, sdiag
+import matplotlib.pyplot as plt
+
+
+def spheremodel(mesh, x0, y0, z0, r):
+    """
+        Generate model indicies for sphere
+        - (x0, y0, z0 ): is the center location of sphere
+        - r: is the radius of the sphere
+        - it returns logical indicies of cell-center model
+    """
+    ind = np.sqrt( (mesh.gridCC[:,0]-x0)**2+(mesh.gridCC[:,1]-y0)**2+(mesh.gridCC[:,2]-z0)**2 ) < r
+    return ind
+
+
+def MagSphereAnaFun(x, y, z, R, x0, y0, z0, mu1, mu2, H0, flag='total'):
+    """
+        test
+        Analytic function for Magnetics problem. The set up here is
+        magnetic sphere in whole-space assuming that the inducing field is oriented in the x-direction.
+
+        * (x0,y0,z0)
+        * (x0, y0, z0 ): is the center location of sphere
+        * r: is the radius of the sphere
+
+    .. math::
+
+        \mathbf{H}_0 = H_0\hat{x}
+
+
+    """
+
+    if (~np.size(x)==np.size(y)==np.size(z)):
+        print "Specify same size of x, y, z"
+        return
+    dim = x.shape
+    x = Utils.mkvc(x)
+    y = Utils.mkvc(y)
+    z = Utils.mkvc(z)
+
+    ind = np.sqrt((x-x0)**2+(y-y0)**2+(z-z0)**2 ) < R
+    r = Utils.mkvc(np.sqrt((x-x0)**2+(y-y0)**2+(z-z0)**2 ))
+    Bx = np.zeros(x.size)
+    By = np.zeros(x.size)
+    Bz = np.zeros(x.size)
+
+    # Inside of the sphere
+    rf2 = 3*mu1/(mu2+2*mu1)
+    if flag is 'total' and any(ind):
+        Bx[ind] = mu2*H0*(rf2)
+    elif (flag == 'secondary'):
+        Bx[ind] = mu2*H0*(rf2)-mu1*H0
+
+    By[ind] = 0.
+    Bz[ind] = 0.
+    # Outside of the sphere
+    rf1 = (mu2-mu1)/(mu2+2*mu1)
+    if (flag == 'total'):
+        Bx[~ind] = mu1*(H0+H0/r[~ind]**5*(R**3)*rf1*(2*(x[~ind]-x0)**2-(y[~ind]-y0)**2-(z[~ind]-z0)**2))
+    elif (flag == 'secondary'):
+        Bx[~ind] = mu1*(H0/r[~ind]**5*(R**3)*rf1*(2*(x[~ind]-x0)**2-(y[~ind]-y0)**2-(z[~ind]-z0)**2))
+
+    By[~ind] = mu1*(H0/r[~ind]**5*(R**3)*rf1*(3*(x[~ind]-x0)*(y[~ind]-y0)))
+    Bz[~ind] = mu1*(H0/r[~ind]**5*(R**3)*rf1*(3*(x[~ind]-x0)*(z[~ind]-z0)))
+    return np.reshape(Bx, x.shape, order='F'), np.reshape(By, x.shape, order='F'), np.reshape(Bz, x.shape, order='F')
+
+
+def CongruousMagBC(mesh, Bo, chi):
+    """
+        Computing boundary condition using Congrous sphere method.
+        This is designed for secondary field formulation.
+
+        >> Input
+
+        * mesh:   Mesh class
+        * Bo:     np.array([Box, Boy, Boz]): Primary magnetic flux
+        * chi:    susceptibility at cell volume
+
+        .. math::
+
+            \\vec{B}(r) = \\frac{\mu_0}{4\pi} \\frac{m}{ \| \\vec{r} - \\vec{r}_0\|^3}[3\hat{m}\cdot\hat{r}-\hat{m}]
+
+    """
+
+    ind = chi > 0.
+    V = mesh.vol[ind].sum()
+
+    gamma = 1/V*(chi*mesh.vol).sum() # like a mass!
+
+    Bot = np.sqrt(sum(Bo**2))
+    mx = Bo[0]/Bot
+    my = Bo[1]/Bot
+    mz = Bo[2]/Bot
+
+    mom = 1/mu_0*Bot*gamma*V/(1+gamma/3)
+    xc = sum(chi[ind]*mesh.gridCC[:,0][ind])/sum(chi[ind])
+    yc = sum(chi[ind]*mesh.gridCC[:,1][ind])/sum(chi[ind])
+    zc = sum(chi[ind]*mesh.gridCC[:,2][ind])/sum(chi[ind])
+
+    indxd, indxu, indyd, indyu, indzd, indzu =  mesh.faceBoundaryInd
+
+    const = mu_0/(4*np.pi)*mom
+    rfun = lambda x: np.sqrt((x[:,0]-xc)**2 + (x[:,1]-yc)**2 + (x[:,2]-zc)**2)
+
+    mdotrx = (mx*(mesh.gridFx[(indxd|indxu),0]-xc)/rfun(mesh.gridFx[(indxd|indxu),:]) +
+              my*(mesh.gridFx[(indxd|indxu),1]-yc)/rfun(mesh.gridFx[(indxd|indxu),:]) +
+              mz*(mesh.gridFx[(indxd|indxu),2]-zc)/rfun(mesh.gridFx[(indxd|indxu),:]))
+
+    Bbcx = const/(rfun(mesh.gridFx[(indxd|indxu),:])**3)*(3*mdotrx*(mesh.gridFx[(indxd|indxu),0]-xc)/rfun(mesh.gridFx[(indxd|indxu),:])-mx)
+
+    mdotry = (mx*(mesh.gridFy[(indyd|indyu),0]-xc)/rfun(mesh.gridFy[(indyd|indyu),:]) +
+              my*(mesh.gridFy[(indyd|indyu),1]-yc)/rfun(mesh.gridFy[(indyd|indyu),:]) +
+              mz*(mesh.gridFy[(indyd|indyu),2]-zc)/rfun(mesh.gridFy[(indyd|indyu),:]))
+
+    Bbcy = const/(rfun(mesh.gridFy[(indyd|indyu),:])**3)*(3*mdotry*(mesh.gridFy[(indyd|indyu),1]-yc)/rfun(mesh.gridFy[(indyd|indyu),:])-my)
+
+    mdotrz = (mx*(mesh.gridFz[(indzd|indzu),0]-xc)/rfun(mesh.gridFz[(indzd|indzu),:])  +
+              my*(mesh.gridFz[(indzd|indzu),1]-yc)/rfun(mesh.gridFz[(indzd|indzu),:]) +
+              mz*(mesh.gridFz[(indzd|indzu),2]-zc)/rfun(mesh.gridFz[(indzd|indzu),:]))
+
+    Bbcz = const/(rfun(mesh.gridFz[(indzd|indzu),:])**3)*(3*mdotrz*(mesh.gridFz[(indzd|indzu),2]-zc)/rfun(mesh.gridFz[(indzd|indzu),:])-mz)
+
+    return np.r_[Bbcx, Bbcy, Bbcz], (1/gamma-1/(3+gamma))*1/V
+
+
+def MagSphereAnaFunA(x, y, z, R, xc, yc, zc, chi, Bo, flag):
+    """
+        Computing boundary condition using Congrous sphere method.
+        This is designed for secondary field formulation.
+        >> Input
+        mesh:   Mesh class
+        Bo:     np.array([Box, Boy, Boz]): Primary magnetic flux
+        Chi:    susceptibility at cell volume
+
+        .. math::
+
+            \\vec{B}(r) = \\frac{\mu_0}{4\pi}\\frac{m}{\| \\vec{r}-\\vec{r}_0\|^3}[3\hat{m}\cdot\hat{r}-\hat{m}]
+
+    """
+    if (~np.size(x)==np.size(y)==np.size(z)):
+        print "Specify same size of x, y, z"
+        return
+    dim = x.shape
+    x = Utils.mkvc(x)
+    y = Utils.mkvc(y)
+    z = Utils.mkvc(z)
+
+    Bot = np.sqrt(sum(Bo**2))
+    mx = Bo[0]/Bot
+    my = Bo[1]/Bot
+    mz = Bo[2]/Bot
+
+    ind = np.sqrt((x-xc)**2+(y-yc)**2+(z-zc)**2 ) < R
+
+    Bx = np.zeros(x.size)
+    By = np.zeros(x.size)
+    Bz = np.zeros(x.size)
+
+    # Inside of the sphere
+    rf2 = 3/(chi+3)*(1+chi)
+    if (flag == 'total'):
+        Bx[ind] = Bo[0]*(rf2)
+        By[ind] = Bo[1]*(rf2)
+        Bz[ind] = Bo[2]*(rf2)
+    elif (flag == 'secondary'):
+        Bx[ind] = Bo[0]*(rf2)-Bo[0]
+        By[ind] = Bo[1]*(rf2)-Bo[1]
+        Bz[ind] = Bo[2]*(rf2)-Bo[2]
+
+    r = Utils.mkvc(np.sqrt((x-xc)**2+(y-yc)**2+(z-zc)**2 ))
+    V = 4*np.pi*R**3/3
+    mom = Bot/mu_0*chi/(1+chi/3)*V
+    const = mu_0/(4*np.pi)*mom
+    mdotr = (mx*(x[~ind]-xc)/r[~ind] + my*(y[~ind]-yc)/r[~ind] + mz*(z[~ind]-zc)/r[~ind])
+    Bx[~ind] = const/(r[~ind]**3)*(3*mdotr*(x[~ind]-xc)/r[~ind]-mx)
+    By[~ind] = const/(r[~ind]**3)*(3*mdotr*(y[~ind]-yc)/r[~ind]-my)
+    Bz[~ind] = const/(r[~ind]**3)*(3*mdotr*(z[~ind]-zc)/r[~ind]-mz)
+
+
+    return Bx, By, Bz
+
+
+def IDTtoxyz(Inc, Dec, Btot):
+    """
+        Convert from Inclination, Declination, Total  intensity of earth field to x, y, z
+    """
+    Bx = Btot*np.cos(Inc/180.*np.pi)*np.sin(Dec/180.*np.pi)
+    By = Btot*np.cos(Inc/180.*np.pi)*np.cos(Dec/180.*np.pi)
+    Bz = -Btot*np.sin(Inc/180.*np.pi)
+
+    return np.r_[Bx, By, Bz]
+
+
+def MagSphereFreeSpace(x, y, z, R, xc, yc, zc, chi, Bo):
+    """
+        Computing boundary condition using Congrous sphere method.
+        This is designed for secondary field formulation.
+        >> Input
+        mesh:   Mesh class
+        Bo:     np.array([Box, Boy, Boz]): Primary magnetic flux
+        Chi:    susceptibility at cell volume
+
+        .. math::
+
+            \\vec{B}(r) = \\frac{\mu_0}{4\pi}\\frac{m}{\| \\vec{r}-\\vec{r}_0\|^3}[3\hat{m}\cdot\hat{r}-\hat{m}]
+
+    """
+    if (~np.size(x)==np.size(y)==np.size(z)):
+        print "Specify same size of x, y, z"
+        return
+
+    x = Utils.mkvc(x)
+    y = Utils.mkvc(y)
+    z = Utils.mkvc(z)
+
+    nobs = len(x)
+
+    Bot = np.sqrt(sum(Bo**2))
+
+    mx = np.ones([nobs]) * Bo[0,0] *  R**3 / 3. * chi
+    my = np.ones([nobs]) * Bo[0,1] *  R**3 / 3. * chi
+    mz = np.ones([nobs]) * Bo[0,2] *  R**3 / 3. * chi
+
+    M = np.c_[mx, my, mz]
+
+    rx = (x - xc)
+    ry = (y - yc)
+    rz = (zc - z)
+
+    rvec = np.c_[rx, ry, rz]
+    r = np.sqrt((rx)**2+(ry)**2+(rz)**2 )
+
+    B = -Utils.sdiag(1./r**3)*M + Utils.sdiag((3 * np.sum(M*rvec,axis=1))/r**5)*rvec
+
+    Bx = B[:,0]
+    By = B[:,1]
+    Bz = B[:,2]
+
+    return Bx, By, Bz
+
+if __name__ == '__main__':
+
+    hxind = [(0,25,1.3),(21, 12.5),(0,25,1.3)]
+    hyind = [(0,25,1.3),(21, 12.5),(0,25,1.3)]
+    hzind = [(0,25,1.3),(20, 12.5),(0,25,1.3)]
+    # hx, hy, hz = Utils.meshTensors(hxind, hyind, hzind)
+    M3 = Mesh.TensorMesh([hxind, hyind, hzind], "CCC")
+    indxd, indxu, indyd, indyu, indzd, indzu = M3.faceBoundaryInd
+    mu0 = 4*np.pi*1e-7
+    chibkg = 0.
+    chiblk = 0.01
+    chi = np.ones(M3.nC)*chibkg
+    sph_ind = spheremodel(M3, 0, 0, 0, 100)
+    chi[sph_ind] = chiblk
+    mu = (1.+chi)*mu0
+    Bbc, const = CongruousMagBC(M3, np.array([1., 0., 0.]), chi)
+
+    flag = 'secondary'
+    Box = 1.
+    H0 = Box/mu_0
+    Bbcxx, Bbcxy, Bbcxz  = MagSphereAnaFun(M3.gridFx[(indxd|indxu),0], M3.gridFx[(indxd|indxu),1], M3.gridFx[(indxd|indxu),2], 100, 0., 0., 0., mu_0, mu_0*(1+chiblk), H0, flag)
+    Bbcyx, Bbcyy, Bbcyz  = MagSphereAnaFun(M3.gridFy[(indyd|indyu),0], M3.gridFy[(indyd|indyu),1], M3.gridFy[(indyd|indyu),2], 100, 0., 0., 0., mu_0, mu_0*(1+chiblk), H0, flag)
+    Bbczx, Bbczy, Bbczz  = MagSphereAnaFun(M3.gridFz[(indzd|indzu),0], M3.gridFz[(indzd|indzu),1], M3.gridFz[(indzd|indzu),2], 100, 0., 0., 0., mu_0, mu_0*(1+chiblk), H0, flag)
+    Bbc_ana = np.r_[Bbcxx, Bbcyy, Bbczz]
+
+    # fig, ax = plt.subplots(1,1, figsize = (10, 10))
+    # ax.plot(Bbc_ana)
+    # ax.plot(Bbc)
+    # plt.show()
+    err = np.linalg.norm(Bbc-Bbc_ana)/np.linalg.norm(Bbc_ana)
+
+    if err < 0.1:
+        print 'Mag Boundary computation is valid, err = ', err
+    else:
+        print 'Mag Boundary computation is wrong!!, err = ', err
+    pass

SimPEG/PF/MagneticsDriver.py

@@ -0,0 +1,334 @@
+import re, os
+from SimPEG import Mesh, np, Utils
+import BaseMag, Magnetics
+
+class MagneticsDriver_Inv(object):
+    """docstring for MagneticsDriver_Inv"""
+
+    def __init__(self, input_file=None):
+        if input_file is not None:
+            self.basePath = os.path.sep.join(input_file.split(os.path.sep)[:-1])
+            if len(self.basePath) > 0:
+                self.basePath += os.path.sep
+            self.readDriverFile(input_file.split(os.path.sep)[-1])
+
+
+    def readDriverFile(self, input_file):
+        """
+            Read input files for forward modeling MAG data with integral form
+            INPUT:
+            input_file: File name containing the forward parameter
+
+            OUTPUT:
+            mshfile
+            obsfile
+            topofile
+            start model
+            ref model
+            mag model
+            weightfile
+            chi_target
+            as, ax ,ay, az
+            upper, lower bounds
+            lp, lqx, lqy, lqz
+
+            # All files should be in the working directory, otherwise the path must
+            # be specified.
+
+        """
+
+
+        fid = open(self.basePath + input_file,'r')
+
+        # Line 1
+        line = fid.readline()
+        l_input  = line.split('!')
+        mshfile = l_input[0].rstrip()
+
+        # Line 2
+        line = fid.readline()
+        l_input  = line.split('!')
+        obsfile = l_input[0].rstrip()
+
+        # Line 3
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input=='null':
+            topofile = []
+
+        else:
+            topofile = l_input[0].rstrip()
+
+
+        # Line 4
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            mstart = float(l_input[1])
+
+        else:
+            mstart = l_input[0].rstrip()
+
+        # Line 5
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            mref = float(l_input[1])
+
+        else:
+            mref = l_input[0].rstrip()
+
+        # Line 6
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            staticInput = float(l_input[1])
+
+        elif l_input[0]=='DEFAULT':
+            staticInput = None
+
+        else:
+            staticInput = l_input[0].rstrip()
+
+
+        # Line 7
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input=='DEFAULT':
+            magfile = []
+
+        else:
+            magfile = l_input[0].rstrip()
+
+        # Line 8
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input=='DEFAULT':
+            wgtfile = []
+
+        else:
+            wgtfile = l_input[0].rstrip()
+
+        # Line 9
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        chi = float(l_input[0])
+
+        # Line 10
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        val = np.array(l_input[0:4])
+        alphas = val.astype(np.float)
+
+        # Line 11
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            val   = np.array(l_input[1:3])
+            bounds = val.astype(np.float)
+
+        else:
+            bounds = l_input[0].rstrip()
+
+        # Line 12
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            val   = np.array(l_input[1:6])
+            lpnorms = val.astype(np.float)
+
+        else:
+            lpnorms = l_input[0].rstrip()
+
+        # Line 13
+        line = fid.readline()
+        l_input = re.split('[!\s]',line)
+        if l_input[0]=='VALUE':
+            val   = np.array(l_input[1:3])
+            eps = val.astype(np.float)
+
+        else:
+            eps = [None,None]
+
+        self.mshfile  = mshfile
+        self.obsfile  = obsfile
+        self.topofile = topofile
+        self.mstart   = mstart
+        self._mrefInput = mref
+        self._staticInput = staticInput
+        self.magfile  = magfile
+        self.wgtfile  = wgtfile
+        self.chi      = chi
+        self.alphas   = alphas
+        self.bounds   = bounds
+        self.lpnorms  = lpnorms
+        self.eps      = eps
+
+    @property
+    def mesh(self):
+        if getattr(self, '_mesh', None) is None:
+            self._mesh = Mesh.TensorMesh.readUBC(self.basePath + self.mshfile)
+        return self._mesh
+
+    @property
+    def survey(self):
+        if getattr(self, '_survey', None) is None:
+            self._survey = self.readMagneticsObservations(self.obsfile)
+        return self._survey
+
+    @property
+    def activeCells(self):
+        if getattr(self, '_activeCells', None) is None:
+            if self.topofile == 'null':
+                self._activeCells = np.arange(self.mesh.nC)
+            else:
+                topo = np.genfromtxt(self.basePath + self.topofile, skip_header=1)
+                # Find the active cells
+                active = Utils.surface2ind_topo(self.mesh,topo,'N')
+                inds = np.asarray([inds for inds, elem in enumerate(active, 1) if elem], dtype = int) - 1
+                self._activeCells = inds
+
+        return self._activeCells
+
+    @property
+    def staticCells(self):
+        if getattr(self, '_staticCells', None) is None:
+
+            if getattr(self, '_staticInput', None) is None:
+                # All cells are dynamic: 1's
+                self._dynamicCells = np.arange(len(self.m0))
+                self._staticCells = []
+
+            # Cells with specific value are static: 0's
+            else:
+                if isinstance(self._staticInput, float):
+                    staticCells = self.m0 == self._staticInput
+
+                else:
+                    # Read from file active cells with 0:air, 1:dynamic, -1 static
+                    staticCells = Mesh.TensorMesh.readModelUBC(self.mesh, self.basePath + self._staticInput)
+                    staticCells = staticCells[self.activeCells] == -1
+
+                inds = np.asarray([inds for inds, elem in enumerate(staticCells, 1) if elem], dtype = int) - 1
+                self._staticCells = inds
+
+        return self._staticCells
+
+    @property
+    def dynamicCells(self):
+        if getattr(self, '_dynamicCells', None) is None:
+
+            if getattr(self, '_staticInput', None) is None:
+                # All cells are dynamic: 1's
+                self._dynamicCells = np.arange(len(self.m0))
+
+            # Cells with specific value are static: 0's
+            else:
+                if isinstance(self._staticInput, float):
+                    dynamicCells = self.m0 != self._staticInput
+
+                else:
+                    # Read from file active cells with 0:air, 1:dynamic, -1 static
+                    dynamicCells = Mesh.TensorMesh.readModelUBC(self.mesh, self.basePath + self._staticInput)
+                    dynamicCells = dynamicCells[self.activeCells] == 1
+
+                inds = np.asarray([inds for inds, elem in enumerate(dynamicCells, 1) if elem], dtype = int) - 1
+                self._dynamicCells = inds
+
+        return self._dynamicCells
+
+    @property
+    def nC(self):
+        if getattr(self, '_nC', None) is None:
+            self._nC = len(self.activeCells)
+        return self._nC
+
+    @property
+    def m0(self):
+        if getattr(self, '_m0', None) is None:
+            if isinstance(self.mstart, float):
+                self._m0 = np.ones(self.nC) * self.mstart
+            else:
+                self._m0 = Mesh.TensorMesh.readModelUBC(self.mesh,self.basePath + self.mstart)
+                self._m0 = self._m0[self.activeCells]
+
+        return self._m0
+
+    @property
+    def mref(self):
+        if getattr(self, '_mref', None) is None:
+            if isinstance(self._mrefInput, float):
+                self._mref = np.ones(self.nC) * self._mrefInput
+            else:
+                self._mref = Mesh.TensorMesh.readModelUBC(self.mesh,self.basePath + self._mrefInput)
+                self._mref = self._mref[self.activeCells]
+        return self._mref
+
+
+    @property
+    def magnetizationModel(self):
+        """
+            magnetization vector
+        """
+
+        if self.magfile == 'DEFAULT':
+            return Magnetics.dipazm_2_xyz(np.ones(self.nC) * self.survey.srcField.param[1], np.ones(self.nC) * self.survey.srcField.param[2])
+
+        else:
+            raise NotImplementedError("this will require you to read in a three column vector model")
+            self._mref = Utils.meshutils.readUBCTensorModel(self.basePath + self._mrefInput, self.mesh)
+            return np.genfromtxt(self.magfile,delimiter=' \n',dtype=np.str,comments='!')
+
+    def readMagneticsObservations(self, obs_file):
+        """
+            Read and write UBC mag file format
+
+            INPUT:
+            :param fileName, path to the UBC obs mag file
+
+            OUTPUT:
+            :param survey
+            :param M, magnetization orentiaton (MI, MD)
+        """
+
+        fid = open(self.basePath + obs_file,'r')
+
+        # First line has the inclination,declination and amplitude of B0
+        line = fid.readline()
+        B = np.array(line.split(),dtype=float)
+
+        # Second line has the magnetization orientation and a flag
+        line = fid.readline()
+        M = np.array(line.split(),dtype=float)
+
+        # Third line has the number of rows
+        line = fid.readline()
+        ndat = np.array(line.split(),dtype=int)
+
+        # Pre-allocate space for obsx, obsy, obsz, data, uncert
+        line = fid.readline()
+        temp = np.array(line.split(),dtype=float)
+
+        d  = np.zeros(ndat, dtype=float)
+        wd = np.zeros(ndat, dtype=float)
+        locXYZ = np.zeros( (ndat,3), dtype=float)
+
+        for ii in range(ndat):
+
+            temp = np.array(line.split(),dtype=float)
+            locXYZ[ii,:] = temp[:3]
+
+            if len(temp) > 3:
+                d[ii] = temp[3]
+
+                if len(temp)==5:
+                    wd[ii] = temp[4]
+
+            line = fid.readline()
+
+        rxLoc = BaseMag.RxObs(locXYZ)
+        srcField = BaseMag.SrcField([rxLoc],param=(B[2],B[0],B[1]))
+        survey = BaseMag.LinearSurvey(srcField)
+        survey.dobs =  d
+        survey.std =  wd
+        return survey

SimPEG/PF/__init__.py

@@ -0,0 +1,7 @@
+import MagAnalytics
+import BaseMag
+import Magnetics
+import BaseGrav
+import Gravity
+import MagneticsDriver
+import GravityDriver

SimPEG/PropMaps.py

@@ -74,7 +74,7 @@ class Property(object):
                 if linkedMap is None:
                     return None
                 linkMap = linkMapClass(None) * linkedMap
-                m = getattr(self, '%s'%linkName)
+                m = getattr(self, '%sModel'%linkName)
                 return linkMap.deriv( m )
 
             m = getattr(self, '%sModel'%prop.name)
@@ -187,7 +187,7 @@ class _PropMapMetaClass(type):
             attrs[attr + 'Model'] = prop._getModelProperty()
             attrs[attr + 'Deriv'] = prop._getModelDerivProperty()
 
-        return type(name.replace('PropMap', 'PropModel'), (PropModel, ), attrs)
+        return type('PropModel', (PropModel, ), attrs)
 
 
 class PropMap(object):
@@ -239,7 +239,7 @@ class PropMap(object):
             setattr(self, '%sMap'%name, mapping)
             setattr(self, '%sIndex'%name, slices.get(name, slice(nP, nP + mapping.nP)))
             nP += mapping.nP
-        self.nP = nP 
+        self.nP = nP
 
     @property
     def defaultInvProp(self):

SimPEG/Regularization.py

@@ -1,4 +1,6 @@
-import Utils, Maps, Mesh, numpy as np, scipy.sparse as sp
+import Utils, Maps, Mesh
+import numpy as np
+import scipy.sparse as sp
 
 class RegularizationMesh(object):
     """
@@ -8,7 +10,7 @@ class RegularizationMesh(object):
     are not necessarily true differential operators, but are constructed from
     a SimPEG Mesh.
 
-    :param Mesh mesh: problem mesh
+    :param BaseMesh mesh: problem mesh
     :param numpy.array indActive: bool array, size nC, that is True where we have active cells. Used to reduce the operators so we regularize only on active cells
     """
 
@@ -311,6 +313,9 @@ class BaseRegularization(object):
             tmp = indActive
             indActive = np.zeros(mesh.nC, dtype=bool)
             indActive[tmp] = True
+        if indActive is not None and mapping is None:
+            mapping = Maps.IdentityMap(nP=indActive.nonzero()[0].size)
+
         self.regmesh = RegularizationMesh(mesh,indActive)
         self.mapping = mapping or self.mapPair(mesh)
         self.mapping._assertMatchesPair(self.mapPair)
@@ -344,7 +349,6 @@ class BaseRegularization(object):
     def W(self):
         """Full regularization weighting matrix W."""
         return sp.identity(self.regmesh.nC)
-        # self.regmesh._Pac.T * sp.identity(self.regmesh.nC) * self.regmesh._Pac # or do we want sp.identity(self.mesh.nC) or even just Utils.Identity() ?
 
     @Utils.timeIt
     def eval(self, m):
@@ -375,11 +379,12 @@ class BaseRegularization(object):
     @Utils.timeIt
     def eval2Deriv(self, m, v=None):
         """
+        Second derivative
 
-            :param numpy.array m: geophysical model
-            :param numpy.array v: vector to multiply
-            :rtype: scipy.sparse.csr_matrix or numpy.ndarray
-            :return: WtW or WtW*v
+        :param numpy.array m: geophysical model
+        :param numpy.array v: vector to multiply
+        :rtype: scipy.sparse.csr_matrix
+        :return: WtW, or if v is supplied WtW*v (numpy.ndarray)
 
         The regularization is:
 
@@ -400,27 +405,281 @@ class BaseRegularization(object):
 
         return mD.T * ( self.W.T * ( self.W * ( mD * v) ) )
 
-class Tikhonov(BaseRegularization):
+class Simple(BaseRegularization):
     """
+    Simple regularization that does not include length scales in the derivatives.
     """
-    mrefInSmooth = True  #: SMOOTH and SMOOTH_MOD_DIF options
-    alpha_s  = Utils.dependentProperty('_alpha_s', 1e-6, ['_W', '_Ws'], "Smallness weight")
-    alpha_x  = Utils.dependentProperty('_alpha_x', 1.0, ['_W', '_Wx'], "Weight for the first derivative in the x direction")
-    alpha_y  = Utils.dependentProperty('_alpha_y', 1.0, ['_W', '_Wy'], "Weight for the first derivative in the y direction")
-    alpha_z  = Utils.dependentProperty('_alpha_z', 1.0, ['_W', '_Wz'], "Weight for the first derivative in the z direction")
-    alpha_xx = Utils.dependentProperty('_alpha_xx', 0.0, ['_W', '_Wxx'], "Weight for the second derivative in the x direction")
-    alpha_yy = Utils.dependentProperty('_alpha_yy', 0.0, ['_W', '_Wyy'], "Weight for the second derivative in the y direction")
-    alpha_zz = Utils.dependentProperty('_alpha_zz', 0.0, ['_W', '_Wzz'], "Weight for the second derivative in the z direction")
 
-    def __init__(self, mesh, mapping=None, indActive = None, **kwargs):
+    mrefInSmooth = False  #: include mref in the smoothness?
+    alpha_s      = Utils.dependentProperty('_alpha_s', 1.0, ['_W', '_Wsmall'], "Smallness weight")
+    alpha_x      = Utils.dependentProperty('_alpha_x', 1.0, ['_W', '_Wx'],     "Weight for the first derivative in the x direction")
+    alpha_y      = Utils.dependentProperty('_alpha_y', 1.0, ['_W', '_Wy'],     "Weight for the first derivative in the y direction")
+    alpha_z      = Utils.dependentProperty('_alpha_z', 1.0, ['_W', '_Wz'],     "Weight for the first derivative in the z direction")
+    cell_weights = 1.
+
+    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
+        BaseRegularization.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
+
+        if isinstance(self.cell_weights,float):
+            self.cell_weights = np.ones(self.regmesh.nC) * self.cell_weights
+
+    @property
+    def Wsmall(self):
+        """Regularization matrix Wsmall"""
+        if getattr(self,'_Wsmall', None) is None:
+            self._Wsmall = Utils.sdiag((self.alpha_s*self.cell_weights)**0.5)
+        return self._Wsmall
+
+    @property
+    def Wx(self):
+        """Regularization matrix Wx"""
+        if getattr(self, '_Wx', None) is None:
+            self._Wx = Utils.sdiag((self.alpha_x * (self.regmesh.aveCC2Fx*self.cell_weights))**0.5)*self.regmesh.cellDiffxStencil
+        return self._Wx
+
+    @property
+    def Wy(self):
+        """Regularization matrix Wy"""
+        if getattr(self, '_Wy', None) is None:
+            self._Wy = Utils.sdiag((self.alpha_y * (self.regmesh.aveCC2Fy*self.cell_weights))**0.5)*self.regmesh.cellDiffyStencil
+        return self._Wy
+
+    @property
+    def Wz(self):
+        """Regularization matrix Wz"""
+        if getattr(self, '_Wz', None) is None:
+            self._Wz = Utils.sdiag((self.alpha_z * (self.regmesh.aveCC2Fz*self.cell_weights))**0.5)*self.regmesh.cellDiffzStencil
+        return self._Wz
+
+#    @property
+#    def Wsmooth(self):
+#        """Full smoothness regularization matrix W"""
+#        print 'wtf why are we using Wsmooth'
+#        raise NotImplementedError
+#        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"""
+#        print 'wtf why are we using W'
+#        if getattr(self, '_W', None) is None:
+#            wlist = (self.Wsmall, self.Wx)
+#            if self.regmesh.dim > 1:
+#                wlist += (self.Wy,)
+#            if self.regmesh.dim > 2:
+#                wlist += (self.Wz,)
+#            self._W = sp.vstack(wlist)
+#        return self._W
+
+
+    @Utils.timeIt
+    def _evalSmall(self, m):
+        r = self.Wsmall * ( self.mapping * (m - self.mref) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmallDeriv(self, m):
+        r = self.Wsmall * ( self.mapping * (m - self.mref) )
+        return r.T * ( self.Wsmall * self.mapping.deriv(m - self.mref) )
+
+    @Utils.timeIt
+    def _evalSmall2Deriv(self, m, v = None):
+        rDeriv = self.Wsmall * ( self.mapping.deriv(m - self.mref) )
+        if v is not None:
+            return rDeriv.T * (rDeriv * v)
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothx(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wx * ( self.mapping * (m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wx * ( self.mapping * (m) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmoothy(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wy * ( self.mapping * (m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wy * ( self.mapping * (m) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmoothz(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wz * ( self.mapping * (m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wz * ( self.mapping * (m) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmooth(self, m):
+        phiSmooth = self._evalSmoothx(m)
+        if self.regmesh.dim > 1:
+            phiSmooth += self._evalSmoothy(m)
+        if self.regmesh.dim > 2:
+            phiSmooth += self._evalSmoothz(m)
+        return phiSmooth
+
+    @Utils.timeIt
+    def _evalSmoothxDeriv(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wx * ( self.mapping * ( m - self.mref ) )
+            return r.T * ( self.Wx * self.mapping.deriv(m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wx * ( self.mapping * m )
+            return r.T * ( self.Wx * self.mapping.deriv(m) )
+
+    @Utils.timeIt
+    def _evalSmoothx2Deriv(self, m, v=None):
+        if self.mrefInSmooth == True:
+            rDeriv = self.Wx * ( self.mapping.deriv( m - self.mref ) )
+        elif self.mrefInSmooth == False:
+            rDeriv = self.Wx * ( self.mapping.deriv(m) )
+
+        if v is not None:
+            return rDeriv.T * ( rDeriv * v )
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothyDeriv(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wy * ( self.mapping * ( m - self.mref ) )
+            return r.T * ( self.Wy * self.mapping.deriv(m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wy * ( self.mapping * m )
+            return r.T * ( self.Wy * self.mapping.deriv(m) )
+
+    @Utils.timeIt
+    def _evalSmoothy2Deriv(self, m, v=None):
+        if self.mrefInSmooth == True:
+            rDeriv = self.Wy * ( self.mapping.deriv( m - self.mref ) )
+        elif self.mrefInSmooth == False:
+            rDeriv = self.Wy * ( self.mapping.deriv(m) )
+
+        if v is not None:
+            return rDeriv.T * ( rDeriv * v )
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothzDeriv(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wz * ( self.mapping * ( m - self.mref ) )
+            return r.T * ( self.Wz * self.mapping.deriv(m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wz * ( self.mapping * m )
+            return r.T * ( self.Wz * self.mapping.deriv(m) )
+
+    @Utils.timeIt
+    def _evalSmoothz2Deriv(self, m, v=None):
+        if self.mrefInSmooth == True:
+            rDeriv = self.Wz * ( self.mapping.deriv( m - self.mref ) )
+        elif self.mrefInSmooth == False:
+            rDeriv = self.Wz * ( self.mapping.deriv(m) )
+
+        if v is not None:
+            return rDeriv.T * ( rDeriv * v )
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothDeriv(self, m):
+        deriv = self._evalSmoothxDeriv(m)
+        if self.regmesh.dim > 1:
+            deriv += self._evalSmoothyDeriv(m)
+        if self.regmesh.dim > 2:
+            deriv += self._evalSmoothzDeriv(m)
+        return deriv
+
+    @Utils.timeIt
+    def _evalSmooth2Deriv(self, m, v=None):
+        deriv = self._evalSmoothx2Deriv(m, v)
+        if self.regmesh.dim > 1:
+            deriv += self._evalSmoothy2Deriv(m, v)
+        if self.regmesh.dim > 2:
+            deriv += self._evalSmoothz2Deriv(m, v)
+        return deriv
+
+
+    @Utils.timeIt
+    def eval(self, m):
+        return self._evalSmall(m) + self._evalSmooth(m)
+
+    @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})}
+
+        """
+        return self._evalSmallDeriv(m) + self._evalSmoothDeriv(m)
+
+    @Utils.timeIt
+    def eval2Deriv(self, m, v=None):
+        return self._evalSmall2Deriv(m, v) + self._evalSmooth2Deriv(m, v)
+
+
+
+class Tikhonov(Simple):
+    """
+    L2 Tikhonov regularization with both smallness and smoothness (first order
+    derivative) contributions.
+
+    .. math::
+        \phi_m(\mathbf{m}) = \\alpha_s \| W_s (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
+        + \\alpha_x \| W_x \\frac{\partial}{\partial x} (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
+        + \\alpha_y \| W_y \\frac{\partial}{\partial y} (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
+        + \\alpha_z \| W_z \\frac{\partial}{\partial z} (\mathbf{m} - \mathbf{m_{ref}} ) \|^2
+
+    Note if the key word argument `mrefInSmooth` is False, then mref is not
+    included in the smoothness contribution.
+
+    :param BaseMesh mesh: SimPEG mesh
+    :param IdentityMap mapping: regularization mapping, takes the model from model space to the thing you want to regularize
+    :param numpy.ndarray indActive: active cell indices for reducing the size of differential operators in the definition of a regularization mesh
+    :param bool mrefInSmooth: (default = False) put mref in the smoothness component?
+    :param float alpha_s: (default 1e-6) smallness weight
+    :param float alpha_x: (default 1) smoothness weight for first derivative in the x-direction
+    :param float alpha_y: (default 1) smoothness weight for first derivative in the y-direction
+    :param float alpha_z: (default 1) smoothness weight for first derivative in the z-direction
+    :param float alpha_xx: (default 1) smoothness weight for second derivative in the x-direction
+    :param float alpha_yy: (default 1) smoothness weight for second derivative in the y-direction
+    :param float alpha_zz: (default 1) smoothness weight for second derivative in the z-direction
+    """
+    mrefInSmooth = False  # put mref in the smoothness contribution
+    alpha_s      = Utils.dependentProperty('_alpha_s', 1e-6, ['_W', '_Wsmall'], "Smallness weight")
+    alpha_x      = Utils.dependentProperty('_alpha_x',  1.0, ['_W', '_Wx'],     "Weight for the first derivative in the x direction")
+    alpha_y      = Utils.dependentProperty('_alpha_y',  1.0, ['_W', '_Wy'],     "Weight for the first derivative in the y direction")
+    alpha_z      = Utils.dependentProperty('_alpha_z',  1.0, ['_W', '_Wz'],     "Weight for the first derivative in the z direction")
+    alpha_xx     = Utils.dependentProperty('_alpha_xx', 0.0, ['_W', '_Wxx'],    "Weight for the second derivative in the x direction")
+    alpha_yy     = Utils.dependentProperty('_alpha_yy', 0.0, ['_W', '_Wyy'],    "Weight for the second derivative in the y direction")
+    alpha_zz     = Utils.dependentProperty('_alpha_zz', 0.0, ['_W', '_Wzz'],    "Weight for the second derivative in the z direction")
+
+    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
         BaseRegularization.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
 
     @property
-    def Ws(self):
-        """Regularization matrix Ws"""
-        if getattr(self,'_Ws', None) is None:
-            self._Ws = Utils.sdiag((self.regmesh.vol*self.alpha_s)**0.5)
-        return self._Ws
+    def Wsmall(self):
+        """Regularization matrix Wsmall"""
+        if getattr(self,'_Wsmall', None) is None:
+            self._Wsmall = Utils.sdiag((self.regmesh.vol*self.alpha_s)**0.5)
+        return self._Wsmall
 
     @property
     def Wx(self):
@@ -467,41 +726,135 @@ class Tikhonov(BaseRegularization):
             self._Wzz = Utils.sdiag((self.regmesh.vol*self.alpha_zz)**0.5)*self.regmesh.faceDiffz*self.regmesh.cellDiffz
         return self._Wzz
 
+
     @property
-    def Wsmooth(self):
+    def Wsmooth2(self):
         """Full smoothness regularization matrix W"""
         if getattr(self, '_Wsmooth', None) is None:
-            wlist = (self.Wx, self.Wxx)
+            wlist = (self.Wxx)
             if self.regmesh.dim > 1:
-                wlist += (self.Wy, self.Wyy)
+                wlist += (self.Wyy)
             if self.regmesh.dim > 2:
-                wlist += (self.Wz, self.Wzz)
+                wlist += (self.Wzz)
             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.Ws, self.Wsmooth)
-            self._W = sp.vstack(wlist)
-        return self._W
+    @Utils.timeIt
+    def _evalSmoothxx(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wxx * ( self.mapping * (m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wxx * ( self.mapping * (m) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmoothyy(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wyy * ( self.mapping * (m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wyy * ( self.mapping * (m) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmoothzz(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wzz * ( self.mapping * (m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wzz * ( self.mapping * (m) )
+        return 0.5 * r.dot(r)
+
+    @Utils.timeIt
+    def _evalSmooth2(self, m):
+        phiSmooth2 = self._evalSmoothxx(m)
+        if self.regmesh.dim > 1:
+            phiSmooth2 += self._evalSmoothyy(m)
+        if self.regmesh.dim > 2:
+            phiSmooth2 += self._evalSmoothzz(m)
+        return phiSmooth2
+
+    @Utils.timeIt
+    def _evalSmoothxxDeriv(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wxx * ( self.mapping * ( m - self.mref ) )
+            return r.T * ( self.Wxx * self.mapping.deriv(m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wxx * ( self.mapping * m )
+            return r.T * ( self.Wxx * self.mapping.deriv(m) )
+
+    @Utils.timeIt
+    def _evalSmoothyyDeriv(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wyy * ( self.mapping * ( m - self.mref ) )
+            return r.T * ( self.Wyy * self.mapping.deriv(m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wyy * ( self.mapping * m )
+            return r.T * ( self.Wyy * self.mapping.deriv(m) )
+
+    @Utils.timeIt
+    def _evalSmoothzzDeriv(self, m):
+        if self.mrefInSmooth == True:
+            r = self.Wzz * ( self.mapping * ( m - self.mref ) )
+            return r.T * ( self.Wzz * self.mapping.deriv(m - self.mref) )
+        elif self.mrefInSmooth == False:
+            r = self.Wzz * ( self.mapping * m )
+            return r.T * ( self.Wzz * self.mapping.deriv(m) )
+
+    @Utils.timeIt
+    def _evalSmoothxx2Deriv(self, m, v=None):
+        if self.mrefInSmooth == True:
+            rDeriv = self.Wxx * ( self.mapping.deriv( m - self.mref ) )
+        elif self.mrefInSmooth == False:
+            rDeriv = self.Wxx * self.mapping.deriv(m)
+        if v is not None:
+            return rDeriv.T * (rDeriv * v)
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothyy2Deriv(self, m, v=None):
+        if self.mrefInSmooth == True:
+            rDeriv = self.Wyy * ( self.mapping.deriv( m - self.mref ) )
+        elif self.mrefInSmooth == False:
+            rDeriv = self.Wyy * self.mapping.deriv(m)
+        if v is not None:
+            return rDeriv.T * (rDeriv * v)
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothzz2Deriv(self, m, v=None):
+        if self.mrefInSmooth == True:
+            rDeriv = self.Wzz * ( self.mapping.deriv( m - self.mref ) )
+        elif self.mrefInSmooth == False:
+            rDeriv = self.Wzz * self.mapping.deriv(m)
+        if v is not None:
+            return rDeriv.T * (rDeriv * v)
+        return rDeriv.T * rDeriv
+
+    @Utils.timeIt
+    def _evalSmoothDeriv2(self, m):
+        deriv = self._evalSmoothxxDeriv(m)
+        if self.regmesh.dim > 1:
+            deriv += self._evalSmoothyyDeriv(m)
+        if self.regmesh.dim > 2:
+            deriv += self._evalSmoothzzDeriv(m)
+        return deriv
+
+    @Utils.timeIt
+    def _evalSmooth2Deriv2(self, m, v=None):
+        deriv = self._evalSmoothxx2Deriv(m, v)
+        if self.regmesh.dim > 1:
+            deriv += self._evalSmoothyy2Deriv(m, v)
+        if self.regmesh.dim > 2:
+            deriv += self._evalSmoothzz2Deriv(m, v)
+        return deriv
+
 
     @Utils.timeIt
     def eval(self, m):
-        if self.mrefInSmooth == True:
-            r1 = self.Wsmooth * ( self.mapping * (m) )
-            r2 = self.Ws * ( self.mapping * (m - self.mref) )
-            return 0.5*(r1.dot(r1)+r2.dot(r2))
-        elif self.mrefInSmooth == False:
-            r = self.W * ( self.mapping * (m - self.mref) )
-            return 0.5*r.dot(r)
-
+        return self._evalSmall(m) + self._evalSmooth(m) + self._evalSmooth2(m)
 
     @Utils.timeIt
     def evalDeriv(self, m):
         """
-
         The regularization is:
 
         .. math::
@@ -515,231 +868,135 @@ class Tikhonov(BaseRegularization):
             R(m) = \mathbf{W^\\top W (m-m_\\text{ref})}
 
         """
-        if self.mrefInSmooth == True:
-            mD1 = self.mapping.deriv(m)
-            mD2 = self.mapping.deriv(m - self.mref)
-            r1 = self.Wsmooth * ( self.mapping * (m))
-            r2 = self.Ws * ( self.mapping * (m - self.mref) )
-            out1 = mD1.T * ( self.Wsmooth.T * r1 )
-            out2 = mD2.T * ( self.Ws.T * r2 )
-            out = out1+out2
-        elif self.mrefInSmooth == False:
-            mD = self.mapping.deriv(m - self.mref)
-            r = self.W * ( self.mapping * (m - self.mref) )
-            out = mD.T * ( self.W.T * r )
-        return out
+        return self._evalSmallDeriv(m) + self._evalSmoothDeriv(m) + self._evalSmoothDeriv2(m)
+
+    def eval2Deriv(self, m, v=None):
+        """
+        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})}
+
+        """
+        return self._evalSmall2Deriv(m, v) + self._evalSmooth2Deriv(m, v) + self._evalSmooth2Deriv2(m, v)
 
 
-class Simple(BaseRegularization):
+
+class Sparse(Simple):
     """
-        Only for tensor mesh
-    """
-
-    mrefInSmooth = True  #: SMOOTH and SMOOTH_MOD_DIF options
-    alpha_s     = Utils.dependentProperty('_alpha_s', 1.0, ['_W', '_Ws'], "Smallness weight")
-    alpha_x     = Utils.dependentProperty('_alpha_x', 1.0, ['_W', '_Wx'], "Weight for the first derivative in the x direction")
-    alpha_y     = Utils.dependentProperty('_alpha_y', 1.0, ['_W', '_Wy'], "Weight for the first derivative in the y direction")
-    alpha_z     = Utils.dependentProperty('_alpha_z', 1.0, ['_W', '_Wz'], "Weight for the first derivative in the z direction")
-    wght        = 1.
+        The regularization is:
     
-    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
-        BaseRegularization.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
+        .. math::
+    
+            R(m) = \\frac{1}{2}\mathbf{(m-m_\\text{ref})^\\top W^\\top R^\\top R W(m-m_\\text{ref})}
+    
+        where the IRLS weight
+    
+        .. math::
+    
+            R = \eta TO FINISH LATER!!!
+    
+        So the derivative is straight forward:
+    
+        .. math::
+    
+            R(m) = \mathbf{W^\\top R^\\top R W (m-m_\\text{ref})}
+    
+        The IRLS weights are recomputed after each beta solves.
+        It is strongly recommended to do a few Gauss-Newton iterations
+        before updating.
+    """
         
-        if isinstance(self.wght,float):
-            self.wght = np.ones(self.regmesh.nC) * self.wght
+    # set default values
+    eps_p = 1e-1        # Threshold value for the model norm
+    eps_q = 1e-1        # Threshold value for the model gradient norm
+    curModel = None     # Requires model to compute the weights
+    l2model = None
+    gamma = 1.          # Model norm scaling to smooth out convergence
+    norms = [0., 2., 2., 2.] # Values for norm on (m, dmdx, dmdy, dmdz)
+    cell_weights = 1.        # Consider overwriting with sensitivity weights
+
+    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
+        Simple.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
+
+        if isinstance(self.cell_weights,float):
+            self.cell_weights = np.ones(self.regmesh.nC) * self.cell_weights
 
     @property
-    def Ws(self):
-        """Regularization matrix Ws"""
-        if getattr(self,'_Ws', None) is None:
-                self._Ws = Utils.sdiag((self.regmesh.vol*self.alpha_s*self.wght)**0.5)
-        return self._Ws
+    def Wsmall(self):
+        """Regularization matrix Wsmall"""
+        if getattr(self,'_Wsmall', None) is None:
+            if getattr(self, 'curModel', None) is None:
+                self.Rs = Utils.speye(self.regmesh.nC)
+
+            else:
+                f_m = self.mapping * (self.curModel - self.reg.mref)
+                self.rs = self.R(f_m , self.eps_p, self.norms[0])
+                self.Rs = Utils.sdiag( self.rs )
+
+            self._Wsmall = Utils.sdiag((self.alpha_s*self.gamma*self.cell_weights)**0.5)*self.Rs
+
+        return self._Wsmall
 
     @property
     def Wx(self):
         """Regularization matrix Wx"""
-        if getattr(self, '_Wx', None) is None:
-            self._Wx = Utils.sdiag((self.regmesh.aveCC2Fx * self.regmesh.vol*self.alpha_x*(self.regmesh.aveCC2Fx*self.wght))**0.5)*self.regmesh.cellDiffxStencil
+        if getattr(self,'_Wx', None) is None:
+            if getattr(self, 'curModel', None) is None:
+                self.Rx = Utils.speye(self.regmesh.cellDiffxStencil.shape[0])
+
+            else:
+                f_m = self.regmesh.cellDiffxStencil * (self.mapping * self.curModel)
+                self.rx = self.R( f_m , self.eps_q, self.norms[1])
+                self.Rx = Utils.sdiag( self.rx )
+
+            self._Wx = Utils.sdiag(( self.alpha_x*self.gamma*(self.regmesh.aveCC2Fx*self.cell_weights))**0.5)*self.Rx*self.regmesh.cellDiffxStencil
+
         return self._Wx
 
     @property
     def Wy(self):
         """Regularization matrix Wy"""
-        if getattr(self, '_Wy', None) is None:
-            self._Wy = Utils.sdiag((self.regmesh.aveCC2Fy * self.regmesh.vol * self.alpha_y*(self.regmesh.aveCC2Fy*self.wght))**0.5)*self.regmesh.cellDiffyStencil
+        if getattr(self,'_Wy', None) is None:
+            if getattr(self, 'curModel', None) is None:
+                self.Ry = Utils.speye(self.regmesh.cellDiffyStencil.shape[0])
+
+            else:
+                f_m = self.regmesh.cellDiffyStencil * (self.mapping * self.curModel)
+                self.ry = self.R( f_m , self.eps_q, self.norms[2])
+                self.Ry = Utils.sdiag( self.ry )
+
+            self._Wy = Utils.sdiag((self.alpha_y*self.gamma*(self.regmesh.aveCC2Fy*self.cell_weights))**0.5)*self.Ry*self.regmesh.cellDiffyStencil
+
         return self._Wy
 
     @property
     def Wz(self):
         """Regularization matrix Wz"""
-        if getattr(self, '_Wz', None) is None:
-            self._Wz = Utils.sdiag((self.regmesh.aveCC2Fz * self.regmesh.vol*self.alpha_z*(self.regmesh.aveCC2Fz*self.wght))**0.5)*self.regmesh.cellDiffzStencil
+        if getattr(self,'_Wz', None) is None:
+            if getattr(self, 'curModel', None) is None:
+                self.Rz = Utils.speye(self.regmesh.cellDiffzStencil.shape[0])
+
+            else:
+                f_m = self.regmesh.cellDiffzStencil * (self.mapping * self.curModel)
+                self.rz = self.R( f_m , self.eps_q, self.norms[3])
+                self.Rz = Utils.sdiag( self.rz )
+
+            self._Wz = Utils.sdiag((self.alpha_z*self.gamma*(self.regmesh.aveCC2Fz*self.cell_weights))**0.5)*self.Rz*self.regmesh.cellDiffzStencil
+
         return self._Wz
 
-    @property
-    def Wsmooth(self):
-        """Full smoothness regularization matrix W"""
-        if getattr(self, '_Wsmooth', None) is None:
-            wlist = (self.Wx,)
-            if self.regmesh.dim > 1:
-                wlist += (self.Wy,)
-            if self.regmesh.dim > 2:
-                wlist += (self.Wz,)
-            self._Wsmooth = sp.vstack(wlist)
-        return self._Wsmooth
+    def R(self, f_m , eps, exponent):
 
-    @property
-    def W(self):
-        """Full regularization matrix W"""
-        if getattr(self, '_W', None) is None:
-            wlist = (self.Ws, self.Wsmooth)
-            self._W = sp.vstack(wlist)
-        return self._W
-
-
-    @Utils.timeIt
-    def eval(self, m):
-        if self.mrefInSmooth == True:
-            r1 = self.Wsmooth * ( self.mapping * (m) )
-            r2 = self.Ws * ( self.mapping * (m - self.mref) )
-            return 0.5*(r1.dot(r1)+r2.dot(r2))
-        elif self.mrefInSmooth == False:
-            r = self.W * ( self.mapping * (m - self.mref) )
-            return 0.5*r.dot(r)
-        return phim
-
-
-
-    @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})}
-
-        """
-        if self.mrefInSmooth == True:
-            mD1 = self.mapping.deriv(m)
-            mD2 = self.mapping.deriv(m - self.mref)
-            r1 = self.Wsmooth * ( self.mapping * (m))
-            r2 = self.Ws * ( self.mapping * (m - self.mref) )
-            out1 = mD1.T * ( self.Wsmooth.T * r1 )
-            out2 = mD2.T * ( self.Ws.T * r2 )
-            out = out1+out2
-        elif self.mrefInSmooth == False:
-            mD = self.mapping.deriv(m - self.mref)
-            r = self.W * ( self.mapping * (m - self.mref) )
-            out = mD.T * ( self.W.T * r )
-        return out
-
-
-class Sparse(Simple):
-
-    # set default values
-    eps      = 1e-1
-    curModel = None # use a model to compute the weights
-    gamma    = 1.
-    p        = 0.
-    qx       = 2.
-    qy       = 2.
-    qz       = 2.
-    wght     = 1.
-
-    def __init__(self, mesh, mapping=None, indActive=None, **kwargs):
-        Simple.__init__(self, mesh, mapping=mapping, indActive=indActive, **kwargs)
-        
-        if isinstance(self.wght,float):
-            self.wght = np.ones(self.regmesh.nC) * self.wght
-
-    @property
-    def Ws(self):
-        """Regularization matrix Ws"""
-        if getattr(self, 'curModel', None) is None:
-            self.Rs = Utils.speye(self.regmesh.nC)
-
-        else:
-            f_m = self.curModel - self.reg.mref
-            self.rs = self.R(f_m , self.p)
-            #print "Min rs: " + str(np.max(self.rs)) + "Max rs: " + str(np.min(self.rs))
-            self.Rs = Utils.sdiag( self.rs )
-            
-        return Utils.sdiag((self.regmesh.vol*self.alpha_s*self.gamma*self.wght)**0.5)*self.Rs
-
-
-    @property
-    def Wx(self):
-        """Regularization matrix Wx"""
-            
-        if getattr(self, 'curModel', None) is None:
-            self.Rx = Utils.speye(self.regmesh.cellDiffxStencil.shape[0])
-
-        else:
-            f_m = self.regmesh.cellDiffxStencil * self.curModel
-            self.rx = self.R( f_m , self.qx)
-            self.Rx = Utils.sdiag( self.rx )
-
-        return Utils.sdiag(( (self.regmesh.aveCC2Fx * self.regmesh.vol) *self.alpha_x*self.gamma*(self.regmesh.aveCC2Fx*self.wght))**0.5)*self.Rx*self.regmesh.cellDiffxStencil
-
-    @property
-    def Wy(self):
-        """Regularization matrix Wy"""
-
-        if getattr(self, 'curModel', None) is None:
-            self.Ry = Utils.speye(self.regmesh.cellDiffyStencil.shape[0])
-
-        else:
-            f_m = self.regmesh.cellDiffyStencil * self.curModel
-            self.ry = self.R( f_m , self.qy)
-            self.Ry = Utils.sdiag( self.ry )
-            
-        return Utils.sdiag(((self.regmesh.aveCC2Fy * self.regmesh.vol)*self.alpha_y*self.gamma*(self.regmesh.aveCC2Fy*self.wght))**0.5)*self.Ry*self.regmesh.cellDiffyStencil
-
-    @property
-    def Wz(self):
-        """Regularization matrix Wz"""
-
-        if getattr(self, 'curModel', None) is None:
-            self.Rz = Utils.speye(self.regmesh.cellDiffzStencil.shape[0])
-
-        else:
-            f_m = self.regmesh.cellDiffzStencil * self.curModel
-            self.rz = self.R( f_m , self.qz)
-            self.Rz = Utils.sdiag( self.rz )
-
-        return Utils.sdiag(((self.regmesh.aveCC2Fz * self.regmesh.vol)*self.alpha_z*self.gamma*(self.regmesh.aveCC2Fz*self.wght))**0.5)*self.Rz*self.regmesh.cellDiffzStencil
-
-    @property
-    def Wsmooth(self):
-        """Full smoothness regularization matrix W"""
-        #if getattr(self, '_Wsmooth', None) is None:
-        wlist = (self.Wx,)
-        if self.regmesh.dim > 1:
-            wlist += (self.Wy,)
-        if self.regmesh.dim > 2:
-            wlist += (self.Wz,)
-        #self._Wsmooth = sp.vstack(wlist)
-        return sp.vstack(wlist)
-
-    @property
-    def W(self):
-        """Full regularization matrix W"""
-        #if getattr(self, '_W', None) is None:
-        wlist = (self.Ws, self.Wsmooth)
-        #self._W = sp.vstack(wlist)
-        return sp.vstack(wlist)
-        
-    def R(self, f_m , exponent):
-
-        eta = (self.eps**(1-exponent/2.))**0.5
-        r = eta / (f_m**2.+self.eps**2.)**((1-exponent/2.)/2.)
+        # Eta scaling is important for mix-norms...do not mess with it
+        eta = (eps**(1.-exponent/2.))**0.5
+        r = eta / (f_m**2.+ eps**2.)**((1.-exponent/2.)/2.)
 
         return r

SimPEG/Survey.py

@@ -311,7 +311,6 @@ class BaseSurvey(object):
         if f is None: f = self.prob.fields(m)
         return Utils.mkvc(self.eval(f))
 
-
     @Utils.count
     def eval(self, f):
         """eval(f)
@@ -322,7 +321,7 @@ class BaseSurvey(object):
 
                 d_\\text{pred} = \mathbf{P} f(m)
         """
-        raise NotImplemented('eval is not yet implemented.')
+        raise NotImplementedError('eval is not yet implemented.')
 
     @Utils.count
     def evalDeriv(self, f):
@@ -334,7 +333,7 @@ class BaseSurvey(object):
 
                 \\frac{\partial d_\\text{pred}}{\partial u} = \mathbf{P}
         """
-        raise NotImplemented('eval is not yet implemented.')
+        raise NotImplementedError('eval is not yet implemented.')
 
     @Utils.count
     def residual(self, m, f=None):

SimPEG/Tests.py

@@ -237,7 +237,7 @@ def checkDerivative(fctn, x0, num=7, plotIt=True, dx=None, expectedOrder=2, tole
         Compares error decay of 0th and 1st order Taylor approximation at point
         x0 for a randomized search direction.
 
-        :param lambda fctn: function handle
+        :param callable fctn: function handle
         :param numpy.array x0: point at which to check derivative
         :param int num: number of times to reduce step length, h
         :param bool plotIt: if you would like to plot

SimPEG/Utils/ModelBuilder.py

@@ -7,11 +7,11 @@ def addBlock(gridCC, modelCC, p0, p1, blockProp):
     """
         Add a block to an exsisting cell centered model, modelCC
 
-        :param numpy.array, gridCC: mesh.gridCC is the cell centered grid
-        :param numpy.array, modelCC: cell centered model
-        :param numpy.array, p0: bottom, southwest corner of block
-        :param numpy.array, p1: top, northeast corner of block
-        :blockProp float, blockProp: property to assign to the model 
+        :param numpy.array gridCC: mesh.gridCC is the cell centered grid
+        :param numpy.array modelCC: cell centered model
+        :param numpy.array p0: bottom, southwest corner of block
+        :param numpy.array p1: top, northeast corner of block
+        :blockProp float blockProp: property to assign to the model
 
         :return numpy.array, modelBlock: model with block
     """
@@ -88,12 +88,14 @@ def getIndicesBlock(p0,p1,ccMesh):
     # Return a tuple
     return ind
 
-def defineBlock(ccMesh,p0,p1,vals=[0,1]):
+def defineBlock(ccMesh,p0,p1,vals=None):
     """
         Build a block with the conductivity specified by condVal.  Returns an array.
         vals[0]  conductivity of the block
         vals[1]  conductivity of the ground
     """
+    if vals is None:
+        vals = [0,1]
     sigma = np.zeros(ccMesh.shape[0]) + vals[1]
     ind   = getIndicesBlock(p0,p1,ccMesh)
 
@@ -101,7 +103,11 @@ def defineBlock(ccMesh,p0,p1,vals=[0,1]):
 
     return mkvc(sigma)
 
-def defineElipse(ccMesh, center=[0,0,0], anisotropy=[1,1,1], slope=10., theta=0.):
+def defineElipse(ccMesh, center=None, anisotropy=None, slope=10., theta=0.):
+    if center is None:
+        center = [0,0,0]
+    if anisotropy is None:
+        anisotropy = [1,1,1]
     G = ccMesh.copy()
     dim = ccMesh.shape[1]
     for i in range(dim):
@@ -141,7 +147,7 @@ def getIndicesSphere(center,radius,ccMesh):
 
     if dimMesh == 1:
        # Define the reference points
-        
+
         ind  = np.abs(center[0] - ccMesh[:,0]) < radius
 
     elif dimMesh == 2:
@@ -156,7 +162,7 @@ def getIndicesSphere(center,radius,ccMesh):
     # Return a tuple
     return ind
 
-def defineTwoLayers(ccMesh,depth,vals=[0,1]):
+def defineTwoLayers(ccMesh,depth,vals=None):
     """
     Define a two layered model.  Depth of the first layer must be specified.
     CondVals vector with the conductivity values of the layers.  Eg:
@@ -167,6 +173,8 @@ def defineTwoLayers(ccMesh,depth,vals=[0,1]):
         0                          depth                                 zf
              1st layer                       2nd layer
     """
+    if vals is None:
+        vals = [0,1]
     sigma = np.zeros(ccMesh.shape[0]) + vals[1]
 
     dim = np.size(ccMesh[0,:])
@@ -214,14 +222,14 @@ def layeredModel(ccMesh, layerTops, layerValues):
 
         :param numpy.array ccMesh: cell-centered mesh
         :param numpy.array layerTops: z-locations of the tops of each layer
-        :param numpy.array layerValue: values of the property to assign for each layer (starting at the top) 
+        :param numpy.array layerValue: values of the property to assign for each layer (starting at the top)
         :rtype: numpy.array
-        :return: M, layered model on the mesh 
+        :return: M, layered model on the mesh
     """
 
     descending = np.linalg.norm(sorted(layerTops, reverse=True) - layerTops) < 1e-20
 
-    # TODO: put an error check to make sure that there is an ordering... needs to work with inf elts 
+    # TODO: put an error check to make sure that there is an ordering... needs to work with inf elts
     # assert ascending or descending, "Layers must be listed in either ascending or descending order"
 
     # start from bottom up
@@ -245,21 +253,21 @@ def layeredModel(ccMesh, layerTops, layerValues):
     model = np.zeros(ccMesh.shape[0])
 
     for i, top in enumerate(layerTops):
-        zind = z <= top 
+        zind = z <= top
         model[zind] = layerValues[i]
 
-    return model 
+    return model
 
 
 
-def randomModel(shape, seed=None, anisotropy=None, its=100, bounds=[0,1]):
+def randomModel(shape, seed=None, anisotropy=None, its=100, bounds=None):
     """
         Create a random model by convolving a kernel with a
         uniformly distributed model.
 
-        :param int,tuple shape: shape of the model.
+        :param tuple shape: shape of the model.
         :param int seed: pick which model to produce, prints the seed if you don't choose.
-        :param numpy.ndarray,list anisotropy: this is the (3 x n) blurring kernel that is used.
+        :param numpy.ndarray anisotropy: this is the (3 x n) blurring kernel that is used.
         :param int its: number of smoothing iterations
         :param list bounds: bounds on the model, len(list) == 2
         :rtype: numpy.ndarray
@@ -276,6 +284,8 @@ def randomModel(shape, seed=None, anisotropy=None, its=100, bounds=[0,1]):
 
 
     """
+    if bounds is None:
+        bounds = [0,1]
 
     if seed is None:
         seed = np.random.randint(1e3)

SimPEG/Utils/SolverUtils.py

@@ -13,7 +13,7 @@ def _checkAccuracy(A, b, X, accuracyTol):
         warnings.warn(msg, RuntimeWarning)
 
 
-def SolverWrapD(fun, factorize=True, checkAccuracy=True, accuracyTol=1e-6):
+def SolverWrapD(fun, factorize=True, checkAccuracy=True, accuracyTol=1e-6, name=None):
     """
     Wraps a direct Solver.
 
@@ -72,11 +72,11 @@ def SolverWrapD(fun, factorize=True, checkAccuracy=True, accuracyTol=1e-6):
         if factorize and hasattr(self.solver, 'clean'):
             return self.solver.clean()
 
-    return type(fun.__name__+'_Wrapped', (object,), {"__init__": __init__, "clean": clean, "__mul__": __mul__})
+    return type(name if name is not None else fun.__name__, (object,), {"__init__": __init__, "clean": clean, "__mul__": __mul__})
 
 
 
-def SolverWrapI(fun, checkAccuracy=True, accuracyTol=1e-5):
+def SolverWrapI(fun, checkAccuracy=True, accuracyTol=1e-5, name=None):
     """
     Wraps an iterative Solver.
 
@@ -128,13 +128,13 @@ def SolverWrapI(fun, checkAccuracy=True, accuracyTol=1e-5):
     def clean(self):
         pass
 
-    return type(fun.__name__+'_Wrapped', (object,), {"__init__": __init__, "clean": clean, "__mul__": __mul__})
+    return type(name if name is not None else fun.__name__, (object,), {"__init__": __init__, "clean": clean, "__mul__": __mul__})
 
 
 from scipy.sparse import linalg
-Solver   = SolverWrapD(linalg.spsolve, factorize=False)
-SolverLU = SolverWrapD(linalg.splu, factorize=True)
-SolverCG = SolverWrapI(linalg.cg)
+Solver   = SolverWrapD(linalg.spsolve, factorize=False, name="Solver")
+SolverLU = SolverWrapD(linalg.splu, factorize=True, name="SolverLU")
+SolverCG = SolverWrapI(linalg.cg, name="SolverCG")
 
 
 class SolverDiag(object):

SimPEG/Utils/__init__.py

@@ -7,3 +7,4 @@ from CounterUtils import *
 import ModelBuilder
 import SolverUtils
 from coordutils import *
+from modelutils import *

SimPEG/Utils/codeutils.py

@@ -55,8 +55,10 @@ def hook(obj, method, name=None, overwrite=False, silent=False):
         print 'Method '+name+' was not overwritten.'
 
 
-def setKwargs(obj, ignore=[],  **kwargs):
+def setKwargs(obj, ignore=None,  **kwargs):
     """Sets key word arguments (kwargs) that are present in the object, throw an error if they don't exist."""
+    if ignore is None:
+        ignore = []
     for attr in kwargs:
         if attr in ignore:
             continue

SimPEG/Utils/interputils.py

@@ -25,7 +25,7 @@ def interpmat(locs, x, y=None, z=None):
         :param numpy.ndarray x: Tensor vector of 1st dimension of grid.
         :param numpy.ndarray y: Tensor vector of 2nd dimension of grid. None by default.
         :param numpy.ndarray z: Tensor vector of 3rd dimension of grid. None by default.
-        :rtype: scipy.sparse.csr.csr_matrix
+        :rtype: scipy.sparse.csr_matrix
         :return: Interpolation matrix
 
         .. plot::

SimPEG/Utils/io_utils.py

@@ -0,0 +1,137 @@
+from SimPEG import np, Mesh
+import time as tm
+import vtk, vtk.util.numpy_support as npsup
+import re
+
+def read_GOCAD_ts(tsfile):
+    """
+
+    Read GOCAD triangulated surface (*.ts) file
+    INPUT:
+    tsfile: Triangulated surface
+
+    OUTPUT:
+    vrts : Array of vertices in XYZ coordinates [n x 3]
+    trgl : Array of index for triangles [m x 3]. The order of the vertices
+            is important and describes the normal
+            n = cross( (P2 - P1 ) , (P3 - P1) )
+
+    Author: @fourndo
+
+
+    .. note::
+
+        Remove all attributes from the GoCAD surface before exporting it!
+
+    """
+
+
+    fid = open(tsfile,'r')
+    line = fid.readline()
+
+    # Skip all the lines until the vertices
+    while re.match('TFACE',line)==None:
+        line = fid.readline()
+
+    line = fid.readline()
+    vrtx = []
+
+    # Run down all the vertices and save in array
+    while re.match('VRTX',line):
+        l_input  = re.split('[\s*]',line)
+        temp = np.array(l_input[2:5])
+        vrtx.append(temp.astype(np.float))
+
+        # Read next line
+        line = fid.readline()
+
+    vrtx = np.asarray(vrtx)
+
+    # Skip lines to the triangles
+    while re.match('TRGL',line)==None:
+        line = fid.readline()
+
+    # Run down the list of triangles
+    trgl = []
+
+    # Run down all the vertices and save in array
+    while re.match('TRGL',line):
+        l_input  = re.split('[\s*]',line)
+        temp = np.array(l_input[1:4])
+        trgl.append(temp.astype(np.int))
+
+        # Read next line
+        line = fid.readline()
+
+    trgl = np.asarray(trgl)
+
+    return vrtx, trgl
+
+def surface2inds(vrtx, trgl, mesh, boundaries=True, internal=True):
+    """"
+    Function to read gocad polystructure file and output indexes of mesh with in the structure.
+
+    """
+    # Adjust the index
+    trgl = trgl - 1
+
+    # Make vtk pts
+    ptsvtk = vtk.vtkPoints()
+    ptsvtk.SetData(npsup.numpy_to_vtk(vrtx,deep=1))
+
+    # Make the polygon connection
+    polys = vtk.vtkCellArray()
+    for face in trgl:
+        poly = vtk.vtkPolygon()
+        poly.GetPointIds().SetNumberOfIds(len(face))
+        for nrv, vert in enumerate(face):
+            poly.GetPointIds().SetId(nrv,vert)
+        polys.InsertNextCell(poly)
+
+    # Make the polydata, structure of connections and vrtx
+    polyData = vtk.vtkPolyData()
+    polyData.SetPoints(ptsvtk)
+    polyData.SetPolys(polys)
+
+    # Make implicit func
+    ImpDistFunc = vtk.vtkImplicitPolyDataDistance()
+    ImpDistFunc.SetInput(polyData)
+
+    # Convert the mesh
+    vtkMesh = vtk.vtkRectilinearGrid()
+    vtkMesh.SetDimensions(mesh.nNx,mesh.nNy,mesh.nNz)
+    vtkMesh.SetXCoordinates(npsup.numpy_to_vtk(mesh.vectorNx, deep=1))
+    vtkMesh.SetYCoordinates(npsup.numpy_to_vtk(mesh.vectorNy, deep=1))
+    vtkMesh.SetZCoordinates(npsup.numpy_to_vtk(mesh.vectorNz, deep=1))
+    # Add indexes
+    vtkInd = npsup.numpy_to_vtk(np.arange(mesh.nC), deep=1)
+    vtkInd.SetName('Index')
+    vtkMesh.GetCellData().AddArray(vtkInd)
+
+    extractImpDistRectGridFilt = vtk.vtkExtractGeometry() # Object constructor
+    extractImpDistRectGridFilt.SetImplicitFunction(ImpDistFunc) #
+    extractImpDistRectGridFilt.SetInputData(vtkMesh)
+
+    if boundaries is True:
+        extractImpDistRectGridFilt.ExtractBoundaryCellsOn()
+
+    else:
+        extractImpDistRectGridFilt.ExtractBoundaryCellsOff()
+
+    if internal is True:
+        extractImpDistRectGridFilt.ExtractInsideOn()
+
+    else:
+        extractImpDistRectGridFilt.ExtractInsideOff()
+
+    print "Extracting indices from grid..."
+    # Executing the pipe
+    extractImpDistRectGridFilt.Update()
+
+    # Get index inside
+    insideGrid = extractImpDistRectGridFilt.GetOutput()
+    insideGrid = npsup.vtk_to_numpy(insideGrid.GetCellData().GetArray('Index'))
+
+
+    # Return the indexes inside
+    return insideGrid

SimPEG/Utils/matutils.py

@@ -27,7 +27,7 @@ def mkvc(x, numDims=1):
 
     if isinstance(x, Zero):
         return x
-    
+
     assert isinstance(x, np.ndarray), "Vector must be a numpy array"
 
     if numDims == 1:
@@ -355,9 +355,9 @@ def diagEst(matFun, n, k=None, approach='Probing'):
         2. Ones : random +/- 1 entries
         3. Random : random vectors
 
-    :param lambda (numpy.array) matFun: matrix to estimate the diagonal of
-    :param int64 n: size of the vector that should be used to compute matFun(v)
-    :param int64 k: number of vectors to be used to estimate the diagonal
+    :param callable matFun: takes a (numpy.array) and multiplies it by a matrix to estimate the diagonal
+    :param int n: size of the vector that should be used to compute matFun(v)
+    :param int k: number of vectors to be used to estimate the diagonal
     :param str approach: approach to be used for getting vectors
     :rtype: numpy.array
     :return: est_diag(A)
@@ -422,9 +422,9 @@ class Zero(object):
     def __ge__(self, v):return 0 >= v
     def __gt__(self, v):return 0 > v
 
-    @property 
+    @property
     def transpose(self): return Zero()
-    
+
     @property
     def T(self): return Zero()
 

SimPEG/Utils/meshutils.py

@@ -83,7 +83,7 @@ def closestPoints(mesh, pts, gridLoc='CC'):
     """
         Move a list of points to the closest points on a grid.
 
-        :param simpeg.Mesh.BaseMesh mesh: The mesh
+        :param BaseMesh mesh: The mesh
         :param numpy.ndarray pts: Points to move
         :param string gridLoc: ['CC', 'N', 'Fx', 'Fy', 'Fz', 'Ex', 'Ex', 'Ey', 'Ez']
         :rtype: numpy.ndarray
@@ -104,16 +104,20 @@ def closestPoints(mesh, pts, gridLoc='CC'):
 
 def ExtractCoreMesh(xyzlim, mesh, meshType='tensor'):
     """
-        Extracts Core Mesh from Global mesh
-        xyzlim: 2D array [ndim x 2]
-        mesh: SimPEG mesh
-        This function ouputs:
-            - actind: corresponding boolean index from global to core
-            - meshcore: core SimPEG mesh
-        Warning: 1D and 2D has not been tested
+    Extracts Core Mesh from Global mesh
+
+    :param numpy.ndarray xyzlim: 2D array [ndim x 2]
+    :param BaseMesh mesh: The mesh
+
+    This function ouputs::
+
+        - actind: corresponding boolean index from global to core
+        - meshcore: core SimPEG mesh
+
+    Warning: 1D and 2D has not been tested
     """
     from SimPEG import Mesh
-    if mesh.dim ==1:
+    if mesh.dim == 1:
         xyzlim = xyzlim.flatten()
         xmin, xmax = xyzlim[0], xyzlim[1]
 
@@ -125,11 +129,11 @@ def ExtractCoreMesh(xyzlim, mesh, meshType='tensor'):
 
         x0 = [xc[0]-hx[0]*0.5, yc[0]-hy[0]*0.5]
 
-        meshCore = Mesh.TensorMesh([hx, hy] ,x0=x0)
+        meshCore = Mesh.TensorMesh([hx, hy], x0=x0)
 
         actind = (mesh.gridCC[:,0]>xmin) & (mesh.gridCC[:,0]<xmax)
 
-    elif mesh.dim ==2:
+    elif mesh.dim == 2:
         xmin, xmax = xyzlim[0,0], xyzlim[0,1]
         ymin, ymax = xyzlim[1,0], xyzlim[1,1]
 
@@ -144,12 +148,12 @@ def ExtractCoreMesh(xyzlim, mesh, meshType='tensor'):
 
         x0 = [xc[0]-hx[0]*0.5, yc[0]-hy[0]*0.5]
 
-        meshCore = Mesh.TensorMesh([hx, hy] ,x0=x0)
+        meshCore = Mesh.TensorMesh([hx, hy], x0=x0)
 
         actind = (mesh.gridCC[:,0]>xmin) & (mesh.gridCC[:,0]<xmax) \
                & (mesh.gridCC[:,1]>ymin) & (mesh.gridCC[:,1]<ymax) \
 
-    elif mesh.dim==3:
+    elif mesh.dim == 3:
         xmin, xmax = xyzlim[0,0], xyzlim[0,1]
         ymin, ymax = xyzlim[1,0], xyzlim[1,1]
         zmin, zmax = xyzlim[2,0], xyzlim[2,1]
@@ -168,7 +172,7 @@ def ExtractCoreMesh(xyzlim, mesh, meshType='tensor'):
 
         x0 = [xc[0]-hx[0]*0.5, yc[0]-hy[0]*0.5, zc[0]-hz[0]*0.5]
 
-        meshCore = Mesh.TensorMesh([hx, hy, hz] ,x0=x0)
+        meshCore = Mesh.TensorMesh([hx, hy, hz], x0=x0)
 
         actind = (mesh.gridCC[:,0]>xmin) & (mesh.gridCC[:,0]<xmax) \
                & (mesh.gridCC[:,1]>ymin) & (mesh.gridCC[:,1]<ymax) \

SimPEG/Utils/modelutils.py

@@ -0,0 +1,63 @@
+from matutils import mkvc, ndgrid
+import numpy as np
+
+def surface2ind_topo(mesh, topo, gridLoc='CC'):
+# def genActiveindfromTopo(mesh, topo):
+    """
+    Get active indices from topography
+    """
+
+
+    if mesh.dim == 3:
+        from scipy.interpolate import NearestNDInterpolator
+        Ftopo = NearestNDInterpolator(topo[:,:2], topo[:,2])
+
+        if gridLoc == 'CC':
+            XY = ndgrid(mesh.vectorCCx, mesh.vectorCCy)
+            Zcc = mesh.gridCC[:,2].reshape((np.prod(mesh.vnC[:2]), mesh.nCz), order='F')
+
+            gridTopo = Ftopo(XY)
+            actind = [gridTopo[ixy] <= Zcc[ixy,:] for ixy in range(np.prod(mesh.vnC[0]))]
+            actind = np.hstack(actind)
+
+        elif gridLoc == 'N':
+
+            XY = ndgrid(mesh.vectorNx, mesh.vectorNy)
+            gridTopo = Ftopo(XY).reshape(mesh.vnN[:2], order='F')
+
+            if mesh._meshType not in ['TENSOR', 'CYL', 'BASETENSOR']:
+                raise NotImplementedError('Nodal surface2ind_topo not implemented for %s mesh'%mesh._meshType)
+
+            Nz = mesh.vectorNz[1:] # TODO: this will only work for tensor meshes
+            actind = np.array([False]*mesh.nC).reshape(mesh.vnC, order='F')
+
+            for ii in range(mesh.nCx):
+                for jj in range(mesh.nCy):
+                     actind[ii,jj,:] = [np.all(gridTopo[ii:ii+2, jj:jj+2] >= Nz[kk]) for kk in range(len(Nz)) ]
+
+    elif mesh.dim == 2:
+        from scipy.interpolate import interp1d
+        Ftopo = interp1d(topo[:,0], topo[:,1])
+
+        if gridLoc == 'CC':
+            gridTopo = Ftopo(mesh.gridCC[:,0])
+            actind = mesh.gridCC[:,1] <= gridTopo
+
+        elif gridLoc == 'N':
+
+            gridTopo = Ftopo(mesh.vectorNx)
+            if mesh._meshType not in ['TENSOR', 'CYL', 'BASETENSOR']:
+                raise NotImplementedError('Nodal surface2ind_topo not implemented for %s mesh'%mesh._meshType)
+
+            Ny = mesh.vectorNy[1:] # TODO: this will only work for tensor meshes
+            actind = np.array([False]*mesh.nC).reshape(mesh.vnC, order='F')
+
+            for ii in range(mesh.nCx):
+                actind[ii,:] = [np.all(gridTopo[ii:ii+2] > Ny[kk]) for kk in range(len(Ny)) ]
+
+    else:
+        raise NotImplementedError('surface2ind_topo not implemented for 1D mesh')
+
+    return mkvc(actind)
+
+

SimPEG/__init__.py

@@ -15,7 +15,7 @@ import Directives
 import Inversion
 import Tests
 
-__version__   = '0.1.10'
+__version__   = '0.1.12'
 __author__    = 'Rowan Cockett'
 __license__   = 'MIT'
 __copyright__ = 'Copyright 2014 Rowan Cockett'

docs/Makefile

@@ -2,7 +2,7 @@
 #
 
 # You can set these variables from the command line.
-SPHINXOPTS    =
+SPHINXOPTS    = -n -w warnings.txt
 SPHINXBUILD   = sphinx-build
 PAPER         =
 BUILDDIR      = _build

docs/_templates/layout.html

@@ -0,0 +1,22 @@
+{# Import the theme's layout. #}
+{% extends "!layout.html" %}
+
+{% block extrahead %}
+{{ super() }}
+
+<meta name="description" content="Simulation and Parameter Estimation in Geophysics">
+<meta name="author" content="SimPEG Developers">
+<meta name="keywords" content="python, geophysics, inversion, electromagnetics, magnetotellurics, magnetics, gravity, DC, flow inverse problems, open source, finite volume">
+
+
+<script>
+  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+
+  ga('create', 'UA-45185336-1', 'auto');
+  ga('send', 'pageview');
+
+</script>
+{% endblock %}

docs/api_FiniteVolume.rst

@@ -1,19 +0,0 @@
-.. _api_FiniteVolume:
-
-Finite Volume
-*************
-
-Any numerical implementation requires the discretization of continuous functions into discrete approximations. These approximations are typically organized in a mesh, which defines boundaries, locations, and connectivity. Of specific interest to geophysical simulations, we require that averaging, interpolation and differential operators be defined for any mesh. In SimPEG, we have implemented a staggered mimetic finite volume approach (`Hyman and Shashkov, 1999 <http://math.lanl.gov/~mac/papers/numerics/HS99B.pdf>`_). This approach requires the definitions of variables at either cell-centers, nodes, faces, or edges as seen in the figure below.
-
-.. image:: images/finitevolrealestate.png
-   :width: 400 px
-   :alt: FiniteVolume
-   :align: center
-
-
-.. toctree::
-   :maxdepth: 2
-
-   api_Mesh
-   api_DiffOps
-   api_InnerProducts