Updates to documentation and DC utilities.

Conflicts:
	SimPEG/DCIP/BaseDC.py
	SimPEG/DCIP/BaseIP.py

.travis.yml

@@ -18,7 +18,7 @@ env:
     - TEST_DIR="tests/mesh tests/base tests/utils"
     - TEST_DIR=tests/em/fdem/inverse/derivs
     - TEST_DIR=tests/em/tdem
-    - TEST_DIR=tests/dcip
+    - TEST_DIR=tests/em/static
     - TEST_DIR=tests/flow
     - TEST_DIR=tests/mt
     - TEST_DIR=tests/examples

SimPEG/DCIP/BaseDC.py

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

SimPEG/DCIP/BaseIP.py

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

SimPEG/DCIP/Utils.py

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

SimPEG/DCIP/__init__.py

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

SimPEG/EM/Static/Utils/StaticUtils.py

@@ -219,10 +219,12 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
         for ii in range(0, int(nstn)-1):
 
 
-            if stype == 'dpdp':
+            if stype == 'dipole-dipole':
                 tx = np.c_[M[ii,:],N[ii,:]]
-            elif stype == 'pdp':
+            elif stype == 'pole-dipole':
                 tx = np.c_[M[ii,:],M[ii,:]]
+            else:
+                raise Exception('The stype must be "dipole-dipole" or "pole-dipole"')
 
             # Rx.append(np.c_[M[ii+1:indx,:],N[ii+1:indx,:]])
 
@@ -256,10 +258,10 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
                 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,:])
+            if stype == 'dipole-dipole':
+                srcClass = DC.Src.Dipole([rxClass], M[ii,:],N[ii,:])
+            elif stype == 'pole-dipole':
+                srcClass = DC.Src.Pole([rxClass], M[ii,:])
             SrcList.append(srcClass)
 
     elif stype == 'gradient':
@@ -310,7 +312,7 @@ def gen_DCIPsurvey(endl, mesh, stype, a, b, n):
             srcClass = DC.Src.Dipole([rxClass], M[0,:], N[-1,:])
         SrcList.append(srcClass)
     else:
-        print """stype must be either 'pdp', 'dpdp' or 'gradient'. """
+        print """stype must be either 'pole-dipole', 'dipole-dipole' or 'gradient'. """
 
 
     return SrcList

SimPEG/EM/Static/__init__.py

@@ -1,3 +1,4 @@
 import DC
 import IP
 import SIP
+import Utils

SimPEG/Examples/DC_Forward_PseudoSection.py

@@ -1,5 +1,5 @@
 from SimPEG import Mesh, Utils, np, sp
-import SimPEG.DCIP as DC
+from SimPEG.EM.Static import DC, Utils as StaticUtils
 import time
 
 def run(loc=None, sig=None, radi=None, param=None, surveyType='dipole-dipole', unitType='appConductivity', plotIt=True):
@@ -74,7 +74,13 @@ def run(loc=None, sig=None, radi=None, param=None, surveyType='dipole-dipole', u
 
     # We will handle the geometry of the survey for you and create all the combination of tx-rx along line
     # [Tx, Rx] = DC.gen_DCIPsurvey(locs, mesh, surveyType, param[0], param[1], param[2])
-    survey, Tx, Rx = DC.gen_DCIPsurvey(locs, mesh, surveyType, param[0], param[1], param[2])
+    srcList = StaticUtils.gen_DCIPsurvey(locs, mesh, surveyType, param[0], param[1], param[2])
+    print(srcList)
+
+    raise Exception('The output of the function changed. We need to create the survey and get Rx to continue.')
+
+    # Something like this!
+    survey, Tx, Rx
 
     # Define some global geometry
     dl_len = np.sqrt( np.sum((locs[0,:] - locs[1,:])**2) )

docs/content/dc/index.rst

@@ -40,7 +40,7 @@
 Direct Current Resistivity
 **************************
 
-`SimPEG.DCIP` uses SimPEG as the framework for the forward and inverse
+`SimPEG.EM.Static.DC` and `SimPEG.EM.Static.IP` uses SimPEG as the framework for the forward and inverse
 direct current (DC) resistivity and induced polarization (IP) geophysical problems.
 
 
@@ -150,7 +150,7 @@ Comparing to the analytic function:
 API for DC codes
 ================
 
-.. automodule:: SimPEG.DCIP.BaseDC
+.. automodule:: SimPEG.EM.Static.DC
     :show-inheritance:
     :members:
     :undoc-members:

docs/content/ip/index.rst

@@ -7,7 +7,7 @@ Todo: docs for IP!
 API for IP codes
 ================
 
-.. automodule:: SimPEG.DCIP.BaseIP
+.. automodule:: SimPEG.EM.Static.IP
     :show-inheritance:
     :members:
     :undoc-members:

tests/dcip/__init__.py

@@ -1,12 +0,0 @@
-import os
-import glob
-import unittest
-
-if __name__ == '__main__':
-    test_file_strings = glob.glob('test_*.py')
-    module_strings = [str[0:len(str)-3] for str in test_file_strings]
-    suites = [unittest.defaultTestLoader.loadTestsFromName(str) for str
-              in module_strings]
-    testSuite = unittest.TestSuite(suites)
-
-    unittest.TextTestRunner(verbosity=2).run(testSuite)

tests/dcip/test_forward_DCproblem.py

@@ -1,77 +0,0 @@
-import unittest
-from SimPEG import *
-import SimPEG.DCIP as DC
-
-
-class DCProblemTests(unittest.TestCase):
-
-    def setUp(self):
-
-        aSpacing=2.5
-        nElecs=10
-
-        surveySize = nElecs*aSpacing - aSpacing
-        cs = surveySize/nElecs/4
-
-        mesh = Mesh.TensorMesh([
-                [(cs,10, -1.3),(cs,surveySize/cs),(cs,10, 1.3)],
-                [(cs,3, -1.3),(cs,3,1.3)],
-        #         [(cs,5, -1.3),(cs,10)]
-            ],'CN')
-
-        srcList = DC.Utils.WennerSrcList(nElecs, aSpacing, in2D=True)
-        survey = DC.SurveyDC(srcList)
-        problem = DC.ProblemDC_CC(mesh)
-        problem.pair(survey)
-
-        mSynth = np.ones(mesh.nC)
-        survey.makeSyntheticData(mSynth)
-
-        # Now set up the problem to do some minimization
-        dmis = DataMisfit.l2_DataMisfit(survey)
-        reg = Regularization.Tikhonov(mesh)
-        opt = Optimization.InexactGaussNewton(maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6)
-        invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=1e4)
-        inv = Inversion.BaseInversion(invProb)
-
-        self.inv = inv
-        self.reg = reg
-        self.p = problem
-        self.mesh = mesh
-        self.m0 = mSynth
-        self.survey = survey
-        self.dmis = dmis
-
-    def test_misfit(self):
-        derChk = lambda m: [self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)]
-        passed = Tests.checkDerivative(derChk, self.m0, plotIt=False)
-        self.assertTrue(passed)
-
-    def test_adjoint(self):
-        # Adjoint Test
-        u = np.random.rand(self.mesh.nC*self.survey.nSrc)
-        v = np.random.rand(self.mesh.nC)
-        w = np.random.rand(self.survey.dobs.shape[0])
-        wtJv = w.dot(self.p.Jvec(self.m0, v))
-        vtJtw = v.dot(self.p.Jtvec(self.m0, w))
-        passed = np.abs(wtJv - vtJtw) < 1e-10
-        print 'Adjoint Test', np.abs(wtJv - vtJtw), passed
-        self.assertTrue(passed)
-
-    def test_dataObj(self):
-        derChk = lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)]
-        passed = Tests.checkDerivative(derChk, self.m0, plotIt=False)
-        self.assertTrue(passed)
-
-
-    def test_massMatrices(self):
-        Gu = np.random.rand(self.mesh.nF)
-        def derChk(m):
-            self.p.curModel = m
-            return [self.p.Msig * Gu, self.p.dMdsig(Gu)]
-        passed = Tests.checkDerivative(derChk, self.m0, plotIt=False)
-        self.assertTrue(passed)
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/dcip/test_forward_IPproblem.py

@@ -1,65 +0,0 @@
-import unittest
-import SimPEG.DCIP as DC
-from SimPEG import *
-
-class IPforwardTests(unittest.TestCase):
-
-    def test_IPforward(self):
-
-        cs = 12.5
-        nc = 200/cs+1
-        hx = [(cs,7, -1.3),(cs,nc),(cs,7, 1.3)]
-        hy = [(cs,7, -1.3),(cs,int(nc/2+1)),(cs,7, 1.3)]
-        hz = [(cs,7, -1.3),(cs,int(nc/2+1))]
-        mesh = Mesh.TensorMesh([hx, hy, hz], 'CCN')
-        sighalf = 1e-2
-        sigma = np.ones(mesh.nC)*sighalf
-        p0 = np.r_[-50., 50., -50.]
-        p1 = np.r_[ 50.,-50., -150.]
-        blk_ind = Utils.ModelBuilder.getIndicesBlock(p0, p1, mesh.gridCC)
-        sigma[blk_ind] = 1e-3
-        eta = np.zeros_like(sigma)
-        eta[blk_ind] = 0.1
-        sigmaInf = sigma.copy()
-        sigma0 = sigma*(1-eta)
-
-        nElecs = 11
-        x_temp = np.linspace(-100, 100, nElecs)
-        aSpacing = x_temp[1]-x_temp[0]
-        y_temp = 0.
-        xyz = Utils.ndgrid(x_temp, np.r_[y_temp], np.r_[0.])
-        srcList = DC.Utils.WennerSrcList(nElecs,aSpacing)
-        survey = DC.SurveyDC(srcList)
-
-        imap   = Maps.IdentityMap(mesh)
-        problem = DC.ProblemDC_CC(mesh, mapping=imap)
-
-        try:
-            from pymatsolver import MumpsSolver
-            solver = MumpsSolver
-        except ImportError, e:
-            solver = SolverLU
-
-        problem.Solver = solver
-        problem.pair(survey)
-
-        phi0 = survey.dpred(sigma0)
-        phiInf = survey.dpred(sigmaInf)
-
-        phiIP_true = phi0-phiInf
-
-        surveyIP = DC.SurveyIP(srcList)
-        problemIP = DC.ProblemIP(mesh, sigma=sigma)
-        problemIP.pair(surveyIP)
-
-        problemIP.Solver = solver
-
-        phiIP_approx = surveyIP.dpred(eta)
-
-        err =  np.linalg.norm(phiIP_true-phiIP_approx) / np.linalg.norm(phiIP_true)
-
-        self.assertTrue(err < 0.02)
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/dcip/test_sens_IPproblem.py

@@ -1,82 +0,0 @@
-import unittest
-from SimPEG import *
-import SimPEG.DCIP as DC
-
-class IPProblemTests(unittest.TestCase):
-
-    def setUp(self):
-
-        cs = 12.5
-        nc = 500/cs+1
-        hx = [(cs,0, -1.3),(cs,nc),(cs,0, 1.3)]
-        hy = [(cs,0, -1.3),(cs,int(nc/2+1)),(cs,0, 1.3)]
-        hz = [(cs,0, -1.3),(cs,int(nc/2+1))]
-        mesh = Mesh.TensorMesh([hx, hy, hz], 'CCN')
-        sighalf = 1e-2
-        sigma = np.ones(mesh.nC)*sighalf
-        p0 = np.r_[-50., 50., -50.]
-        p1 = np.r_[ 50.,-50., -150.]
-        blk_ind = Utils.ModelBuilder.getIndicesBlock(p0, p1, mesh.gridCC)
-        sigma[blk_ind] = 1e-3
-        eta = np.zeros_like(sigma)
-        eta[blk_ind] = 0.1
-
-        nElecs = 5
-        x_temp = np.linspace(-250, 250, nElecs)
-        aSpacing = x_temp[1]-x_temp[0]
-        y_temp = 0.
-        xyz = Utils.ndgrid(x_temp, np.r_[y_temp], np.r_[0.])
-        srcList = DC.Utils.WennerSrcList(nElecs,aSpacing)
-        survey = DC.SurveyIP(srcList)
-        imap   = Maps.IdentityMap(mesh)
-        problem = DC.ProblemIP(mesh, sigma=sigma, mapping= imap)
-        problem.pair(survey)
-
-        try:
-            from pymatsolver import MumpsSolver
-            problem.Solver = MumpsSolver
-        except ImportError, e:
-            problem.Solver = SolverLU
-
-        mSynth = eta
-        survey.makeSyntheticData(mSynth)
-
-        # Now set up the problem to do some minimization
-        dmis = DataMisfit.l2_DataMisfit(survey)
-        reg = Regularization.Tikhonov(mesh)
-        opt = Optimization.InexactGaussNewton(maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6)
-        invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=1e4)
-        inv = Inversion.BaseInversion(invProb)
-
-        self.inv = inv
-        self.reg = reg
-        self.p = problem
-        self.mesh = mesh
-        self.m0 = mSynth
-        self.survey = survey
-        self.dmis = dmis
-
-    def test_misfit(self):
-        derChk = lambda m: [self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)]
-        passed = Tests.checkDerivative(derChk, self.m0*0, plotIt=False)
-        self.assertTrue(passed)
-
-    def test_adjoint(self):
-        # Adjoint Test
-        u = np.random.rand(self.mesh.nC*self.survey.nSrc)
-        v = np.random.rand(self.mesh.nC)
-        w = np.random.rand(self.survey.dobs.shape[0])
-        wtJv = w.dot(self.p.Jvec(self.m0, v))
-        vtJtw = v.dot(self.p.Jtvec(self.m0, w))
-        passed = np.abs(wtJv - vtJtw) < 1e-10
-        print 'Adjoint Test', np.abs(wtJv - vtJtw), passed
-        self.assertTrue(passed)
-
-    def test_dataObj(self):
-        derChk = lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)]
-        passed = Tests.checkDerivative(derChk, self.m0, plotIt=False)
-        self.assertTrue(passed)
-
-
-if __name__ == '__main__':
-    unittest.main()