trial for secondary data

Conflicts:
	SimPEG/Problem.py

.bumpversion.cfg

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

.travis.yml

@@ -18,9 +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/flow
-    - TEST_DIR=tests/mt
     - TEST_DIR=tests/examples
     - TEST_DIR=tests/em/fdem/inverse/adjoint
     - TEST_DIR=tests/em/fdem/forward
@@ -56,5 +54,3 @@ notifications:
   email:
     - rowanc1@gmail.com
     - lindseyheagy@gmail.com
-    - gkrosen@gmail.com
-    - sgkang09@gmail.com

README.rst

@@ -25,10 +25,6 @@ SimPEG
     :target: https://coveralls.io/r/simpeg/simpeg?branch=master
     :alt: Coverage status
 
-.. image:: http://img.shields.io/badge/GITTER-JOIN_CHAT-brightgreen.svg?style=flat-square
-    :alt: gitter chat room at https://gitter.im/simpeg/simpeg
-    :target: https://gitter.im/simpeg/simpeg
-    
 Simulation and Parameter Estimation in Geophysics  -  A python package for simulation and gradient based parameter estimation in the context of geophysical applications.
 
 The vision is to create a package for finite volume simulation with applications to geophysical imaging and subsurface flow. To enable the understanding of the many different components, this package has the following features:

SimPEG/DCIP/BaseDC.py

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

SimPEG/DCIP/BaseIP.py

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

SimPEG/DCIP/Utils.py

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

SimPEG/DCIP/__init__.py

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

SimPEG/DataMisfit.py

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

SimPEG/Directives.py

@@ -123,10 +123,10 @@ class BetaEstimate_ByEig(InversionDirective):
         if self.debug: print 'Calculating the beta0 parameter.'
 
         m = self.invProb.curModel
-        f = self.invProb.getFields(m, store=True, deleteWarmstart=False)
+        u = self.invProb.getFields(m, store=True, deleteWarmstart=False)
 
         x0 = np.random.rand(*m.shape)
-        t = x0.dot(self.dmisfit.eval2Deriv(m,x0,f=f))
+        t = x0.dot(self.dmisfit.eval2Deriv(m,x0,u=u))
         b = x0.dot(self.reg.eval2Deriv(m, v=x0))
         self.beta0 = self.beta0_ratio*(t/b)
 
@@ -144,18 +144,12 @@ class BetaSchedule(InversionDirective):
             if self.debug: print 'BetaSchedule is cooling Beta. Iteration: %d' % self.opt.iter
             self.invProb.beta /= self.coolingFactor
 
-
 class TargetMisfit(InversionDirective):
 
-    chifact = 1.
-    phi_d_star = None
-
     @property
     def target(self):
         if getattr(self, '_target', None) is None:
-            if self.phi_d_star is None:
-                self.phi_d_star = 0.5 * self.survey.nD
-            self._target = self.chifact * self.phi_d_star # the factor of 0.5 is because we do phid = 0.5*|| dpred - dobs||^2
+            self._target = self.survey.nD*0.5
         return self._target
     @target.setter
     def target(self, val):
@@ -222,13 +216,13 @@ class SaveOutputDictEveryIteration(_SaveEveryIteration):
         # 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:
+        if self.reg.smoothModel == 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:
+        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:
@@ -243,197 +237,53 @@ 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)
 
-#         mref = getattr(self, 'm_prev', None)
-#         if mref is None:
-#             if self.debug: print 'UpdateReferenceModel is using mref0'
-#             mref = self.mref0
-#         self.m_prev = self.invProb.m_current
-#         return mref
-
-class Update_IRLS(InversionDirective):
-
-    eps_min = None
-    eps_p = None
-    eps_q = None
-    norms = [2.,2.,2.,2.]
-    factor = None
-    gamma = None
-    phi_m_last = None
-    phi_d_last = None
-    f_old = None
-    f_min_change = 1e-2
-    beta_tol = 5e-2
-
-    # Solving parameter for IRLS (mode:2)
-    IRLSiter   = 0
-    minGNiter = 5
-    maxIRLSiter = 10
-    iterStart = 0
-
-    # Beta schedule
-    coolingFactor = 2.
-    coolingRate = 1
-
-    mode = 1
-
-    @property
-    def target(self):
-        if getattr(self, '_target', None) is None:
-            self._target = self.survey.nD*0.5
-        return self._target
-    @target.setter
-    def target(self, val):
-        self._target = val
-
-    def initialize(self):
-
-        if self.mode == 1:
-            self.reg.norms = [2., 2., 2., 2.]
-
-    def endIter(self):
-
-        # After reaching target misfit with l2-norm, switch to IRLS (mode:2)
-        if self.invProb.phi_d < self.target and self.mode == 1:
-            print "Convergence with smooth l2-norm regularization: Start IRLS steps..."
-
-            self.mode = 2
-            print self.eps_p, self.eps_q, self.norms
-            self.reg.eps_p = self.eps_p
-            self.reg.eps_q = self.eps_q
-            self.reg.norms = self.norms
-            self.coolingFactor = 1.
-            self.coolingRate = 1
-            self.iterStart = self.opt.iter
-            self.phi_d_last = self.invProb.phi_d
-            self.phi_m_last = self.invProb.phi_m_last
-
-            self.reg.l2model = self.invProb.curModel
-            self.reg.curModel = self.invProb.curModel
-
-            if getattr(self, 'f_old', None) is None:
-                self.f_old = self.reg.eval(self.invProb.curModel)#self.invProb.evalFunction(self.invProb.curModel, return_g=False, return_H=False)
-
-        # Beta Schedule
-        if self.opt.iter > 0 and self.opt.iter % self.coolingRate == 0:
-            if self.debug: print 'BetaSchedule is cooling Beta. Iteration: %d' % self.opt.iter
-            self.invProb.beta /= self.coolingFactor
 
 
-        # Only update after GN iterations
-        if (self.opt.iter-self.iterStart) % self.minGNiter == 0 and self.mode==2:
+class update_IRLS(InversionDirective):
 
-            self.IRLSiter += 1
+     m = None
+     eps_min = None
+     factor = None
+     gamma = None
+     phi_m_last = None
+     
+     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
+         
+         self.reg.gamma = self.gamma
+         
+     def endIter(self):
+         # Cool the threshold parameter 
+         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
+                 
+         
+         # Update the model used for the IRLS weights
+         if getattr(self, 'm', None) is None:
+             self.reg.m = 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.prob.mesh.nC))**2.
+         PC     = Utils.sdiag(diagA**-1.)
 
-            phim_new = self.reg.eval(self.invProb.curModel)
-            self.f_change = np.abs(self.f_old - phim_new) / self.f_old
+         self.opt.approxHinv = PC
+         
+         phim_new = self.reg.eval(self.invProb.curModel)
+         self.reg.gamma = self.reg.gamma * self.invProb.phi_m_last / phim_new
 
-            print "Regularization decrease: %6.3e" % (self.f_change)
-
-            # Check for maximum number of IRLS cycles
-            if self.IRLSiter == self.maxIRLSiter:
-                print "Reach maximum number of IRLS cycles: %i" % self.maxIRLSiter
-                self.opt.stopNextIteration = True
-                return
-
-            # Check if the function has changed enough
-            if self.f_change < self.f_min_change and self.IRLSiter > 1:
-                print "Minimum decrease in regularization. End of IRLS"
-                self.opt.stopNextIteration = True
-                return
-            else:
-                self.f_old = phim_new
-
-            # Cool the threshold parameter if required
-            if getattr(self, 'factor', None) is not None:
-                eps = self.reg.eps / self.factor
-
-                if getattr(self, 'eps_min', None) is not None:
-                    self.reg.eps = np.max([self.eps_min,eps])
-                else:
-                    self.reg.eps = eps
-
-            # Get phi_m at the end of current iteration
-            self.phi_m_last = self.invProb.phi_m_last
-
-            # Reset the regularization matrices so that it is
-            # recalculated for current model
-            self.reg._Wsmall = None
-            self.reg._Wx = None
-            self.reg._Wy = None
-            self.reg._Wz = None
-
-             # Update the model used for the IRLS weights
-            self.reg.curModel = self.invProb.curModel
-
-            # Temporarely set gamma to 1. to get raw phi_m
-            self.reg.gamma = 1.
-
-            # Compute new model objective function value
-            phim_new = self.reg.eval(self.invProb.curModel)
-
-            # Update gamma to scale the regularization between IRLS iterations
-            self.reg.gamma = self.phi_m_last / phim_new
-
-            # Reset the regularization matrices again for new gamma
-            self.reg._Wsmall = None
-            self.reg._Wx = None
-            self.reg._Wy = None
-            self.reg._Wz = None
-
-            # Check if misfit is within the tolerance, otherwise scale beta
-            val = self.invProb.phi_d / (self.survey.nD*0.5)
-
-            if np.abs(1.-val) > self.beta_tol:
-                self.invProb.beta = self.invProb.beta * self.survey.nD*0.5 / self.invProb.phi_d
-
-class Update_lin_PreCond(InversionDirective):
-    """
-    Create a Jacobi preconditioner for the linear problem
-    """
-    onlyOnStart=False
-
-    def initialize(self):
-
-        if getattr(self.opt, 'approxHinv', None) is None:
-            # Update the pre-conditioner
-            diagA = np.sum(self.prob.G**2.,axis=0) + self.invProb.beta*(self.reg.W.T*self.reg.W).diagonal() #* (self.reg.mapping * np.ones(self.reg.curModel.size))**2.
-            PC     = Utils.sdiag((self.prob.mapping.deriv(None).T *diagA)**-1.)
-            self.opt.approxHinv = PC
-
-    def endIter(self):
-        # Cool the threshold parameter
-        if self.onlyOnStart==True:
-            return
-
-        if getattr(self.opt, 'approxHinv', None) is not None:
-            # Update the pre-conditioner
-            diagA = np.sum(self.prob.G**2.,axis=0) + self.invProb.beta*(self.reg.W.T*self.reg.W).diagonal() #* (self.reg.mapping * np.ones(self.reg.curModel.size))**2.
-            PC     = Utils.sdiag((self.prob.mapping.deriv(None).T *diagA)**-1.)
-            self.opt.approxHinv = PC
-
-
-class Update_Wj(InversionDirective):
-    """
-        Create approx-sensitivity base weighting using the probing method
-    """
-    k = None # Number of probing cycles
-    itr = None # Iteration number to update Wj, or always update if None
-
-    def endIter(self):
-
-        if self.itr is None or self.itr == self.opt.iter:
-
-            m = self.invProb.curModel
-            if self.k is None:
-                self.k = int(self.survey.nD/10)
-
-            def JtJv(v):
-
-                Jv = self.prob.Jvec(m, v)
-
-                return self.prob.Jtvec(m,Jv)
-
-            JtJdiag = Utils.diagEst(JtJv,len(m),k=self.k)
-            JtJdiag = JtJdiag / max(JtJdiag)
-
-            self.reg.wght = JtJdiag
+#==============================================================================
+#          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))
+#==============================================================================

SimPEG/EM/Analytics/DC.py

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

SimPEG/EM/Analytics/__init__.py

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

SimPEG/EM/Base.py

@@ -1,16 +1,15 @@
 from SimPEG import Survey, Problem, Utils, Models, Maps, PropMaps, np, sp, Solver as SimpegSolver
 from scipy.constants import mu_0
 
-
 class EMPropMap(Maps.PropMap):
-    """
+    """ 
         Property Map for EM Problems. The electrical conductivity (\\(\\sigma\\)) is the default inversion property, and the default value of the magnetic permeability is that of free space (\\(\\mu = 4\\pi\\times 10^{-7} \\) H/m)
     """
 
     sigma = Maps.Property("Electrical Conductivity", defaultInvProp = True, propertyLink=('rho',Maps.ReciprocalMap))
     mu = Maps.Property("Inverse Magnetic Permeability", defaultVal = mu_0, propertyLink=('mui',Maps.ReciprocalMap))
 
-    rho = Maps.Property("Electrical Resistivity", propertyLink=('sigma', Maps.ReciprocalMap))
+    rho = Maps.Property("Electrical Resistivity", propertyLink=('sigma', Maps.ReciprocalMap)) 
     mui = Maps.Property("Inverse Magnetic Permeability", defaultVal = 1./mu_0, propertyLink=('mu', Maps.ReciprocalMap))
 
 
@@ -22,7 +21,7 @@ class BaseEMProblem(Problem.BaseProblem):
 
     surveyPair = Survey.BaseSurvey
     dataPair = Survey.Data
-
+    
     PropMap = EMPropMap
 
     Solver = SimpegSolver
@@ -52,7 +51,7 @@ class BaseEMProblem(Problem.BaseProblem):
         if self.mapping.muMap is not None or self.mapping.muiMap is not None:
             toDelete += ['_MeMu', '_MeMuI','_MfMui','_MfMuiI']
         return toDelete
-
+    
     @property
     def Me(self):
         """
@@ -62,15 +61,6 @@ 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):
         """
@@ -80,22 +70,8 @@ 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 ----- #
+    # ----- Magnetic Permeability ----- # 
     @property
     def MfMui(self):
         """
@@ -133,7 +109,7 @@ class BaseEMProblem(Problem.BaseProblem):
         return self._MeMuI
 
 
-    # ----- Electrical Conductivity ----- #
+    # ----- Electrical Conductivity ----- # 
     #TODO: hardcoded to sigma as the model
     @property
     def MeSigma(self):
@@ -144,17 +120,18 @@ class BaseEMProblem(Problem.BaseProblem):
             self._MeSigma = self.mesh.getEdgeInnerProduct(self.curModel.sigma)
         return self._MeSigma
 
-    # TODO: This should take a vector
+    # TODO: This should take a vector 
     def MeSigmaDeriv(self, u):
         """
             Derivative of MeSigma with respect to the model
-        """
+        """ 
         return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u) * self.curModel.sigmaDeriv
+    
 
     @property
     def MeSigmaI(self):
         """
-            Inverse of the edge inner product matrix for \\(\\sigma\\).
+            Inverse of the edge inner product matrix for \\(\\sigma\\). 
         """
         if getattr(self, '_MeSigmaI', None) is None:
             self._MeSigmaI = self.mesh.getEdgeInnerProduct(self.curModel.sigma, invMat=True)
@@ -163,13 +140,16 @@ class BaseEMProblem(Problem.BaseProblem):
     # TODO: This should take a vector
     def MeSigmaIDeriv(self, u):
         """
-            Derivative of :code:`MeSigma` with respect to the model
-        """
+            Derivative of :code:`MeSigma` with respect to the model 
+        """ 
         # TODO: only works for diagonal tensors. getEdgeInnerProductDeriv, invMat=True should be implemented in SimPEG
 
         dMeSigmaI_dI = -self.MeSigmaI**2
         dMe_dsig = self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u)
-        return dMeSigmaI_dI * ( dMe_dsig * self.curModel.sigmaDeriv )
+        dsig_dm = self.curModel.sigmaDeriv
+        return dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm))
+        # return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma, invMat=True)(u)
+
 
     @property
     def MfRho(self):
@@ -183,9 +163,10 @@ class BaseEMProblem(Problem.BaseProblem):
     # TODO: This should take a vector
     def MfRhoDeriv(self,u):
         """
-            Derivative of :code:`MfRho` with respect to the model.
+            Derivative of :code:`MfRho` with respect to the model. 
         """
-        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u) * self.curModel.rhoDeriv
+        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u) * (-Utils.sdiag(self.curModel.rho**2) * self.curModel.sigmaDeriv)
+        # self.curModel.rhoDeriv
 
     @property
     def MfRhoI(self):
@@ -200,32 +181,6 @@ class BaseEMProblem(Problem.BaseProblem):
     # TODO: This should take a vector
     def MfRhoIDeriv(self,u):
         """
-            Derivative of :code:`MfRhoI` with respect to the model.
+            Derivative of :code:`MfRhoI` with respect to the model. 
         """
-
-        dMfRhoI_dI = -self.MfRhoI**2
-        dMf_drho = self.mesh.getFaceInnerProductDeriv(self.curModel.rho)(u)
-        return dMfRhoI_dI * ( dMf_drho * self.curModel.rhoDeriv )
-
-class BaseEMSurvey(Survey.BaseSurvey):
-
-    def __init__(self, srcList, **kwargs):
-        # Sort these by frequency
-        self.srcList = srcList
-        Survey.BaseSurvey.__init__(self, **kwargs)
-
-    def eval(self, f):
-        """
-        Project fields to receiver locations
-        :param Fields u: fields object
-        :rtype: numpy.ndarray
-        :return: data
-        """
-        data = Survey.Data(self)
-        for src in self.srcList:
-            for rx in src.rxList:
-                data[src, rx] = rx.eval(src, self.mesh, f)
-        return data
-
-    def evalDeriv(self, f):
-        raise Exception('Use Receivers to project fields deriv.')
+        return self.mesh.getFaceInnerProductDeriv(self.curModel.rho, invMat=True)(u) * self.curModel.rhoDeriv

SimPEG/EM/FDEM/FDEM.py

@@ -0,0 +1,572 @@
+from SimPEG import Problem, Utils, np, sp, Solver as SimpegSolver
+from scipy.constants import mu_0
+from SurveyFDEM import Survey as SurveyFDEM
+from FieldsFDEM import Fields, Fields_e, Fields_b, Fields_h, Fields_j
+from SimPEG.EM.Base import BaseEMProblem
+from SimPEG.EM.Utils import omega
+
+
+class BaseFDEMProblem(BaseEMProblem):
+    """
+        We start by looking at Maxwell's equations in the electric
+        field \\\(\\\mathbf{e}\\\) and the magnetic flux
+        density \\\(\\\mathbf{b}\\\)
+
+        .. math ::
+
+            \mathbf{C} \mathbf{e} + i \omega \mathbf{b} = \mathbf{s_m} \\\\
+            {\mathbf{C}^T \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e} \mathbf{e} = \mathbf{M^e} \mathbf{s_e}}
+
+        if using the E-B formulation (:code:`Problem_e`
+        or :code:`Problem_b`) or the magnetic field
+        \\\(\\\mathbf{h}\\\) and current density \\\(\\\mathbf{j}\\\)
+
+        .. math ::
+
+            \mathbf{C}^T \mathbf{M_{\\rho}^f} \mathbf{j} + i \omega \mathbf{M_{\mu}^e} \mathbf{h} = \mathbf{M^e} \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`).
+
+        The problem performs the elimination so that we are solving the system for \\\(\\\mathbf{e},\\\mathbf{b},\\\mathbf{j} \\\) or \\\(\\\mathbf{h}\\\)
+    """
+
+    surveyPair = SurveyFDEM
+    fieldsPair = Fields
+
+    def fields(self, m=None):
+        """
+            Solve the forward problem for the fields.
+        """
+
+        self.curModel = m
+        F = self.fieldsPair(self.mesh, self.survey)
+
+        for freq in self.survey.freqs:
+            A = self.getA(freq)
+            rhs = self.getRHS(freq)
+            Ainv = self.Solver(A, **self.solverOpts)
+            sol = Ainv * rhs
+            Srcs = self.survey.getSrcByFreq(freq)
+            ftype = self._fieldType + 'Solution'
+            F[Srcs, ftype] = sol
+            Ainv.clean()
+        return F
+
+    def Jvec(self, m, v, f=None):
+        """
+            Sensitivity times a vector
+        """
+
+        if f is None:
+           f = self.fields(m)
+
+        self.curModel = m
+
+        Jv = self.dataPair(self.survey)
+
+        for freq in self.survey.freqs:
+            A = self.getA(freq) #
+            Ainv = self.Solver(A, **self.solverOpts)
+
+            for src in self.survey.getSrcByFreq(freq):
+                ftype = self._fieldType + 'Solution'
+                u_src = f[src, ftype]
+                dA_dm = self.getADeriv_m(freq, u_src, v)
+                dRHS_dm = self.getRHSDeriv_m(freq, src, v) 
+                du_dm = Ainv * ( - dA_dm + dRHS_dm )
+                
+                for rx in src.rxList:
+                    df_duFun = getattr(f, '_%sDeriv_u'%rx.projField, None)
+                    df_dudu_dm = df_duFun(src, du_dm, adjoint=False)
+
+                    df_dmFun = getattr(f, '_%sDeriv_m'%rx.projField, None)
+                    df_dm = df_dmFun(src, v, adjoint=False)
+
+                    Df_Dm = np.array(df_dudu_dm + df_dm,dtype=complex)
+
+                    P = lambda v: rx.projectFieldsDeriv(src, self.mesh, f, v) # wrt u, also have wrt m
+
+                    Jv[src, rx] = P(Df_Dm)
+
+            Ainv.clean()
+        return Utils.mkvc(Jv)
+
+    def Jtvec(self, m, v, f=None):
+        """
+            Sensitivity transpose times a vector
+        """
+
+        if f is None:
+            f = self.fields(m)
+
+        self.curModel = m
+
+        # Ensure v is a data object.
+        if not isinstance(v, self.dataPair):
+            v = self.dataPair(self.survey, v)
+
+        Jtv = np.zeros(m.size)
+
+        for freq in self.survey.freqs:
+            AT = self.getA(freq).T
+            ATinv = self.Solver(AT, **self.solverOpts)
+
+            for src in self.survey.getSrcByFreq(freq):
+                ftype = self._fieldType + 'Solution'
+                u_src = f[src, ftype]
+
+                for rx in src.rxList:
+                    PTv = rx.projectFieldsDeriv(src, self.mesh, f, v[src, rx], adjoint=True) # wrt u, need possibility wrt m
+
+                    df_duTFun = getattr(f, '_%sDeriv_u'%rx.projField, None)
+                    df_duT = df_duTFun(src, PTv, adjoint=True)
+                    
+                    ATinvdf_duT = ATinv * df_duT
+
+                    dA_dmT = self.getADeriv_m(freq, u_src, ATinvdf_duT, adjoint=True)
+                    dRHS_dmT = self.getRHSDeriv_m(freq,src, ATinvdf_duT, adjoint=True)
+                    du_dmT = -dA_dmT + dRHS_dmT
+
+                    df_dmFun = getattr(f, '_%sDeriv_m'%rx.projField, None)
+                    dfT_dm = df_dmFun(src, PTv, adjoint=True)
+
+                    du_dmT += dfT_dm
+
+                    real_or_imag = rx.projComp
+                    if real_or_imag is 'real':
+                        Jtv +=   np.array(du_dmT,dtype=complex).real
+                    elif real_or_imag is 'imag':
+                        Jtv += - np.array(du_dmT,dtype=complex).real
+                    else:
+                        raise Exception('Must be real or imag')
+            
+            ATinv.clean()
+        return Jtv
+
+    def getSourceTerm(self, freq):
+        """
+            Evaluates the sources for a given frequency and puts them in matrix form
+
+            :param float freq: Frequency
+            :rtype: numpy.ndarray (nE or nF, nSrc)
+            :return: S_m, S_e
+        """
+        Srcs = self.survey.getSrcByFreq(freq)
+        if self._eqLocs is 'FE':
+            S_m = np.zeros((self.mesh.nF,len(Srcs)), dtype=complex)
+            S_e = np.zeros((self.mesh.nE,len(Srcs)), dtype=complex)
+        elif self._eqLocs is 'EF':
+            S_m = np.zeros((self.mesh.nE,len(Srcs)), dtype=complex)
+            S_e = np.zeros((self.mesh.nF,len(Srcs)), dtype=complex)
+
+        for i, src in enumerate(Srcs):
+            smi, sei = src.eval(self)
+            S_m[:,i] = S_m[:,i] + smi
+            S_e[:,i] = S_e[:,i] + sei
+
+        return S_m, S_e
+
+
+##########################################################################################
+################################ E-B Formulation #########################################
+##########################################################################################
+
+class Problem_e(BaseFDEMProblem):
+    """
+        By eliminating the magnetic flux density using
+
+            .. math ::
+
+                \mathbf{b} = \\frac{1}{i \omega}\\left(-\mathbf{C} \mathbf{e} + \mathbf{s_m}\\right)
+
+
+        we can write Maxwell's equations as a second order system in \\\(\\\mathbf{e}\\\) only:
+
+        .. math ::
+
+            \\left(\mathbf{C}^T \mathbf{M_{\mu^{-1}}^f} \mathbf{C}+ i \omega \mathbf{M^e_{\sigma}} \\right)\mathbf{e} = \mathbf{C}^T \mathbf{M_{\mu^{-1}}^f}\mathbf{s_m} -i\omega\mathbf{M^e}\mathbf{s_e}
+
+        which we solve for \\\(\\\mathbf{e}\\\).
+    """
+
+    _fieldType = 'e'
+    _eqLocs    = 'FE'
+    fieldsPair = Fields_e
+
+    def __init__(self, mesh, **kwargs):
+        BaseFDEMProblem.__init__(self, mesh, **kwargs)
+
+    def getA(self, freq):
+        """
+            .. math ::
+                \mathbf{A} = \mathbf{C}^T \mathbf{M_{\mu^{-1}}^f} \mathbf{C} + i \omega \mathbf{M^e_{\sigma}}
+
+            :param float freq: Frequency
+            :rtype: scipy.sparse.csr_matrix
+            :return: A
+        """
+        MfMui = self.MfMui
+        MeSigma = self.MeSigma
+        C = self.mesh.edgeCurl
+
+        return C.T*MfMui*C + 1j*omega(freq)*MeSigma
+
+
+    def getADeriv_m(self, freq, u, v, adjoint=False):
+        dsig_dm = self.curModel.sigmaDeriv
+        dMe_dsig = self.MeSigmaDeriv(u)
+
+        if adjoint:
+            return 1j * omega(freq) * ( dMe_dsig.T * v )
+
+        return 1j * omega(freq) * ( dMe_dsig * v )
+
+    def getRHS(self, freq):
+        """
+            .. math ::
+                \mathbf{RHS} = \mathbf{C}^T \mathbf{M_{\mu^{-1}}^f}\mathbf{s_m} -i\omega\mathbf{M_e}\mathbf{s_e}
+
+            :param float freq: Frequency
+            :rtype: numpy.ndarray (nE, nSrc)
+            :return: RHS
+        """
+
+        S_m, S_e = self.getSourceTerm(freq)
+        C = self.mesh.edgeCurl
+        MfMui = self.MfMui
+
+        RHS = C.T * (MfMui * S_m) -1j * omega(freq) * S_e
+
+        return RHS
+
+    def getRHSDeriv_m(self, freq, src, v, adjoint=False):
+        C = self.mesh.edgeCurl
+        MfMui = self.MfMui
+        S_mDeriv, S_eDeriv = src.evalDeriv(self, adjoint)
+
+        if adjoint:
+            dRHS = MfMui * (C * v)
+            return S_mDeriv(dRHS) - 1j * omega(freq) * S_eDeriv(v)
+
+        else:
+            return C.T * (MfMui * S_mDeriv(v)) -1j * omega(freq) * S_eDeriv(v)
+
+
+class Problem_b(BaseFDEMProblem):
+    """
+        We eliminate \\\(\\\mathbf{e}\\\) using
+
+        .. math ::
+
+             \mathbf{e} = \mathbf{M^e_{\sigma}}^{-1} \\left(\mathbf{C}^T \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{s_e}\\right)
+
+        and solve for \\\(\\\mathbf{b}\\\) using:
+
+        .. math ::
+
+            \\left(\mathbf{C} \mathbf{M^e_{\sigma}}^{-1} \mathbf{C}^T \mathbf{M_{\mu^{-1}}^f}  + i \omega \\right)\mathbf{b} = \mathbf{s_m} + \mathbf{M^e_{\sigma}}^{-1}\mathbf{M^e}\mathbf{s_e}
+
+        .. note ::
+            The inverse problem will not work with full anisotropy
+    """
+
+    _fieldType = 'b'
+    _eqLocs    = 'FE'
+    fieldsPair = Fields_b
+
+    def __init__(self, mesh, **kwargs):
+        BaseFDEMProblem.__init__(self, mesh, **kwargs)
+
+    def getA(self, freq):
+        """
+            .. math ::
+                \mathbf{A} = \mathbf{C} \mathbf{M^e_{\sigma}}^{-1} \mathbf{C}^T \mathbf{M_{\mu^{-1}}^f}  + i \omega
+
+            :param float freq: Frequency
+            :rtype: scipy.sparse.csr_matrix
+            :return: A
+        """
+
+        MfMui = self.MfMui
+        MeSigmaI = self.MeSigmaI
+        C = self.mesh.edgeCurl
+        iomega = 1j * omega(freq) * sp.eye(self.mesh.nF)
+
+        A = C * (MeSigmaI * (C.T * MfMui)) + iomega
+
+        if self._makeASymmetric is True:
+            return MfMui.T*A
+        return A
+
+    def getADeriv_m(self, freq, u, v, adjoint=False):
+
+        MfMui = self.MfMui
+        C = self.mesh.edgeCurl
+        MeSigmaIDeriv = self.MeSigmaIDeriv
+        vec = C.T * (MfMui * u)
+
+        MeSigmaIDeriv = MeSigmaIDeriv(vec)
+
+        if adjoint:
+            if self._makeASymmetric is True:
+                v = MfMui * v
+            return MeSigmaIDeriv.T * (C.T * v)
+
+        if self._makeASymmetric is True:
+            return MfMui.T * ( C * ( MeSigmaIDeriv * v ) )
+        return C * ( MeSigmaIDeriv * v )
+
+
+    def getRHS(self, freq):
+        """
+            .. math ::
+                \mathbf{RHS} = \mathbf{s_m} + \mathbf{M^e_{\sigma}}^{-1}\mathbf{s_e}
+
+            :param float freq: Frequency
+            :rtype: numpy.ndarray (nE, nSrc)
+            :return: RHS
+        """
+
+        S_m, S_e = self.getSourceTerm(freq)
+        C = self.mesh.edgeCurl
+        MeSigmaI = self.MeSigmaI
+
+        RHS = S_m + C * ( MeSigmaI * S_e )
+
+        if self._makeASymmetric is True:
+            MfMui = self.MfMui
+            return MfMui.T * RHS
+
+        return RHS
+
+    def getRHSDeriv_m(self, freq, src, v, adjoint=False):
+        C = self.mesh.edgeCurl
+        S_m, S_e = src.eval(self)
+        MfMui = self.MfMui
+
+        if self._makeASymmetric and adjoint:
+            v = self.MfMui * v
+
+        MeSigmaIDeriv = self.MeSigmaIDeriv(S_e)
+        S_mDeriv, S_eDeriv = src.evalDeriv(self, adjoint)
+
+        if not adjoint:
+            RHSderiv = C * (MeSigmaIDeriv * v)
+            SrcDeriv = S_mDeriv(v) + C * (self.MeSigmaI * S_eDeriv(v))
+        elif adjoint:
+            RHSderiv = MeSigmaIDeriv.T * (C.T * v)
+            SrcDeriv = S_mDeriv(v) + self.MeSigmaI.T * (C.T * S_eDeriv(v))
+
+        if self._makeASymmetric is True and not adjoint:
+            return MfMui.T * (SrcDeriv + RHSderiv)
+
+        return RHSderiv + SrcDeriv
+
+
+
+##########################################################################################
+################################ H-J Formulation #########################################
+##########################################################################################
+
+
+class Problem_j(BaseFDEMProblem):
+    """
+        We eliminate \\\(\\\mathbf{h}\\\) using
+
+        .. math ::
+
+            \mathbf{h} = \\frac{1}{i \omega} \mathbf{M_{\mu}^e}^{-1} \\left(-\mathbf{C}^T \mathbf{M_{\\rho}^f} \mathbf{j}  + \mathbf{M^e} \mathbf{s_m} \\right)
+
+        and solve for \\\(\\\mathbf{j}\\\) using
+
+        .. math ::
+
+            \\left(\mathbf{C} \mathbf{M_{\mu}^e}^{-1} \mathbf{C}^T \mathbf{M_{\\rho}^f} + i \omega\\right)\mathbf{j} = \mathbf{C} \mathbf{M_{\mu}^e}^{-1} \mathbf{M^e} \mathbf{s_m} -i\omega\mathbf{s_e}
+
+        .. note::
+            This implementation does not yet work with full anisotropy!!
+
+    """
+
+    _fieldType = 'j'
+    _eqLocs    = 'EF'
+    fieldsPair = Fields_j
+
+    def __init__(self, mesh, **kwargs):
+        BaseFDEMProblem.__init__(self, mesh, **kwargs)
+
+    def getA(self, freq):
+        """
+            .. math ::
+                    \\mathbf{A} = \\mathbf{C}  \\mathbf{M^e_{mu^{-1}}} \\mathbf{C}^T \\mathbf{M^f_{\\sigma^{-1}}}  + i\\omega
+
+            :param float freq: Frequency
+            :rtype: scipy.sparse.csr_matrix
+            :return: A
+        """
+
+        MeMuI = self.MeMuI
+        MfRho = self.MfRho
+        C = self.mesh.edgeCurl
+        iomega = 1j * omega(freq) * sp.eye(self.mesh.nF)
+
+        A = C * MeMuI * C.T * MfRho + iomega
+
+        if self._makeASymmetric is True:
+            return MfRho.T*A
+        return A
+
+
+    def getADeriv_m(self, freq, u, v, adjoint=False):
+        """
+            In this case, we assume that electrical conductivity, \\\(\\\sigma\\\) is the physical property of interest (i.e. \\\(\\\sigma\\\) = model.transform). Then we want
+
+            .. math ::
+
+                \\frac{\mathbf{A(\sigma)} \mathbf{v}}{d \\mathbf{m}} &= \\mathbf{C}  \\mathbf{M^e_{mu^{-1}}} \\mathbf{C^T} \\frac{d \\mathbf{M^f_{\\sigma^{-1}}}}{d \\mathbf{m}}
+                &= \\mathbf{C}  \\mathbf{M^e_{mu}^{-1}} \\mathbf{C^T} \\frac{d \\mathbf{M^f_{\\sigma^{-1}}}}{d \\mathbf{\\sigma^{-1}}} \\frac{d \\mathbf{\\sigma^{-1}}}{d \\mathbf{\\sigma}} \\frac{d \\mathbf{\\sigma}}{d \\mathbf{m}}
+        """
+
+        MeMuI = self.MeMuI
+        MfRho = self.MfRho
+        C = self.mesh.edgeCurl
+        MfRhoDeriv_m = self.MfRhoDeriv(u)
+
+        if adjoint:
+            if self._makeASymmetric is True:
+                v = MfRho * v
+            return MfRhoDeriv_m.T * (C * (MeMuI.T * (C.T * v)))
+
+        if self._makeASymmetric is True:
+            return MfRho.T * (C * ( MeMuI * (C.T * (MfRhoDeriv_m * v) )))
+        return C * (MeMuI * (C.T * (MfRhoDeriv_m * v)))
+
+
+    def getRHS(self, freq):
+        """
+            .. math ::
+
+                \mathbf{RHS} = \mathbf{C} \mathbf{M_{\mu}^e}^{-1}\mathbf{s_m} -i\omega \mathbf{s_e}
+            :param float freq: Frequency
+            :rtype: numpy.ndarray (nE, nSrc)
+            :return: RHS
+        """
+
+        S_m, S_e = self.getSourceTerm(freq)
+        C = self.mesh.edgeCurl
+        MeMuI = self.MeMuI
+
+        RHS = C * (MeMuI * S_m) - 1j * omega(freq) * S_e
+        if self._makeASymmetric is True:
+            MfRho = self.MfRho
+            return MfRho.T*RHS
+
+        return RHS
+
+    def getRHSDeriv_m(self, freq, src, v, adjoint=False):
+        C = self.mesh.edgeCurl
+        MeMuI = self.MeMuI
+        S_mDeriv, S_eDeriv = src.evalDeriv(self, adjoint)
+
+        if adjoint:
+            if self._makeASymmetric:
+                MfRho = self.MfRho
+                v = MfRho*v
+            return S_mDeriv(MeMuI.T * (C.T * v)) - 1j * omega(freq) * S_eDeriv(v)
+
+        else:
+            RHSDeriv = C * (MeMuI * S_mDeriv(v)) - 1j * omega(freq) * S_eDeriv(v)
+
+            if self._makeASymmetric:
+                MfRho = self.MfRho
+                return MfRho.T * RHSDeriv
+            return RHSDeriv
+
+
+
+
+class Problem_h(BaseFDEMProblem):
+    """
+        We eliminate \\\(\\\mathbf{j}\\\) using
+
+        .. math ::
+
+            \mathbf{j} = \mathbf{C} \mathbf{h} - \mathbf{s_e}
+
+        and solve for \\\(\\\mathbf{h}\\\) using
+
+        .. math ::
+
+            \\left(\mathbf{C}^T \mathbf{M_{\\rho}^f} \mathbf{C} + i \omega \mathbf{M_{\mu}^e}\\right) \mathbf{h} = \mathbf{M^e} \mathbf{s_m} + \mathbf{C}^T \mathbf{M_{\\rho}^f} \mathbf{s_e}
+
+    """
+
+    _fieldType = 'h'
+    _eqLocs    = 'EF'
+    fieldsPair = Fields_h
+
+    def __init__(self, mesh, **kwargs):
+        BaseFDEMProblem.__init__(self, mesh, **kwargs)
+
+    def getA(self, freq):
+        """
+            .. math ::
+
+                \mathbf{A} = \mathbf{C}^T \mathbf{M_{\\rho}^f} \mathbf{C} + i \omega \mathbf{M_{\mu}^e}
+
+            :param float freq: Frequency
+            :rtype: scipy.sparse.csr_matrix
+            :return: A
+        """
+
+        MeMu = self.MeMu
+        MfRho = self.MfRho
+        C = self.mesh.edgeCurl
+
+        return C.T * (MfRho * C) + 1j*omega(freq)*MeMu
+
+    def getADeriv_m(self, freq, u, v, adjoint=False):
+
+        MeMu = self.MeMu
+        C = self.mesh.edgeCurl
+        MfRhoDeriv_m = self.MfRhoDeriv(C*u)
+
+        if adjoint:
+            return MfRhoDeriv_m.T * (C * v)
+        return C.T * (MfRhoDeriv_m * v)
+
+    def getRHS(self, freq):
+        """
+            .. math ::
+
+                \mathbf{RHS} = \mathbf{M^e} \mathbf{s_m} + \mathbf{C}^T \mathbf{M_{\\rho}^f} \mathbf{s_e}
+
+            :param float freq: Frequency
+            :rtype: numpy.ndarray (nE, nSrc)
+            :return: RHS
+        """
+
+        S_m, S_e = self.getSourceTerm(freq)
+        C = self.mesh.edgeCurl
+        MfRho  = self.MfRho
+
+        RHS = S_m + C.T * ( MfRho * S_e )
+
+        return RHS
+
+    def getRHSDeriv_m(self, freq, src, v, adjoint=False):
+        _, S_e = src.eval(self)
+        C = self.mesh.edgeCurl
+        MfRho  = self.MfRho
+
+        MfRhoDeriv = self.MfRhoDeriv(S_e)
+        if not adjoint:
+            RHSDeriv = C.T * (MfRhoDeriv * v)
+        elif adjoint:
+            RHSDeriv = MfRhoDeriv.T * (C * v)
+
+        S_mDeriv, S_eDeriv = src.evalDeriv(self, adjoint)
+
+        return RHSDeriv + S_mDeriv(v) + C.T * (MfRho * S_eDeriv(v))
+

SimPEG/EM/FDEM/ProblemFDEM.py

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

SimPEG/EM/FDEM/RxFDEM.py

@@ -1,139 +0,0 @@
-import SimPEG
-from SimPEG import sp
-
-class BaseRx(SimPEG.Survey.BaseRx):
-    """
-    Frequency domain receiver base class
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        assert(orientation in ['x','y','z']), "Orientation %s not known. Orientation must be in 'x', 'y', 'z'. Arbitrary orientations have not yet been implemented."%orientation
-        assert(component in ['real', 'imag']), "'component' must be 'real' or 'imag', not %s"%component
-
-        self.projComp = orientation
-        self.component = component
-
-        SimPEG.Survey.BaseRx.__init__(self, locs, rxType=None) #TODO: remove rxType from baseRx
-
-    def projGLoc(self, u):
-        """Grid Location projection (e.g. Ex Fy ...)"""
-        return u._GLoc(self.projField) + self.projComp
-
-    def eval(self, src, mesh, f):
-        """
-        Project fields to recievers to get data.
-
-        :param Source src: FDEM source
-        :param Mesh mesh: mesh used
-        :param Fields f: fields object
-        :rtype: numpy.ndarray
-        :return: fields projected to recievers
-        """
-
-        P = self.getP(mesh, self.projGLoc(f))
-        f_part_complex = f[src, self.projField]
-        f_part = getattr(f_part_complex, self.component) # get the real or imag component
-
-        return P*f_part
-
-    def evalDeriv(self, src, mesh, f, v, adjoint=False):
-        """
-        Derivative of projected fields with respect to the inversion model times a vector.
-
-        :param Source src: FDEM source
-        :param Mesh mesh: mesh used
-        :param Fields f: fields object
-        :param numpy.ndarray v: vector to multiply
-        :rtype: numpy.ndarray
-        :return: fields projected to recievers
-        """
-
-        P = self.getP(mesh, self.projGLoc(f))
-
-        if not adjoint:
-            Pv_complex = P * v
-            Pv = getattr(Pv_complex, self.component)
-        elif adjoint:
-            Pv_real = P.T * v
-
-            if self.component == 'imag':
-                Pv = 1j*Pv_real
-            elif self.component == 'real':
-                Pv = Pv_real.astype(complex)
-            else:
-                raise NotImplementedError('must be real or imag')
-
-        return Pv
-
-
-class Point_e(BaseRx):
-    """
-    Electric field FDEM receiver
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        self.projField = 'e'
-        super(Point_e, self).__init__(locs, orientation, component)
-
-
-class Point_b(BaseRx):
-    """
-    Magnetic flux FDEM receiver
-
-    :param numpy.ndarray locs: receiver locations (ie. :code:`np.r_[x,y,z]`)
-    :param string orientation: receiver orientation 'x', 'y' or 'z'
-    :param string component: real or imaginary component 'real' or 'imag'
-    """
-
-    def __init__(self, locs, orientation=None, component=None):
-        self.projField = 'b'
-        super(Point_b, self).__init__(locs, orientation, component)
-
-class Point_bSecondary(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 = 'bSecondary'
-        super(Point_bSecondary, 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

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

SimPEG/EM/FDEM/SurveyFDEM.py

@@ -1,29 +1,119 @@
 import SimPEG
 from SimPEG.EM.Utils import *
-from SimPEG.EM.Base import BaseEMSurvey
 from scipy.constants import mu_0
 from SimPEG.Utils import Zero, Identity
 import SrcFDEM as Src
-import RxFDEM as Rx
-from SimPEG import sp
 
-class Survey(BaseEMSurvey):
+
+####################################################
+# Receivers
+####################################################
+
+class Rx(SimPEG.Survey.BaseRx):
+
+    knownRxTypes = {
+                    'exr':['e', 'Ex', 'real'],
+                    'eyr':['e', 'Ey', 'real'],
+                    'ezr':['e', 'Ez', 'real'],
+                    'exi':['e', 'Ex', 'imag'],
+                    'eyi':['e', 'Ey', 'imag'],
+                    'ezi':['e', 'Ez', 'imag'],
+
+                    'bxr':['b', 'Fx', 'real'],
+                    'byr':['b', 'Fy', 'real'],
+                    'bzr':['b', 'Fz', 'real'],
+                    'bxi':['b', 'Fx', 'imag'],
+                    'byi':['b', 'Fy', 'imag'],
+                    'bzi':['b', 'Fz', 'imag'],
+
+                    'bxr_sec':['bSecondary', 'Fx', 'real'],
+                    'byr_sec':['bSecondary', 'Fy', 'real'],
+                    'bzr_sec':['bSecondary', 'Fz', 'real'],
+                    'bxi_sec':['bSecondary', 'Fx', 'imag'],
+                    'byi_sec':['bSecondary', 'Fy', 'imag'],
+                    'bzi_sec':['bSecondary', 'Fz', 'imag'],
+
+                    'jxr':['j', 'Fx', 'real'],
+                    'jyr':['j', 'Fy', 'real'],
+                    'jzr':['j', 'Fz', 'real'],
+                    'jxi':['j', 'Fx', 'imag'],
+                    'jyi':['j', 'Fy', 'imag'],
+                    'jzi':['j', 'Fz', 'imag'],
+
+                    'hxr':['h', 'Ex', 'real'],
+                    'hyr':['h', 'Ey', 'real'],
+                    'hzr':['h', 'Ez', 'real'],
+                    'hxi':['h', 'Ex', 'imag'],
+                    'hyi':['h', 'Ey', 'imag'],
+                    'hzi':['h', 'Ez', '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 projGLoc(self):
+        """Grid Location projection (e.g. Ex Fy ...)"""
+        return self.knownRxTypes[self.rxType][1]
+
+    @property
+    def projComp(self):
+        """Component projection (real/imag)"""
+        return self.knownRxTypes[self.rxType][2]
+
+    def projectFields(self, src, mesh, u):
+        P = self.getP(mesh)
+        u_part_complex = u[src, self.projField]
+        # get the real or imag component
+        real_or_imag = self.projComp
+        u_part = getattr(u_part_complex, real_or_imag)
+        return P*u_part
+
+    def projectFieldsDeriv(self, src, mesh, u, v, adjoint=False):
+        P = self.getP(mesh)
+
+        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(SimPEG.Survey.BaseSurvey):
     """
-    Frequency domain electromagnetic survey
-
-    :param list srcList: list of FDEM sources used in the survey
+        docstring for SurveyFDEM
     """
 
     srcPair = Src.BaseSrc
-    rxPair = Rx.BaseRx
 
     def __init__(self, srcList, **kwargs):
         # Sort these by frequency
         self.srcList = srcList
-        BaseEMSurvey.__init__(self, srcList, **kwargs)
+        SimPEG.Survey.BaseSurvey.__init__(self, **kwargs)
 
         _freqDict = {}
-        for src in srcList:
+        for src in self.srcList:
             if src.freq not in _freqDict:
                 _freqDict[src.freq] = []
             _freqDict[src.freq] += [src]
@@ -43,7 +133,6 @@ class Survey(BaseEMSurvey):
 
     @property
     def nSrcByFreq(self):
-        """Number of sources at each frequency"""
         if getattr(self, '_nSrcByFreq', None) is None:
             self._nSrcByFreq = {}
             for freq in self.freqs:
@@ -51,12 +140,16 @@ class Survey(BaseEMSurvey):
         return self._nSrcByFreq
 
     def getSrcByFreq(self, freq):
-        """
-        Returns the sources associated with a specific frequency.
-        :param float freq: frequency for which we look up sources
-        :rtype: dictionary
-        :return: sources at the sepcified frequency
-        """
+        """Returns the sources associated with a specific frequency."""
         assert freq in self._freqDict, "The requested frequency is not in this survey."
         return self._freqDict[freq]
 
+    def projectFields(self, u):
+        data = SimPEG.Survey.Data(self)
+        for src in self.srcList:
+            for rx in src.rxList:
+                data[src, rx] = rx.projectFields(src, self.mesh, u)
+        return data
+
+    def projectFieldsDeriv(self, u):
+        raise Exception('Use Sources to project fields deriv.')

SimPEG/EM/FDEM/__init__.py

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

SimPEG/EM/Static/DC/BoundaryUtils.py

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

SimPEG/EM/Static/DC/FieldsDC.py

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

SimPEG/EM/Static/DC/FieldsDC_2D.py

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

SimPEG/EM/Static/DC/ProblemDC.py

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

SimPEG/EM/Static/DC/ProblemDC_2D.py

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

SimPEG/EM/Static/DC/RxDC.py

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

SimPEG/EM/Static/DC/SrcDC.py

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

SimPEG/EM/Static/DC/SurveyDC.py

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

SimPEG/EM/Static/DC/Utils.py

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

SimPEG/EM/Static/DC/__init__.py

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

SimPEG/EM/Static/IP/ProblemIP.py

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

SimPEG/EM/Static/IP/SurveyIP.py

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

SimPEG/EM/Static/IP/__init__.py

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

SimPEG/EM/Static/SIP/ProblemSIP.py

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

SimPEG/EM/Static/SIP/Regularization.py

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

SimPEG/EM/Static/SIP/RxSIP.py

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

SimPEG/EM/Static/SIP/SrcSIP.py

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

SimPEG/EM/Static/SIP/SurveySIP.py

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

SimPEG/EM/Static/SIP/__init__.py

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

SimPEG/EM/Static/Utils/StaticUtils.py

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

SimPEG/EM/Static/Utils/__init__.py

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

SimPEG/EM/Static/__init__.py

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

SimPEG/EM/TDEM/BaseTDEM.py

@@ -27,7 +27,6 @@ class FieldsTDEM(Problem.TimeFields):
             else:
                 e = np.zeros((nE,nSrc)) # if nSrc == 1 else (nE, nSrc))
             u = np.concatenate((u, b, e))
-
         return Utils.mkvc(u,nSrc)
 
 
@@ -108,11 +107,11 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem):
         Ainv.clean()
         return F
 
-    def Jvec(self, m, v, f=None):
+    def Jvec(self, m, v, u=None):
         """
             :param numpy.array m: Conductivity model
             :param numpy.ndarray v: vector (model object)
-            :param simpegEM.TDEM.FieldsTDEM f: Fields resulting from m
+            :param simpegEM.TDEM.FieldsTDEM u: Fields resulting from m
             :rtype: numpy.ndarray
             :return: w (data object)
 
@@ -125,15 +124,15 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem):
         """
         if self.verbose: print '%s\nCalculating J(v)\n%s'%('*'*50,'*'*50)
         self.curModel = m
-        if f is None:
-            f = self.fields(m)
-        p = self.Gvec(m, v, f)
+        if u is None:
+            u = self.fields(m)
+        p = self.Gvec(m, v, u)
         y = self.solveAh(m, p)
-        Jv = self.survey.evalDeriv(f, v=y)
+        Jv = self.survey.projectFieldsDeriv(u, v=y)
         if self.verbose: print '%s\nDone calculating J(v)\n%s'%('*'*50,'*'*50)
         return - mkvc(Jv)
 
-    def Jtvec(self, m, v, f=None):
+    def Jtvec(self, m, v, u=None):
         """
             :param numpy.array m: Conductivity model
             :param numpy.ndarray,SimPEG.Survey.Data v: vector (data object)
@@ -150,15 +149,15 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem):
         """
         if self.verbose: print '%s\nCalculating J^T(v)\n%s'%('*'*50,'*'*50)
         self.curModel = m
-        if f is None:
-            f = self.fields(m)
+        if u is None:
+            u = self.fields(m)
 
         if not isinstance(v, self.dataPair):
             v = self.dataPair(self.survey, v)
 
-        p = self.survey.evalDeriv(f, v=v, adjoint=True)
+        p = self.survey.projectFieldsDeriv(u, v=v, adjoint=True)
         y = self.solveAht(m, p)
-        w = self.Gtvec(m, y, f)
+        w = self.Gtvec(m, y, u)
         if self.verbose: print '%s\nDone calculating J^T(v)\n%s'%('*'*50,'*'*50)
         return - mkvc(w)
 

SimPEG/EM/TDEM/FieldsTDEM.py

@@ -1,142 +0,0 @@
-import numpy as np
-import scipy.sparse as sp
-import SimPEG
-from SimPEG import Utils
-from SimPEG.EM.Utils import omega
-from SimPEG.Utils import Zero, Identity
-
-class Fields(SimPEG.Problem.TimeFields):
-    """
-
-    Fancy Field Storage for a TDEM 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
-
-    .. code-block:: python
-
-        f = problem.fields(m)
-        e = f[srcList,'e']
-        b = f[srcList,'b']
-
-    If accessing all sources for a given field, use the :code:`:`
-
-    .. code-block:: python
-
-        f = problem.fields(m)
-        e = f[:,'e']
-        b = f[:,'b']
-
-    The array returned will be size (nE or nF, nSrcs :math:`\\times` nFrequencies)
-    """
-
-    knownFields = {}
-    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_Derivs(Fields):
-    knownFields = {
-                    'bDeriv': 'F',
-                    'eDeriv': 'E',
-                    'hDeriv': 'E',
-                    'jDeriv': 'F'
-                  }
-
-
-class Fields_b(Fields):
-    """Fancy Field Storage for a TDEM survey."""
-    knownFields = {'bSolution': 'F'}
-    aliasFields = {
-                    'b': ['bSolution', 'F', '_b'],
-                    'e': ['bSolution', 'E', '_e'],
-                  }
-
-    def startup(self):
-        self.MeSigmaI      = self.survey.prob.MeSigmaI
-        self.MeSigmaIDeriv = self.survey.prob.MeSigmaIDeriv
-        self.edgeCurl      = self.survey.prob.mesh.edgeCurl
-        self.MfMui         = self.survey.prob.MfMui
-
-    def _b(self, bSolution, srcList, tInd):
-        return bSolution
-
-    def _bDeriv_u(self, tInd, src, dun_dm_v, adjoint=False):
-        return Identity()*dun_dm_v
-
-    def _bDeriv_m(self, tInd, src, v, adjoint=False):
-        return Zero()
-
-    # 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)
-
-    def _e(self, bSolution, srcList, tInd):
-        e = self.MeSigmaI * ( self.edgeCurl.T * ( self.MfMui * bSolution ) )
-        for i, src in enumerate(srcList):
-            _, S_e = src.eval(self.survey.prob, self.survey.prob.times[tInd])
-            e[:,i] = e[:,i] - self.MeSigmaI * S_e
-        return e
-
-    def _eDeriv_u(self, tInd, src, dun_dm_v, adjoint = False):
-        if adjoint is True:
-            return self.MfMui.T * ( self.edgeCurl * ( self.MeSigmaI.T * dun_dm_v ) )
-        return self.MeSigmaI * ( self.edgeCurl.T * ( self.MfMui * dun_dm_v ) )
-
-    def _eDeriv_m(self, tInd, src, v, adjoint = False):
-        _, S_e = src.eval(self.survey.prob, self.survey.prob.times[tInd])
-        bSolution = self[[src],'bSolution',tInd]
-
-        _, S_eDeriv = src.evalDeriv(self.survey.prob.times[tInd], self, adjoint=adjoint)
-
-        if adjoint is True:
-            return self.MeSigmaIDeriv(-S_e + self.edgeCurl.T * ( self.MfMui * bSolution ) ).T * v - S_eDeriv(self.MeSigmaI.T * v)
-
-        return self.MeSigmaIDeriv(-S_e + self.edgeCurl.T * ( self.MfMui * bSolution)) * v - self.MeSigmaI * S_eDeriv(v)
-
-
-
-class Fields_e(Fields):
-    """Fancy Field Storage for a TDEM survey."""
-    knownFields = {'eSolution': 'E'}
-    aliasFields = {
-                    'e': ['eSolution', 'E', '_e'],
-                    'b': ['eSolution', 'F', '_b'],
-                  }
-
-    def startup(self):
-        self.MeSigmaI      = self.survey.prob.MeSigmaI
-        self.MeSigmaIDeriv = self.survey.prob.MeSigmaIDeriv
-        self.edgeCurl      = self.survey.prob.mesh.edgeCurl
-        self.MfMui         = self.survey.prob.MfMui
-
-
-    def _e(self, eSolution, srcList, tInd):
-        return eSolution
-
-    def _eDeriv_u(self, tInd, src, dun_dm_v, adjoint = False):
-        return dun_dm_v
-
-    def _eDeriv_m(self, tInd, src, v, adjoint = False):
-        return Zero()
-
-    def _b(self, eSolution, srcList, tInd):
-        raise NotImplementedError
-
-    def _bDeriv_u(self, tInd, src, dun_dm_v, adjoint=False):
-        raise NotImplementedError
-
-    def _bDeriv_m(self, tInd, src, v, adjoint=False):
-        raise NotImplementedError
-
-    # 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)

SimPEG/EM/TDEM/SrcTDEM.py

@@ -1,246 +0,0 @@
-import SimPEG
-from SimPEG import np, Utils
-from SimPEG.Utils import Zero, Identity
-from scipy.constants import mu_0
-from SimPEG.EM.Utils import *
-
-####################################################
-# Sources
-####################################################
-
-class BaseWaveform(object):
-
-    def __init__(self, offTime=0., hasInitialFields=False):
-        self.offTime = offTime
-        self.hasInitialFields = hasInitialFields
-
-    def _assertMatchesPair(self, pair):
-        assert (isinstance(self, pair)
-            ), "Waveform object must be an instance of a %s BaseWaveform class."%(pair.__name__)
-
-    def eval(self, time):
-        raise NotImplementedError
-
-    def evalDeriv(self, time):
-        raise NotImplementedError # needed for E-formulation
-
-
-class StepOffWaveform(BaseWaveform):
-
-    def __init__(self, offTime=0.):
-        BaseWaveform.__init__(self, offTime, hasInitialFields=True)
-
-    def eval(self, time):
-        return 0.
-
-
-class RawWaveform(BaseWaveform):
-
-    def __init__(self, offTime=0.):
-        BaseWaveform.__init__(self, offTime, hasInitialFields=True)
-
-    def eval(self, time):
-        raise NotImplementedError('RawWaveform has not been implemented, you should write it!')
-
-
-class TriangularWaveform(BaseWaveform):
-
-    def __init__(self, offTime=0.):
-        BaseWaveform.__init__(self, offTime, hasInitialFields=True)
-
-    def eval(self, time):
-        raise NotImplementedError('TriangularWaveform has not been implemented, you should write it!')
-
-
-
-class BaseSrc(SimPEG.Survey.BaseSrc):
-
-    # rxPair = Rx
-    integrate = True
-    waveformPair = BaseWaveform
-
-    @property
-    def waveform(self):
-        "A waveform instance is not None"
-        return getattr(self, '_waveform', None)
-    @waveform.setter
-    def waveform(self, val):
-        if self.waveform is None:
-            val._assertMatchesPair(self.waveformPair)
-            self._mapping = val
-        else:
-            self._mapping = self.PropMap(val)
-
-
-    def __init__(self, rxList, waveform = StepOffWaveform(), **kwargs):
-        self.waveform = waveform
-        SimPEG.Survey.BaseSrc.__init__(self, rxList, **kwargs)
-
-
-    def bInitial(self, prob):
-        return Zero()
-
-    def bInitialDeriv(self, prob, v=None, adjoint=False):
-        return Zero()
-
-    def eInitial(self, prob):
-        return Zero()
-
-    def eInitialDeriv(self, prob, v=None, adjoint=False):
-        return Zero()
-
-    def eval(self, prob, time):
-        S_m = self.S_m(prob, time)
-        S_e = self.S_e(prob, time)
-        return S_m, S_e
-
-    def evalDeriv(self, prob, time, v=None, adjoint=False):
-        if v is not None:
-            return self.S_mDeriv(prob, time, v, adjoint), self.S_eDeriv(prob, time, v, adjoint)
-        else:
-            return lambda v: self.S_mDeriv(prob, time, v, adjoint), lambda v: self.S_eDeriv(prob, time, v, adjoint)
-
-    def S_m(self, prob, time):
-        return Zero()
-
-    def S_e(self, prob, time):
-        return Zero()
-
-    def S_mDeriv(self, prob, time, v=None, adjoint=False):
-        return Zero()
-
-    def S_eDeriv(self, prob, time, v=None, adjoint=False):
-        return Zero()
-
-
-class MagDipole(BaseSrc):
-
-    waveform = None
-    loc = None
-    orientation = 'Z'
-    moment = 1.
-    mu = mu_0
-
-    def __init__(self, rxList, **kwargs):
-        assert self.orientation in ['X','Y','Z'], "Orientation (right now) doesn't actually do anything! The methods in SrcUtils should take care of this..."
-        self.integrate = False
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    def _bfromVectorPotential(self, prob):
-        if prob._eqLocs is 'FE':
-            gridX = prob.mesh.gridEx
-            gridY = prob.mesh.gridEy
-            gridZ = prob.mesh.gridEz
-            C = prob.mesh.edgeCurl
-
-        elif prob._eqLocs is 'EF':
-            gridX = prob.mesh.gridFx
-            gridY = prob.mesh.gridFy
-            gridZ = prob.mesh.gridFz
-            C = prob.mesh.edgeCurl.T
-
-
-        if prob.mesh._meshType is 'CYL':
-            if not prob.mesh.isSymmetric:
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            a = MagneticDipoleVectorPotential(self.loc, gridY, 'y', mu=self.mu, moment=self.moment)
-
-        else:
-            srcfct = MagneticDipoleVectorPotential
-            ax = srcfct(self.loc, gridX, 'x', mu=self.mu, moment=self.moment)
-            ay = srcfct(self.loc, gridY, 'y', mu=self.mu, moment=self.moment)
-            az = srcfct(self.loc, gridZ, 'z', mu=self.mu, moment=self.moment)
-            a = np.concatenate((ax, ay, az))
-
-        return C*a
-
-
-    def bInitial(self, prob):
-
-        if self.waveform.hasInitialFields is False:
-            return Zero()
-
-        return self._bfromVectorPotential(prob)
-
-    def eInitial(self, prob):
-
-        if self.waveform.hasInitialFields is False:
-            return Zero()
-
-        b = self.bInitial(prob)
-        MeSigmaI = prob.MeSigmaI
-        MfMui = prob.MfMui
-        C = prob.mesh.edgeCurl
-
-        return MeSigmaI * (C.T * (MfMui * b))
-
-    def eInitialDeriv(self, prob, v=None, adjoint=False):
-
-        if self.waveform.hasInitialFields is False:
-            return Zero()
-
-        b = self.bInitial(prob)
-        MeSigmaIDeriv = prob.MeSigmaIDeriv
-        MfMui = prob.MfMui
-        C = prob.mesh.edgeCurl
-        S_e = self.S_e(prob, prob.t0)
-
-        # S_e doesn't depend on the model
-
-        if adjoint:
-            return MeSigmaIDeriv( -S_e + C.T * ( MfMui * b ) ).T * v
-
-        return MeSigmaIDeriv( -S_e + C.T * ( MfMui * b ) ) * v
-
-
-    def S_m(self, prob, time):
-        if self.waveform.hasInitialFields is False:
-            raise NotImplementedError
-        return Zero()
-
-    def S_e(self, prob, time):
-        if self.waveform.hasInitialFields is False:
-            raise NotImplementedError
-        return Zero()
-
-class CircularLoop(MagDipole):
-
-    waveform = None
-    loc = None
-    orientation = 'Z'
-    radius = None
-    mu = mu_0
-
-    def __init__(self, rxList, **kwargs):
-        assert self.orientation in ['X','Y','Z'], "Orientation (right now) doesn't actually do anything! The methods in SrcUtils should take care of this..."
-        self.integrate = False
-        BaseSrc.__init__(self, rxList, **kwargs)
-
-    def _bfromVectorPotential(self, prob):
-        if prob._eqLocs is 'FE':
-            gridX = prob.mesh.gridEx
-            gridY = prob.mesh.gridEy
-            gridZ = prob.mesh.gridEz
-            C = prob.mesh.edgeCurl
-
-        elif prob._eqLocs is 'EF':
-            gridX = prob.mesh.gridFx
-            gridY = prob.mesh.gridFy
-            gridZ = prob.mesh.gridFz
-            C = prob.mesh.edgeCurl.T
-
-
-        if prob.mesh._meshType is 'CYL':
-            if not prob.mesh.isSymmetric:
-                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
-            a = MagneticLoopVectorPotential(self.loc, gridY, 'y', radius=self.radius, mu=self.mu)
-
-        else:
-            srcfct = MagneticLoopVectorPotential
-            ax = srcfct(self.loc, gridX, 'x', mu=self.mu, radius=self.radius)
-            ay = srcfct(self.loc, gridY, 'y', mu=self.mu, radius=self.radius)
-            az = srcfct(self.loc, gridZ, 'z', mu=self.mu, radius=self.radius)
-            a = np.concatenate((ax, ay, az))
-
-        return C*a
-

SimPEG/EM/TDEM/SurveyTDEM.py

@@ -1,16 +1,10 @@
-import SimPEG
-from SimPEG import np, Utils
-from SimPEG.Utils import Zero, Identity
-from scipy.constants import mu_0
+from SimPEG import Utils, Survey, np
+from SimPEG.Survey import BaseSurvey
 from SimPEG.EM.Utils import *
-import SrcTDEM as Src
+from BaseTDEM import FieldsTDEM
 
 
-####################################################
-# Receivers
-####################################################
-
-class Rx(SimPEG.Survey.BaseTimeRx):
+class RxTDEM(Survey.BaseTimeRx):
 
     knownRxTypes = {
                     'ex':['e', 'Ex', 'N'],
@@ -27,7 +21,7 @@ class Rx(SimPEG.Survey.BaseTimeRx):
                    }
 
     def __init__(self, locs, times, rxType):
-        SimPEG.Survey.BaseTimeRx.__init__(self, locs, times, rxType)
+        Survey.BaseTimeRx.__init__(self, locs, times, rxType)
 
     @property
     def projField(self):
@@ -57,65 +51,149 @@ class Rx(SimPEG.Survey.BaseTimeRx):
         else:
             return timeMesh.getInterpolationMat(self.times, self.projTLoc)
 
-    def eval(self, src, mesh, timeMesh, u):
+    def projectFields(self, src, mesh, timeMesh, u):
         P = self.getP(mesh, timeMesh)
         u_part = Utils.mkvc(u[src, self.projField, :])
         return P*u_part
 
-    def evalDeriv(self, src, mesh, timeMesh, v, adjoint=False):
+    def projectFieldsDeriv(self, src, mesh, timeMesh, u, v, adjoint=False):
         P = self.getP(mesh, timeMesh)
+
         if not adjoint:
-            return P * v #Utils.mkvc(v[src, self.projField+'Deriv', :])
+            return P * Utils.mkvc(v[src, self.projField, :])
         elif adjoint:
-            # dP_dF_T = P.T * v #[src, self]
-            # newshape = (len(dP_dF_T)/timeMesh.nN, timeMesh.nN )
-            return P.T * v #np.reshape(dP_dF_T, newshape, order='F')
+            return P.T * v[src, self]
 
 
-####################################################
-# Survey
-####################################################
+class SrcTDEM(Survey.BaseSrc):
+    rxPair = RxTDEM
+    radius = None
 
-class Survey(SimPEG.Survey.BaseSurvey):
+    def getInitialFields(self, mesh):
+        F0 = getattr(self, '_getInitialFields_' + self.srcType)(mesh)
+        return F0
+
+    def getJs(self, mesh, time):
+        return None
+
+
+class SrcTDEM_VMD_MVP(SrcTDEM):
+
+    def __init__(self,rxList,loc,waveformType="STEPOFF"):
+        self.loc = loc
+        self.waveformType = waveformType
+        SrcTDEM.__init__(self,rxList)
+
+    def getInitialFields(self, mesh):
+        """Vertical magnetic dipole, magnetic vector potential"""
+        if self.waveformType == "STEPOFF":
+            print ">> Step waveform: Non-zero initial condition"        
+            if mesh._meshType is 'CYL':
+                if mesh.isSymmetric:
+                    MVP = MagneticDipoleVectorPotential(self.loc, mesh, 'Ey')
+                else:
+                    raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
+            elif mesh._meshType is 'TENSOR':
+                MVP = MagneticDipoleVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'])
+            else:
+                raise Exception('Unknown mesh for VMD') 
+            return {"b": mesh.edgeCurl*MVP}               
+        elif self.waveformType == "GENERAL":
+            print ">> General waveform: Zero initial condition"
+            return {"b": np.zeros(mesh.nF)}
+        else:
+            raise NotImplementedError("Only use STEPOFF or GENERAL")
+
+    def getMeS(self, mesh, MfMui):
+        if mesh._meshType is 'CYL':
+            if mesh.isSymmetric:
+                MVP = MagneticDipoleVectorPotential(self.loc, mesh, 'Ey')
+            else:
+                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
+        elif mesh._meshType is 'TENSOR':
+            MVP = MagneticDipoleVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'])
+        else:
+            raise Exception('Unknown mesh for VMD')            
+        return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP
+
+
+class SrcTDEM_CircularLoop_MVP(SrcTDEM):
+    def __init__(self,rxList,loc,radius,waveformType="STEPOFF"):
+        self.loc = loc
+        self.radius = radius
+        self.waveformType = waveformType
+        SrcTDEM.__init__(self,rxList)        
+
+    def getInitialFields(self, mesh):
+        """Circular Loop, magnetic vector potential"""
+        if self.waveformType == "STEPOFF":
+            print ">> Step waveform: Non-zero initial condition"
+            if mesh._meshType is 'CYL':
+                if mesh.isSymmetric:
+                    MVP = MagneticLoopVectorPotential(self.loc, mesh, 'Ey', self.radius)
+                else:
+                    raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
+            elif mesh._meshType is 'TENSOR':
+                MVP = MagneticLoopVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'], self.radius)
+            else:
+                raise Exception('Unknown mesh for CircularLoop')
+            return {"b": mesh.edgeCurl*MVP}
+        elif self.waveformType == "GENERAL":
+            print ">> General waveform: Zero initial condition"
+            return {"b": np.zeros(mesh.nF)}
+        else:
+            raise NotImplementedError("Only use STEPOFF or GENERAL")
+
+    def getMeS(self, mesh, MfMui):
+        if mesh._meshType is 'CYL':
+            if mesh.isSymmetric:
+                MVP = MagneticLoopVectorPotential(self.loc, mesh, 'Ey', self.radius)
+            else:
+                raise NotImplementedError('Non-symmetric cyl mesh not implemented yet!')
+        elif mesh._meshType is 'TENSOR':
+            MVP = MagneticLoopVectorPotential(self.loc, mesh, ['Ex','Ey','Ez'], self.radius)
+        else:
+            raise Exception('Unknown mesh for CircularLoop')            
+        return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP
+
+
+class SurveyTDEM(Survey.BaseSurvey):
     """
-    Time domain electromagnetic survey
+        docstring for SurveyTDEM
     """
-
-    srcPair = Src.BaseSrc
-    rxPair = Rx
+    srcPair = SrcTDEM
 
     def __init__(self, srcList, **kwargs):
         # Sort these by frequency
         self.srcList = srcList
-        SimPEG.Survey.BaseSurvey.__init__(self, **kwargs)
+        Survey.BaseSurvey.__init__(self, **kwargs)
 
-    def eval(self, u):
-        data = SimPEG.Survey.Data(self)
+    def projectFields(self, u):
+        data = Survey.Data(self)
         for src in self.srcList:
             for rx in src.rxList:
-                data[src, rx] = rx.eval(src, self.mesh, self.prob.timeMesh, u)
+                data[src, rx] = rx.projectFields(src, self.mesh, self.prob.timeMesh, u)
         return data
 
-    def evalDeriv(self, u, v=None, adjoint=False):
-        raise Exception('Use Receivers to project fields deriv.')
-        # assert v is not None, 'v to multiply must be provided.'
+    def projectFieldsDeriv(self, u, v=None, adjoint=False):
+        assert v is not None, 'v to multiply must be provided.'
 
-        # if not adjoint:
-        #     data = SimPEG.Survey.Data(self)
-        #     for src in self.srcList:
-        #         for rx in src.rxList:
-        #             data[src, rx] = rx.evalDeriv(src, self.mesh, self.prob.timeMesh, u, v)
-        #     return data
-        # else:
-        #     f = FieldsTDEM(self.mesh, self)
-        #     for src in self.srcList:
-        #         for rx in src.rxList:
-        #             Ptv = rx.evalDeriv(src, self.mesh, self.prob.timeMesh, u, v, adjoint=True)
-        #             Ptv = Ptv.reshape((-1, self.prob.timeMesh.nN), order='F')
-        #             if rx.projField not in f: # first time we are projecting
-        #                 f[src, rx.projField, :] = Ptv
-        #             else: # there are already fields, so let's add to them!
-        #                 f[src, rx.projField, :] += Ptv
-        #     return f
+        if not adjoint:
+            data = Survey.Data(self)
+            for src in self.srcList:
+                for rx in src.rxList:
+                    data[src, rx] = rx.projectFieldsDeriv(src, self.mesh, self.prob.timeMesh, u, v)
+            return data
+        else:
+            f = FieldsTDEM(self.mesh, self)
+            for src in self.srcList:
+                for rx in src.rxList:
+                    Ptv = rx.projectFieldsDeriv(src, self.mesh, self.prob.timeMesh, u, v, adjoint=True)
+                    Ptv = Ptv.reshape((-1, self.prob.timeMesh.nN), order='F')
+                    if rx.projField not in f: # first time we are projecting
+                        f[src, rx.projField, :] = Ptv
+                    else: # there are already fields, so let's add to them!
+                        f[src, rx.projField, :] += Ptv
+            return f
 
 

SimPEG/EM/TDEM/TDEM.py

@@ -1,553 +0,0 @@
-from SimPEG import Problem, Utils, np, sp, Solver as SimpegSolver
-from SimPEG.EM.Base import BaseEMProblem
-from SimPEG.EM.TDEM.SurveyTDEM import Survey as SurveyTDEM
-from SimPEG.EM.TDEM.FieldsTDEM import *
-from scipy.constants import mu_0
-import time
-
-class BaseTDEMProblem(Problem.BaseTimeProblem, BaseEMProblem):
-    """
-    We start with the first order form of Maxwell's equations
-    """
-    surveyPair = SurveyTDEM
-    fieldsPair = Fields
-
-    def __init__(self, mesh, mapping=None, **kwargs):
-        Problem.BaseTimeProblem.__init__(self, mesh, mapping=mapping, **kwargs)
-
-    def fields(self, m):
-        """
-        Solve the forward problem for the fields.
-
-        :param numpy.array m: inversion model (nP,)
-        :rtype numpy.array:
-        :return F: fields
-        """
-
-        tic = time.time()
-        self.curModel = m
-
-        F = self.fieldsPair(self.mesh, self.survey)
-
-        # set initial fields
-        F[:,self._fieldType+'Solution',0] = self.getInitialFields()
-
-        # timestep to solve forward
-        if self.verbose: print '%s\nCalculating fields(m)\n%s'%('*'*50,'*'*50)
-        Ainv = None
-        for tInd, dt in enumerate(self.timeSteps):
-            if Ainv is not None and (tInd > 0 and dt != self.timeSteps[tInd - 1]):# keep factors if dt is the same as previous step b/c A will be the same
-                Ainv.clean()
-                Ainv = None
-
-            if Ainv is None:
-                A = self.getAdiag(tInd)
-                if self.verbose: print 'Factoring...   (dt = %e)'%dt
-                Ainv = self.Solver(A, **self.solverOpts)
-                if self.verbose: print 'Done'
-
-            rhs = self.getRHS(tInd+1) # this is on the nodes of the time mesh
-            Asubdiag = self.getAsubdiag(tInd)
-
-            if self.verbose: print ('    Solving...   (tInd = %i)')% (tInd+1)
-            sol = Ainv * (rhs - Asubdiag * F[:,self._fieldType+'Solution',tInd]) # taking a step
-
-            if self.verbose: print '    Done...'
-
-            if sol.ndim == 1:
-                sol.shape = (sol.size,1)
-            F[:,self._fieldType+'Solution',tInd+1] = sol
-        if self.verbose: print '%s\nDone calculating fields(m)\n%s'%('*'*50,'*'*50)
-        Ainv.clean()
-        return F
-
-
-    def Jvec(self, m, v, f=None):
-        """
-        Jvec computes the sensitivity times a vector
-
-        .. math::
-            \mathbf{J} \mathbf{v} = \\frac{d\mathbf{P}}{d\mathbf{F}} \left( \\frac{d\mathbf{F}}{d\mathbf{u}} \\frac{d\mathbf{u}}{d\mathbf{m}} + \\frac{\partial\mathbf{F}}{\partial\mathbf{m}} \\right) \mathbf{v}
-
-        where
-
-        .. math::
-            \mathbf{A} \\frac{d\mathbf{u}}{d\mathbf{m}} + \\frac{d\mathbf{A}(\mathbf{u})}{d\mathbf{m}} = \\frac{d \mathbf{RHS}}{d \mathbf{m}}
-        """
-
-        if f is None:
-           f = self.fields(m)
-
-        ftype = self._fieldType + 'Solution' # the thing we solved for
-        self.curModel = m
-
-        # mat to store previous time-step's solution deriv times a vector for each source
-        # size: nu x nSrc
-
-        # this is a bit silly
-
-        # if self._fieldType is 'b' or self._fieldType is 'j':
-        #     ifields = np.zeros((self.mesh.nF, len(Srcs)))
-        # elif self._fieldType is 'e' or self._fieldType is 'h':
-        #     ifields = np.zeros((self.mesh.nE, len(Srcs)))
-
-        # for i, src in enumerate(self.survey.srcList):
-        dun_dm_v = np.hstack([Utils.mkvc(self.getInitialFieldsDeriv(src,v),2) for src in self.survey.srcList]) # can over-write this at each timestep
-        #
-        df_dm_v = Fields_Derivs(self.mesh, self.survey) # store the field derivs we need to project to calc full deriv
-
-        Adiaginv = None
-
-        for tInd, dt in zip(range(self.nT), self.timeSteps):
-            if Adiaginv is not None and (tInd > 0 and dt != self.timeSteps[tInd - 1]):# keep factors if dt is the same as previous step b/c A will be the same
-                Adiaginv.clean()
-                Adiaginv = None
-
-            if Adiaginv is None:
-                A = self.getAdiag(tInd)
-                Adiaginv = self.Solver(A, **self.solverOpts)
-
-            Asubdiag = self.getAsubdiag(tInd)
-
-            for i, src in enumerate(self.survey.srcList):
-
-                # here, we are lagging by a timestep, so filling in as we go
-                for projField in set([rx.projField for rx in src.rxList]):
-                    # Seogi: df_duFun?
-                    df_dmFun = getattr(f, '_%sDeriv'%projField, None)
-                    # df_dm_v is dense, but we only need the times at (rx.P.T * ones > 0)
-                    # This should be called rx.footprint
-                    df_dm_v[src, '%sDeriv'%projField , tInd] = df_dmFun(tInd, src, dun_dm_v[:,i], v)
-
-                un_src = f[src,ftype,tInd+1]
-
-                dA_dm_v   = self.getAdiagDeriv(tInd, un_src, v) # cell centered on time mesh
-                dRHS_dm_v = self.getRHSDeriv(tInd+1, src, v) # on nodes of time mesh
-
-                dAsubdiag_dm_v = self.getAsubdiagDeriv(tInd, f[src,ftype,tInd], v)
-
-                JRHS = dRHS_dm_v - dAsubdiag_dm_v - dA_dm_v
-
-                # step in time and overwrite
-                if tInd != len(self.timeSteps+1):
-                    dun_dm_v[:,i] = Adiaginv * (JRHS - Asubdiag * dun_dm_v[:,i])
-
-        # Seogi: suspcious spot
-        # Jv = self.dataPair(self.survey)
-        Jv = []
-        for src in self.survey.srcList:
-            for rx in src.rxList:
-                # Looping over data class append memory as well!!
-                # Jv[src,rx] = rx.evalDeriv(src, self.mesh, self.timeMesh, Utils.mkvc(df_dm_v[src,'%sDeriv'%rx.projField,:]))
-                Jv.append(rx.evalDeriv(src, self.mesh, self.timeMesh, Utils.mkvc(df_dm_v[src,'%sDeriv'%rx.projField,:])))
-        Adiaginv.clean()
-        # del df_dm_v, dun_dm_v, Asubdiag
-        # return Utils.mkvc(Jv)
-        return np.hstack(Jv)
-
-    def Jtvec(self, m, v, f=None):
-
-        """
-        Jvec computes the adjoint of the sensitivity times a vector
-
-        .. math::
-            \mathbf{J}^\\top \mathbf{v} =  \left( \\frac{d\mathbf{u}}{d\mathbf{m}} ^ \\top \\frac{d\mathbf{F}}{d\mathbf{u}} ^ \\top  + \\frac{\partial\mathbf{F}}{\partial\mathbf{m}} ^ \\top \\right) \\frac{d\mathbf{P}}{d\mathbf{F}} ^ \\top \mathbf{v}
-
-        where
-
-        .. math::
-            \\frac{d\mathbf{u}}{d\mathbf{m}} ^\\top \mathbf{A}^\\top  + \\frac{d\mathbf{A}(\mathbf{u})}{d\mathbf{m}} ^ \\top = \\frac{d \mathbf{RHS}}{d \mathbf{m}} ^ \\top
-        """
-
-        if f is None:
-            f = self.fields(m)
-
-        self.curModel = m
-        ftype = self._fieldType + 'Solution' # the thing we solved for
-
-        # Ensure v is a data object.
-        if not isinstance(v, self.dataPair):
-            v = self.dataPair(self.survey, v)
-
-        df_duT_v = Fields_Derivs(self.mesh, self.survey)
-        ATinv_df_duT_v = np.zeros((len(self.survey.srcList), len(f[self.survey.srcList[0],ftype,0])), dtype=float) # same size as fields at a single timestep
-
-        JTv = np.zeros(m.shape, dtype=float)
-
-        # Loop over sources and receivers to create a fields object: PT_v, df_duT_v, df_dmT_v
-        PT_v = Fields_Derivs(self.mesh, self.survey) # initialize storage for PT_v (don't need to preserve over sources)
-        for src in self.survey.srcList:
-            # Looping over initializing field class is appending memory!
-            # PT_v = Fields_Derivs(self.mesh, self.survey) # initialize storage for PT_v (don't need to preserve over sources)
-            # initialize size
-            df_duT_v[src, '%sDeriv'%self._fieldType, :] = np.zeros_like(f[src, self._fieldType, :])
-
-            for rx in src.rxList:
-                print ('_%sDeriv')%(rx.projField)
-                PT_v[src,'%sDeriv'%rx.projField,:] = rx.evalDeriv(src, self.mesh, self.timeMesh, Utils.mkvc(v[src,rx]), adjoint=True) # this is +=
-
-                # PT_v = np.reshape(curPT_v,(len(curPT_v)/self.timeMesh.nN, self.timeMesh.nN), order='F')
-                df_duTFun = getattr(f, '_%sDeriv'%rx.projField, None)
-
-                for tInd in range(self.nT+1):
-                    cur = df_duTFun(tInd, src, None, Utils.mkvc(PT_v[src,'%sDeriv'%rx.projField,tInd]), adjoint=True)
-                    df_duT_v[src, '%sDeriv'%self._fieldType, tInd] = df_duT_v[src, '%sDeriv'%self._fieldType, tInd] + Utils.mkvc(cur[0],2)
-                    JTv = cur[1] + JTv
-
-        del PT_v # no longer need this
-
-        AdiagTinv = None
-
-        # Do the back-solve through time
-        for tIndP in reversed(range(self.nT + 1)):
-            tInd = tIndP - 1
-            if AdiagTinv is not None and (tInd <= self.nT and self.timeSteps[tInd] != self.timeSteps[tInd+1]): # if the previous timestep is the same --> no need to refactor the matrix
-                AdiagTinv.clean()
-                AdiagTinv = None
-
-            # refactor if we need to
-            if AdiagTinv is None and tInd > -1:
-                Adiag = self.getAdiag(tInd)
-                AdiagTinv = self.Solver(Adiag.T, **self.solverOpts)
-
-            dAsubdiag_dm_v = Zero()
-
-            if tInd < self.nT - 1:
-                Asubdiag = self.getAsubdiag(tInd+1)
-
-
-            for isrc, src in enumerate(self.survey.srcList):
-                # solve against df_duT_v
-                if tInd >= self.nT-1:
-                    # last timestep (first to be solved)
-                    ATinv_df_duT_v[isrc,:] = AdiagTinv * df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1]
-                elif tInd > -1:
-                # else:
-                    ATinv_df_duT_v[isrc,:] = AdiagTinv * (Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1]) - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:]))
-                else:
-                    # AdiagTinv = I
-                    ATinv_df_duT_v[isrc,:] = Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1]) - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:])
-                    # - Utils.mkvc(Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:]))
-                    # (Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1]) - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:]))
-
-                if tInd < self.nT - 1:
-                    dAsubdiagT_dm_v = self.getAsubdiagDeriv(tInd+1, f[src,ftype,tInd+1], ATinv_df_duT_v[isrc,:], adjoint = True)
-
-                if tInd > -1:
-                    un_src = f[src,ftype,tInd+1]
-                    dAT_dm_v = self.getAdiagDeriv(tInd, un_src, ATinv_df_duT_v[isrc,:], adjoint=True) # cell centered on time mesh
-                    dRHST_dm_v = self.getRHSDeriv(tInd+1, src, ATinv_df_duT_v[isrc,:], adjoint=True) # on nodes of time mesh
-
-                    JTv = JTv + Utils.mkvc(- dAT_dm_v - dAsubdiag_dm_v + dRHST_dm_v)
-                else:
-                    # dA_dm_v = self.getInitialFieldsDeriv(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1], adjoint=True)
-                    # print np.linalg.norm(self.getInitialFieldsDeriv(src, df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1], adjoint=True))
-                    # print np.linalg.norm(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1])
-                    # vec = - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:]) + Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1])
-                    # dAsubdiagT_dm_v = self.getAsubdiagDeriv(tInd+1, f[src,ftype,tInd+1], Utils.mkvc(ATinv_df_duT_v[isrc,:]), adjoint = True)
-                    dRHST_dm_v = Utils.mkvc(self.getInitialFieldsDeriv(src, Utils.mkvc(ATinv_df_duT_v[isrc,:]) , adjoint=True))
-
-                    JTv = JTv + Utils.mkvc( -dAsubdiagT_dm_v + dRHST_dm_v) #
-
-
-
-                    # # dAT_dm_v = self.getAdiagDeriv(tInd, un_src, ATinv_df_duT_v[isrc,:], adjoint=True) # cell centered on time mesh
-                    # dRHST_dm_v0 = self.getRHSDeriv(tInd+1, src, ATinv_df_duT_v[isrc,:], adjoint=True) # on nodes of time mesh
-                    # dRHST_dm_v1 = self.getInitialFieldsDeriv( Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1]), adjoint=True)
-                    # JTv = JTv + Utils.mkvc(dRHST_dm_v0 + dRHST_dm_v1)
-
-                    # print 'here'
-                    # inFields = self.getInitialFieldsDeriv(f[src,ftype,tInd+1], Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,tInd+1]), adjoint=True)
-                    #  # - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:]), adjoint=True)
-                    # print inFields.shape
-                    # JTv = JTv + inFields
-                # dAsubdiag_dm_v = 0
-
-
-
-        # Missing the 0 step
-
-        # adding du_dm^T * dF_du^T * P^T vfor time 0 (no dRHS_dm_v at time 0)
-        # Asubdiag = self.getAsubdiag(0)
-        # for src in self.survey.srcList:
-        #     for projField in set(rx.projField):
-        #         v = AdiagTinv * (Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,0]) - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:]))
-        #         JTv = JTv - Utils.mkvc(self.getAdiagDeriv(0, f[src, ftype, tInd], v, adjoint = True))
-        #         # JTv = JTv + self.getInitialFieldsDeriv(Utils.mkvc(df_duT_v[src,'%sDeriv'%self._fieldType,0] - Asubdiag.T * Utils.mkvc(ATinv_df_duT_v[isrc,:])), adjoint=True)
-
-        # del df_duT_v, ATinv_df_duT_v, A, Asubdiag
-        if AdiagTinv is not None:
-            AdiagTinv.clean()
-
-        return Utils.mkvc(JTv).astype(float)
-
-
-
-    def getSourceTerm(self, tInd):
-
-        Srcs = self.survey.srcList
-
-        if self._eqLocs is 'FE':
-            S_m = np.zeros((self.mesh.nF,len(Srcs)))
-            S_e = np.zeros((self.mesh.nE,len(Srcs)))
-        elif self._eqLocs is 'EF':
-            S_m = np.zeros((self.mesh.nE,len(Srcs)))
-            S_e = np.zeros((self.mesh.nF,len(Srcs)))
-
-        for i, src in enumerate(Srcs):
-            smi, sei = src.eval(self, self.times[tInd])
-            S_m[:,i] = S_m[:,i] + smi
-            S_e[:,i] = S_e[:,i] + sei
-
-        return S_m, S_e
-
-    def getInitialFields(self):
-
-        Srcs = self.survey.srcList
-
-        if self._fieldType is 'b' or self._fieldType is 'j':
-            ifields = np.zeros((self.mesh.nF, len(Srcs)))
-        elif self._fieldType is 'e' or self._fieldType is 'h':
-            ifields = np.zeros((self.mesh.nE, len(Srcs)))
-
-        for i,src in enumerate(Srcs):
-            ifields[:,i] = ifields[:,i] + getattr(src, '%sInitial'%self._fieldType, None)(self)
-
-        return ifields
-
-    def getInitialFieldsDeriv(self, src, v, adjoint=False):
-
-        if adjoint is False:
-            if self._fieldType is 'b' or self._fieldType is 'j':
-                ifieldsDeriv = np.zeros(self.mesh.nF)
-            elif self._fieldType is 'e' or self._fieldType is 'h':
-                ifieldsDeriv = np.zeros(self.mesh.nE)
-
-        elif adjoint is True:
-            ifieldsDeriv = np.zeros(self.mapping.nP)
-
-        ifieldsDeriv = Utils.mkvc(getattr(src, '%sInitialDeriv'%self._fieldType, None)(self,v,adjoint)) + ifieldsDeriv
-
-            # ifieldsDeriv = Utils.mkvc(getattr(src, '%sInitialDeriv'%self._fieldType, None)(self,v,adjoint)) + ifieldsDeriv
-            # ifieldsDeriv = self.getAdiagDeriv(None, u, v, adjoint)
-            # ifieldsDeriv = ifieldsDeriv.sum()
-
-        return ifieldsDeriv
-
-
-##########################################################################################
-################################ E-B Formulation #########################################
-##########################################################################################
-
-# ------------------------------- Problem_b -------------------------------------------- #
-
-class Problem_b(BaseTDEMProblem):
-    """
-    Starting from the quasi-static E-B formulation of Maxwell's equations (semi-discretized)
-
-    .. math::
-
-        \mathbf{C} \mathbf{e} + \\frac{\partial \mathbf{b}}{\partial t} = \mathbf{s_m} \\\\
-        \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e} \mathbf{e} = \mathbf{s_e}
-
-    where :math:`\mathbf{s_e}` is an integrated quantity, we eliminate :math:`\mathbf{e}` using
-
-    .. math::
-        \mathbf{e} = \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} - \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e}
-
-    to obtain a second order semi-discretized system in :math:`\mathbf{b}`
-
-    .. math::
-        \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b}  + \\frac{\partial \mathbf{b}}{\partial t} = \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e} + \mathbf{s_m}
-
-    and moving everything except the time derivative to the rhs gives
-
-    .. math::
-        \\frac{\partial \mathbf{b}}{\partial t} = -\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b} + \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e} + \mathbf{s_m}
-
-    For the time discretization, we use backward euler. To solve for the :math:`n+1`th time step, we have
-
-    .. math::
-        \\frac{\mathbf{b}^{n+1} - \mathbf{b}^{n}}{\mathbf{dt}} = -\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f} \mathbf{b}^{n+1} + \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e}^{n+1} + \mathbf{s_m}^{n+1}
-
-    re-arranging to put :math:`\mathbf{b}^{n+1}` on the left hand side gives
-
-    .. math::
-        (\mathbf{I} + \mathbf{dt} \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f}) \mathbf{b}^{n+1} = \mathbf{b}^{n} + \mathbf{dt}(\mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{s_e}^{n+1} + \mathbf{s_m}^{n+1})
-
-    :param Mesh mesh: mesh
-    :param Mapping mapping: mapping
-    """
-
-    _fieldType = 'b'
-    _eqLocs    = 'FE'
-    fieldsPair = Fields_b
-    surveyPair = SurveyTDEM
-
-    def __init__(self, mesh, mapping=None, **kwargs):
-        BaseTDEMProblem.__init__(self, mesh, mapping=mapping, **kwargs)
-
-    def getAdiag(self, tInd):
-        """
-        System matrix at a given time index
-
-        .. math::
-            (\mathbf{I} + \mathbf{dt} \mathbf{C} \mathbf{M_{\sigma}^e}^{-1} \mathbf{C}^{\\top} \mathbf{M_{\mu^{-1}}^f})
-
-        """
-        assert tInd >= 0 and tInd < self.nT
-
-        dt = self.timeSteps[tInd]
-        C = self.mesh.edgeCurl
-        MeSigmaI = self.MeSigmaI
-        MfMui = self.MfMui
-        I = Utils.speye(self.mesh.nF)
-
-        A = 1./dt * I + ( C * ( MeSigmaI * (C.T * MfMui ) ) )
-
-        if self._makeASymmetric is True:
-            return MfMui.T * A
-        return A
-
-    def getAdiagDeriv(self, tInd, u, v, adjoint=False):
-        C = self.mesh.edgeCurl
-        MeSigmaIDeriv = lambda x: self.MeSigmaIDeriv(x)
-        MfMui = self.MfMui
-
-        if adjoint:
-            if self._makeASymmetric is True:
-                v = MfMui * v
-            return  MeSigmaIDeriv(C.T * ( MfMui * u )).T * ( C.T * v )
-
-        ADeriv = ( C * ( MeSigmaIDeriv(C.T * ( MfMui * u )) * v ) )
-        if self._makeASymmetric is True:
-            return MfMui.T * ADeriv
-        return ADeriv
-
-
-    def getAsubdiag(self, tInd):
-
-        dt = self.timeSteps[tInd]
-        MfMui = self.MfMui
-        Asubdiag = - 1./dt * sp.eye(self.mesh.nF)
-
-        if self._makeASymmetric is True:
-            return MfMui.T * Asubdiag
-
-        return Asubdiag
-
-    def getAsubdiagDeriv(self, tInd, u, v, adjoint=False):
-        return Zero() * v
-
-
-
-    def getRHS(self, tInd):
-        C = self.mesh.edgeCurl
-        MeSigmaI = self.MeSigmaI
-        MfMui = self.MfMui
-
-        S_m, S_e = self.getSourceTerm(tInd)
-
-        rhs =  (C * (MeSigmaI * S_e) + S_m)
-        if self._makeASymmetric is True:
-            return MfMui.T * rhs
-        return rhs
-
-    def getRHSDeriv(self, tInd, src, v, adjoint=False):
-
-        C = self.mesh.edgeCurl
-        MeSigmaI = self.MeSigmaI
-        MeSigmaIDeriv = lambda u: self.MeSigmaIDeriv(u)
-        MfMui = self.MfMui
-
-        _, S_e = src.eval(tInd, self)
-        S_mDeriv, S_eDeriv = src.evalDeriv(self.times[tInd], self, adjoint=adjoint)
-
-        if adjoint:
-            if self._makeASymmetric is True:
-                v = self.MfMui * v
-            if isinstance(S_e, Utils.Zero):
-                MeSigmaIDerivT_v = Utils.Zero()
-            else:
-                MeSigmaIDerivT_v = MeSigmaIDeriv(S_e).T * v
-            RHSDeriv = MeSigmaIDerivT_v + S_eDeriv( MeSigmaI.T *  ( C.T * v ) ) + S_mDeriv(v)
-            return RHSDeriv
-
-        if isinstance(S_e, Utils.Zero):
-            MeSigmaIDeriv_v = Utils.Zero()
-        else:
-            MeSigmaIDeriv_v = MeSigmaIDeriv(S_e) * v
-
-        RHSDeriv = (C * (MeSigmaIDeriv_v + MeSigmaI * S_eDeriv(v) + S_mDeriv(v)))
-
-        if self._makeASymmetric is True:
-            return self.MfMui.T * RHSDeriv
-        return RHSDeriv
-
-
-# ------------------------------- Problem_e -------------------------------------------- #
-
-class Problem_e(BaseTDEMProblem):
-
-    _fieldType = 'e'
-    _eqLocs    = 'FE'
-    fieldsPair = Fields_e
-    surveyPair = SurveyTDEM
-
-    def __init__(self, mesh, mapping=None, **kwargs):
-        BaseTDEMProblem.__init__(self, mesh, mapping=mapping, **kwargs)
-
-    def getAdiag(self, tInd):
-        """
-        System matrix at a given time index
-
-        """
-        assert tInd >= 0 and tInd < self.nT
-
-        dt = self.timeSteps[tInd]
-        C = self.mesh.edgeCurl
-        MfMui = self.MfMui
-        MeSigma = self.MeSigma
-
-        return C.T * ( MfMui * C ) + 1./dt * MeSigma
-
-
-    def getAdiagDeriv(self, tInd, u, v, adjoint=False):
-        assert tInd >= 0 and tInd < self.nT
-
-        dt = self.timeSteps[tInd]
-        C = self.mesh.edgeCurl
-        MfMui = self.MfMui
-        MeSigmaDeriv = self.MeSigmaDeriv(u)
-
-        if adjoint:
-            return 1./dt * MeSigmaDeriv.T * v
-
-        return 1./dt * MeSigmaDeriv * v
-
-
-    def getAsubdiag(self, tInd):
-        assert tInd >= 0 and tInd < self.nT
-
-        dt = self.timeSteps[tInd]
-
-        return - 1./dt * self.MeSigma
-
-    def getAsubdiagDeriv(self, tInd, u, v, adjoint=False):
-        dt = self.timeSteps[tInd]
-
-        if adjoint:
-            return - 1./dt * self.MeSigmaDeriv(u).T * v
-
-        return - 1./dt * self.MeSigmaDeriv(u) * v
-
-    def getRHS(self, tInd):
-        return Zero()
-
-    def getRHSDeriv(self, tInd, src, v, adjoint=False):
-        return Zero()
-
-
-
-
-

SimPEG/EM/TDEM/__init__.py

@@ -1,3 +1,3 @@
-from TDEM import BaseTDEMProblem, Problem_b, Problem_e
-from FieldsTDEM import Fields, Fields_b
-from SurveyTDEM import Survey, Src, Rx
+from SurveyTDEM import * #SurveyTDEM, RxTDEM, SrcTDEM
+from BaseTDEM import BaseTDEMProblem, FieldsTDEM
+from TDEM_b import ProblemTDEM_b

SimPEG/EM/TDEM_old/SurveyTDEM.py

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

SimPEG/EM/TDEM_old/__init__.py

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

SimPEG/EM/Utils/EMUtils.py

@@ -13,4 +13,37 @@ def k(freq, sigma, mu=mu_0, eps=epsilon_0):
     beta = w * np.sqrt( mu*eps/2 * ( np.sqrt(1. + (sigma / (eps*w))**2 ) - 1) ) 
     return alp - 1j*beta
 
+# Constitutive relations
+def e_from_j(prob,j):
+    eqLocs = prob._eqLocs
+    if eqLocs is 'FE':
+        MSigmaI = prob.MeSigmaI
+    elif eqLocs is 'EF':
+        MSigmaI = prob.MfRho
+    return MSigmaI*j
+
+def j_from_e(prob,e):
+    eqLocs = prob._eqLocs
+    if eqLocs is 'FE':
+        MSigma = prob.MeSigma
+    elif eqLocs is 'EF':
+        MSigma = prob.MfRhoI
+    return MSigma*e
+
+def b_from_h(prob,h):
+    eqLocs = prob._eqLocs
+    if eqLocs is 'FE':
+        MMu = prob.MfMuiI
+    elif eqLocs is 'EF':
+        MMu = prob.MeMu
+    return MMu*h
+
+def h_from_b(prob,b):
+    eqLocs = prob._eqLocs
+    if eqLocs is 'FE':
+        MMuI = prob.MfMui
+    elif eqLocs is 'EF':
+        MMuI = prob.MeMuI
+    return MMuI*b 
+
 

SimPEG/EM/Utils/__init__.py

@@ -1,2 +1,5 @@
-from EMUtils import omega, k
+# import Sources
+# import Ana
+# import Solver
+from EMUtils import omega, e_from_j, j_from_e, b_from_h, h_from_b
 from AnalyticUtils import MagneticDipoleFields, MagneticDipoleVectorPotential, MagneticLoopVectorPotential

SimPEG/EM/Utils/testingUtils.py

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

SimPEG/EM/__init__.py

@@ -1,7 +1,6 @@
+# from EM import *
 import TDEM
 import FDEM
-import Static
 import Base
 import Analytics
 import Utils
-from scipy.constants import mu_0, epsilon_0

SimPEG/Examples/DC_Analytic_Dipole.py

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

SimPEG/Examples/DC_PseudoSection_Simulation.py

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

SimPEG/Examples/EM_FDEM_1D_Inversion.py

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

SimPEG/Examples/EM_Schenkel_Morrison_Casing.py

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

SimPEG/Examples/EM_TDEM_1D_Inversion.py

@@ -1,6 +1,6 @@
 from SimPEG import *
 import SimPEG.EM as EM
-from SimPEG.EM import mu_0
+from scipy.constants import mu_0
 
 
 def run(plotIt=True):
@@ -19,8 +19,8 @@ def run(plotIt=True):
 
     active = mesh.vectorCCz<0.
     layer = (mesh.vectorCCz<0.) & (mesh.vectorCCz>=-100.)
-    actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
-    mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap
+    actMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
+    mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * actMap
     sig_half = 2e-3
     sig_air = 1e-8
     sig_layer = 1e-3
@@ -42,26 +42,28 @@ def run(plotIt=True):
 
 
     rxOffset=1e-3
-    rx = EM.TDEM.Rx(np.array([[rxOffset, 0., 30]]), np.logspace(-5,-3, 31), 'bz')
-    src = EM.TDEM.Src.MagDipole([rx], loc=np.array([0., 0., 80]))
-    survey = EM.TDEM.Survey([src])
-    prb = EM.TDEM.Problem_b(mesh, mapping=mapping)
+    rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 30]]), np.logspace(-5,-3, 31), 'bz')
+    src = EM.TDEM.SrcTDEM_VMD_MVP([rx], np.array([0., 0., 80]))
+    survey = EM.TDEM.SurveyTDEM([src])
+    prb = EM.TDEM.ProblemTDEM_b(mesh, mapping=mapping)
 
     prb.Solver = SolverLU
     prb.timeSteps = [(1e-06, 20),(1e-05, 20), (0.0001, 20)]
     prb.pair(survey)
+    dtrue = survey.dpred(mtrue)
 
-    # create observed data
+
+    survey.dtrue = dtrue
     std = 0.05
-
-    survey.dobs = survey.makeSyntheticData(mtrue,std)
-    survey.std = std
-    survey.eps = 1e-5*np.linalg.norm(survey.dobs)
+    noise = std*abs(survey.dtrue)*np.random.randn(*survey.dtrue.shape)
+    survey.dobs = survey.dtrue+noise
+    survey.std = survey.dobs*0 + std
+    survey.Wd = 1/(abs(survey.dobs)*std)
 
     if plotIt:
         import matplotlib.pyplot as plt
         fig, ax = plt.subplots(1,1, figsize = (10, 6))
-        ax.loglog(rx.times, survey.dtrue, 'b.-')
+        ax.loglog(rx.times, dtrue, 'b.-')
         ax.loglog(rx.times, survey.dobs, 'r.-')
         ax.legend(('Noisefree', '$d^{obs}$'), fontsize = 16)
         ax.set_xlabel('Time (s)', fontsize = 14)
@@ -74,7 +76,6 @@ def run(plotIt=True):
     reg = Regularization.Tikhonov(regMesh)
     opt = Optimization.InexactGaussNewton(maxIter = 5)
     invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)
-
     # Create an inversion object
     beta = Directives.BetaSchedule(coolingFactor=5, coolingRate=2)
     betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1e0)

SimPEG/Examples/Forward_BasicDirectCurrent.py

@@ -1,25 +1,22 @@
 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(sigma, invProp=True, invMat=True)
-        A = -D*MsigI*D.T
+        Msigi = mesh.getFaceInnerProduct(1./sigma)
+        MsigI = Utils.sdInv(Msigi)
+        A = D*MsigI*G
         A[-1,-1] /= mesh.vol[-1] # Remove null space
         rhs = np.zeros(mesh.nC)
         txind = Utils.meshutils.closestPoints(mesh, pts)
@@ -40,17 +37,39 @@ 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)
-    dat = rM.plotImage(phirM, ax=axes[1], clim=(vmin, vmax), grid=True)
+
+    #TODO: At the moment Curvilinear Mesh do not have plotimage
+
+    Xi = tM.gridCC[:,0].reshape(sz[0], sz[1], order='F')
+    Yi = tM.gridCC[:,1].reshape(sz[0], sz[1], order='F')
+    PHIrM = griddata(rM.gridCC[:,0], rM.gridCC[:,1], phirM, Xi, Yi, interp='linear')
+    axes[1].contourf(Xi, Yi, PHIrM, 100, vmin=vmin, vmax=vmax)
+
     cb = plt.colorbar(dat[0], ax=axes[0]); cb.set_label("Voltage (V)")
     cb = plt.colorbar(dat[0], ax=axes[1]); cb.set_label("Voltage (V)")
 
+    tM.plotGrid(ax=axes[0], **opts)
     axes[0].set_title('TensorMesh')
+    rM.plotGrid(ax=axes[1], **opts)
     axes[1].set_title('CurvilinearMesh')
+    for i in range(2):
+        axes[i].set_xlim(0.025, 0.975)
+        axes[i].set_ylim(0.025, 0.975)
+        axes[i].text(0., 1.0, label[i], fontsize=20)
+        if i==0:
+            axes[i].set_ylabel("y")
+        else:
+            axes[i].set_ylabel(" ")
+        axes[i].set_xlabel("x")
     plt.show()
 
 

SimPEG/Examples/Inversion_IRLS.py

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

SimPEG/Examples/Inversion_Linear.py

@@ -10,6 +10,28 @@ def run(N=100, plotIt=True):
 
     """
 
+    class LinearSurvey(Survey.BaseSurvey):
+        def projectFields(self, u):
+            return u
+
+    class LinearProblem(Problem.BaseProblem):
+
+        surveyPair = LinearSurvey
+
+        def __init__(self, mesh, G, **kwargs):
+            Problem.BaseProblem.__init__(self, mesh, **kwargs)
+            self.G = G
+
+        def fields(self, m, u=None):
+            return self.G.dot(m)
+
+        def Jvec(self, m, v, u=None):
+            return self.G.dot(v)
+
+        def Jtvec(self, m, v, u=None):
+            return self.G.T.dot(v)
+
+
     np.random.seed(1)
 
     mesh = Mesh.TensorMesh([N])
@@ -31,8 +53,8 @@ def run(N=100, plotIt=True):
     mtrue[mesh.vectorCCx > 0.45] = -0.5
     mtrue[mesh.vectorCCx > 0.6] = 0
 
-    prob = Problem.LinearProblem(mesh, G)
-    survey = Survey.LinearSurvey()
+    prob = LinearProblem(mesh, G)
+    survey = LinearSurvey()
     survey.pair(prob)
     survey.makeSyntheticData(mtrue, std=0.01)
 

SimPEG/Examples/MT_1D_ForwardAndInversion.py

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

SimPEG/Examples/MT_3D_Foward.py

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

SimPEG/Examples/Utils_surface2ind_topo.py

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

SimPEG/Examples/__init__.py

@@ -1,16 +1,11 @@
 # Run this file to add imports.
 
 ##### AUTOIMPORTS #####
-import DC_Analytic_Dipole
-import DC_Forward_PseudoSection
-import EM_FDEM_1D_Inversion
 import EM_FDEM_Analytic_MagDipoleWholespace
-import EM_Schenkel_Morrison_Casing
 import EM_TDEM_1D_Inversion
 import FLOW_Richards_1D_Celia1990
-import Inversion_IRLS
+import Forward_BasicDirectCurrent
 import Inversion_Linear
-import Mesh_Basic_ForwardDC
 import Mesh_Basic_PlotImage
 import Mesh_Basic_Types
 import Mesh_Operators_CahnHilliard
@@ -18,11 +13,8 @@ import Mesh_QuadTree_Creation
 import Mesh_QuadTree_FaceDiv
 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", "Inversion_IRLS", "Inversion_Linear", "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"]
+__examples__ = ["EM_FDEM_Analytic_MagDipoleWholespace", "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"]
 
 ##### AUTOIMPORTS #####
 

SimPEG/Examples/simpegEMpaper_example_1.py

@@ -1,157 +0,0 @@
-from SimPEG import np, Mesh, Maps, Utils, DataMisfit, Regularization, Optimization, Inversion, InvProblem, Directives
-from SimPEG import SolverLU
-from SimPEG.EM import FDEM, TDEM, mu_0
-import matplotlib.pyplot as plt
-import matplotlib
-matplotlib.rcParams['font.size'] = 14
-
-def run(plotIt=True):
-    # Set up cylindrically symmeric mesh
-    cs, ncx, ncz, npad = 10., 15, 25, 13  # padded cyl mesh
-    hx = [(cs,ncx), (cs,npad,1.3)]
-    hz = [(cs,npad,-1.3), (cs,ncz), (cs,npad,1.3)]
-    mesh = Mesh.CylMesh([hx,1,hz], '00C')
-
-    # Conductivity model
-    layerz = np.r_[-200., -100.]
-    layer = (mesh.vectorCCz>=layerz[0]) & (mesh.vectorCCz<=layerz[1])
-    active = mesh.vectorCCz<0.
-    sig_half  = 1e-2  # Half-space conductivity
-    sig_air   = 1e-8  # Air conductivity
-    sig_layer = 5e-2  # Layer conductivity
-    sigma = np.ones(mesh.nCz)*sig_air
-    sigma[active] = sig_half
-    sigma[layer] = sig_layer
-
-    # Mapping
-    actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
-    mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap
-    mtrue = np.log(sigma[active])
-
-    # FDEM problem & survey
-    rxlocs = Utils.ndgrid([np.r_[50.], np.r_[0], np.r_[0.]])
-    bzi = FDEM.Rx.Point_bSecondary(rxlocs, 'z', 'real')
-    bzr = FDEM.Rx.Point_bSecondary(rxlocs, 'z', 'imag')
-
-    freqs = np.logspace(2, 3, 5)
-    srcLoc = np.array([0., 0., 0.])
-
-    print 'min skin depth = ', 500./np.sqrt(freqs.max() * sig_half), 'max skin depth = ', 500./np.sqrt(freqs.min() * sig_half)
-    print 'max x ', mesh.vectorCCx.max(), 'min z ', mesh.vectorCCz.min(), 'max z ', mesh.vectorCCz.max()
-
-    srcList = []
-    [srcList.append(FDEM.Src.MagDipole([bzr, bzi],freq, srcLoc,orientation='Z')) for freq in freqs]
-
-    surveyFD = FDEM.Survey(srcList)
-    prbFD = FDEM.Problem3D_b(mesh, mapping=mapping)
-    prbFD.pair(surveyFD)
-    std = 0.03
-    surveyFD.makeSyntheticData(mtrue, std)
-    surveyFD.eps = np.linalg.norm(surveyFD.dtrue)*1e-5
-
-    # FDEM inversion
-    np.random.seed(1)
-    dmisfit = DataMisfit.l2_DataMisfit(surveyFD)
-    regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
-    reg = Regularization.Simple(regMesh)
-    opt = Optimization.InexactGaussNewton(maxIterCG=10, maxIter=4)
-    invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)
-    # Inversion Directives
-    beta = Directives.BetaSchedule(coolingFactor=5, coolingRate=3)
-    # betaest = Directives.BetaEstimate_ByEig(beta0_ratio=10.)
-    invProb.beta = 1.
-    target = Directives.TargetMisfit()
-
-    inv = Inversion.BaseInversion(invProb, directiveList=[beta,target])
-    m0 = np.log(np.ones(mtrue.size)*sig_half)
-    reg.alpha_s = 5e-1
-    reg.alpha_x = 1.
-    prbFD.counter = opt.counter = Utils.Counter()
-    opt.LSshorten = 0.5
-    opt.tolG = 1e-10
-    opt.eps = 1e-10
-    opt.remember('xc')
-    moptFD = inv.run(m0)
-
-    # TDEM problem
-    times = np.logspace(-4, np.log10(2e-3), 10)
-    print 'min diffusion distance ', 1.28*np.sqrt(times.min()/(sig_half*mu_0)), 'max diffusion distance ', 1.28*np.sqrt(times.max()/(sig_half*mu_0))
-    rx = TDEM.Rx(rxlocs, times, 'bz')
-    src = TDEM.Src.MagDipole([rx], waveform=TDEM.Src.StepOffWaveform(), loc=srcLoc) # same src location as FDEM problem
-
-    surveyTD = TDEM.Survey([src])
-    prbTD = TDEM.Problem_b(mesh, mapping=mapping)
-    prbTD.timeSteps = [(5e-5, 10),(1e-4, 10),(5e-4, 10)]
-    prbTD.pair(surveyTD)
-    prbTD.Solver = SolverLU
-
-    std = 0.03
-    surveyTD.makeSyntheticData(mtrue, std)
-    surveyTD.std = std
-    surveyTD.eps = np.linalg.norm(surveyTD.dtrue)*1e-5
-
-    # TDEM inversion
-    dmisfit = DataMisfit.l2_DataMisfit(surveyTD)
-    regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
-    reg = Regularization.Simple(regMesh)
-    opt = Optimization.InexactGaussNewton(maxIterCG=10, maxIter=4)
-    invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)
-
-    # Inversion Directives
-    beta = Directives.BetaSchedule(coolingFactor=5, coolingRate=3)
-    invProb.beta = 1.
-    # betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1.)
-    target = Directives.TargetMisfit()
-
-    inv = Inversion.BaseInversion(invProb, directiveList=[beta, target])
-    m0 = np.log(np.ones(mtrue.size)*sig_half)
-    reg.alpha_s = 5e-1
-    reg.alpha_x = 1.
-    prbTD.counter = opt.counter = Utils.Counter()
-    opt.LSshorten = 0.5
-    opt.remember('xc')
-    moptTD = inv.run(m0)
-
-    if plotIt:
-        fig, ax = plt.subplots(1,1, figsize = (4, 6))
-        plt.semilogx(sigma[active], mesh.vectorCCz[active], 'k-', lw=2)
-        plt.semilogx(np.exp(moptFD), mesh.vectorCCz[active], 'ko', ms=3)
-        plt.semilogx(np.exp(moptTD), mesh.vectorCCz[active], 'k*')
-        ax.set_ylim(-1000, 0)
-        ax.set_xlim(5e-3, 1e-1)
-
-        ax.set_xlabel('Conductivity (S/m)', fontsize = 14)
-        ax.set_ylabel('Depth (m)', fontsize = 14)
-        ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
-        plt.legend(['True', 'Pred (FD)', 'Pred (TD)'], fontsize=13, loc=4)
-        plt.show()
-
-        fig = plt.figure(figsize = (10*1.3, 5*1.3))
-        ax2 = plt.subplot(122)
-        ax2.plot(times, surveyTD.dobs, 'k-', lw=2)
-        ax2.plot(times, surveyTD.dpred(moptTD), 'ko', ms=4)
-        ax2.set_xscale('log')
-        ax2.set_yscale('log')
-        ax2.set_xlim(times.min(), times.max())
-        ax1 = plt.subplot(121)
-        ax1.plot(freqs, -surveyFD.dobs[::2], 'k-', lw=2)
-        ax1.plot(freqs, -surveyFD.dobs[1::2], 'k--', lw=2)
-        dpredFD = surveyFD.dpred(moptTD)
-        ax1.plot(freqs, -dpredFD[::2], 'ko', ms=4)
-        ax1.plot(freqs, -dpredFD[1::2], 'k+', markeredgewidth=2., ms=10)
-        ax1.set_xscale('log')
-        ax1.set_yscale('log')
-        ax2.set_xlabel('Time (s)', fontsize = 14)
-        ax1.set_xlabel('Frequency (Hz)', fontsize = 14)
-        ax1.set_ylabel('Vertical magnetic field (T)', fontsize = 14)
-        ax2.grid(True,which='minor')
-        ax1.grid(True,which='minor')
-        ax2.set_title("(b) TD observed vs. predicted", fontsize = 14)
-        ax1.set_title("(a) FD observed vs. predicted", fontsize = 14)
-        ax2.legend(("Obs", "Pred"), fontsize = 12)
-        ax1.legend(("Obs", "Pred (real)", "Pred (imag)"), fontsize = 12, loc=3)
-        ax1.set_xlim(freqs.max(), freqs.min())
-        plt.show()
-
-if __name__ == '__main__':
-    run()

SimPEG/Exceptions.py

@@ -0,0 +1,13 @@
+
+
+class SimPEGException(Exception):
+
+    def __init__(self, reason=''):
+        self.reason = reason
+
+    def __str__(self):
+        return '%s: %s' %(self.__class__.__name__,  self.reason)
+
+
+class PairingException(SimPEGException):
+    pass

SimPEG/FLOW/Richards/RichardsProblem.py

@@ -8,7 +8,7 @@ class RichardsRx(Survey.BaseTimeRx):
 
     knownRxTypes = ['saturation','pressureHead']
 
-    def eval(self, U, m, mapping, mesh, timeMesh):
+    def projectFields(self, U, m, mapping, mesh, timeMesh):
 
         if self.rxType == 'pressureHead':
             u = np.concatenate(U)
@@ -17,7 +17,7 @@ class RichardsRx(Survey.BaseTimeRx):
 
         return self.getP(mesh, timeMesh) * u
 
-    def evalDeriv(self, U, m, mapping, mesh, timeMesh):
+    def projectFieldsDeriv(self, U, m, mapping, mesh, timeMesh):
 
         P = self.getP(mesh, timeMesh)
         if self.rxType == 'pressureHead':
@@ -45,25 +45,25 @@ class RichardsSurvey(Survey.BaseSurvey):
 
     @Utils.count
     @Utils.requires('prob')
-    def dpred(self, m, f=None):
+    def dpred(self, m, u=None):
         """
             Create the projected data from a model.
-            The field, f, (if provided) will be used for the predicted data
+            The field, u, (if provided) will be used for the predicted data
             instead of recalculating the fields (which may be expensive!).
 
             .. math::
-                d_\\text{pred} = P(f(m), m)
+                d_\\text{pred} = P(u(m), m)
 
             Where P is a projection of the fields onto the data space.
         """
-        if f is None: f = self.prob.fields(m)
-        return Utils.mkvc(self.eval(f, m))
+        if u is None: u = self.prob.fields(m)
+        return Utils.mkvc(self.projectFields(u, m))
 
     @Utils.requires('prob')
-    def eval(self, U, m):
+    def projectFields(self, U, m):
         Ds = range(len(self.rxList))
         for ii, rx in enumerate(self.rxList):
-            Ds[ii] = rx.eval(U, m,
+            Ds[ii] = rx.projectFields(U, m,
                                 self.prob.mapping,
                                 self.prob.mesh,
                                 self.prob.timeMesh)
@@ -71,11 +71,11 @@ class RichardsSurvey(Survey.BaseSurvey):
         return np.concatenate(Ds)
 
     @Utils.requires('prob')
-    def evalDeriv(self, U, m):
+    def projectFieldsDeriv(self, U, m):
         """The Derivative with respect to the fields."""
         Ds = range(len(self.rxList))
         for ii, rx in enumerate(self.rxList):
-            Ds[ii] = rx.evalDeriv(U, m,
+            Ds[ii] = rx.projectFieldsDeriv(U, m,
                                 self.prob.mapping,
                                 self.prob.mesh,
                                 self.prob.timeMesh)
@@ -233,16 +233,16 @@ class RichardsProblem(Problem.BaseTimeProblem):
         return r, J
 
     @Utils.timeIt
-    def Jfull(self, m, f=None):
-        if f is None:
-            f = self.fields(m)
+    def Jfull(self, m, u=None):
+        if u is None:
+            u = self.fields(m)
 
-        nn = len(f)-1
+        nn = len(u)-1
         Asubs, Adiags, Bs = range(nn), range(nn), range(nn)
         for ii in range(nn):
             dt = self.timeSteps[ii]
-            bc = self.getBoundaryConditions(ii, f[ii])
-            Asubs[ii], Adiags[ii], Bs[ii] = self.diagsJacobian(m, f[ii], f[ii+1], dt, bc)
+            bc = self.getBoundaryConditions(ii, u[ii])
+            Asubs[ii], Adiags[ii], Bs[ii] = self.diagsJacobian(m, u[ii], u[ii+1], dt, bc)
         Ad = sp.block_diag(Adiags)
         zRight = Utils.spzeros((len(Asubs)-1)*Asubs[0].shape[0],Adiags[0].shape[1])
         zTop = Utils.spzeros(Adiags[0].shape[0], len(Adiags)*Adiags[0].shape[1])
@@ -251,7 +251,7 @@ class RichardsProblem(Problem.BaseTimeProblem):
         B = np.array(sp.vstack(Bs).todense())
 
         Ainv = self.Solver(A, **self.solverOpts)
-        P = self.survey.evalDeriv(f, m)
+        P = self.survey.projectFieldsDeriv(u, m)
         AinvB = Ainv * B
         z = np.zeros((self.mesh.nC, B.shape[1]))
         zAinvB = np.vstack((z, AinvB))
@@ -259,41 +259,41 @@ class RichardsProblem(Problem.BaseTimeProblem):
         return J
 
     @Utils.timeIt
-    def Jvec(self, m, v, f=None):
-        if f is None:
-            f = self.fields(m)
+    def Jvec(self, m, v, u=None):
+        if u is None:
+            u = self.fields(m)
 
-        JvC = range(len(f)-1) # Cell to hold each row of the long vector.
+        JvC = range(len(u)-1) # Cell to hold each row of the long vector.
 
         # This is done via forward substitution.
-        bc = self.getBoundaryConditions(0, f[0])
-        temp, Adiag, B = self.diagsJacobian(m, f[0], f[1], self.timeSteps[0], bc)
+        bc = self.getBoundaryConditions(0, u[0])
+        temp, Adiag, B = self.diagsJacobian(m, u[0], u[1], self.timeSteps[0], bc)
         Adiaginv = self.Solver(Adiag, **self.solverOpts)
         JvC[0] = Adiaginv * (B*v)
 
-        for ii in range(1,len(f)-1):
-            bc = self.getBoundaryConditions(ii, f[ii])
-            Asub, Adiag, B = self.diagsJacobian(m, f[ii], f[ii+1], self.timeSteps[ii], bc)
+        for ii in range(1,len(u)-1):
+            bc = self.getBoundaryConditions(ii, u[ii])
+            Asub, Adiag, B = self.diagsJacobian(m, u[ii], u[ii+1], self.timeSteps[ii], bc)
             Adiaginv = self.Solver(Adiag, **self.solverOpts)
             JvC[ii] = Adiaginv * (B*v - Asub*JvC[ii-1])
 
-        P = self.survey.evalDeriv(f, m)
+        P = self.survey.projectFieldsDeriv(u, m)
         return P * np.concatenate([np.zeros(self.mesh.nC)] + JvC)
 
     @Utils.timeIt
-    def Jtvec(self, m, v, f=None):
-        if f is None:
-            f = self.field(m)
+    def Jtvec(self, m, v, u=None):
+        if u is None:
+            u = self.field(m)
 
-        P = self.survey.evalDeriv(f, m)
+        P = self.survey.projectFieldsDeriv(u, m)
         PTv = P.T*v
 
         # This is done via backward substitution.
         minus = 0
         BJtv = 0
-        for ii in range(len(f)-1,0,-1):
-            bc = self.getBoundaryConditions(ii-1, f[ii-1])
-            Asub, Adiag, B = self.diagsJacobian(m, f[ii-1], f[ii], self.timeSteps[ii-1], bc)
+        for ii in range(len(u)-1,0,-1):
+            bc = self.getBoundaryConditions(ii-1, u[ii-1])
+            Asub, Adiag, B = self.diagsJacobian(m, u[ii-1], u[ii], self.timeSteps[ii-1], bc)
             #select the correct part of v
             vpart = range((ii)*Adiag.shape[0], (ii+1)*Adiag.shape[0])
             AdiaginvT = self.Solver(Adiag.T, **self.solverOpts)

SimPEG/InvProblem.py

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

SimPEG/Inversion.py

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

SimPEG/MT/BaseMT.py

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

SimPEG/MT/FieldsMT.py

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

SimPEG/MT/Problem1D/Probs.py

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

SimPEG/MT/Problem1D/__init__.py

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

SimPEG/MT/Problem2D/__init__.py

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

SimPEG/MT/Problem3D/Probs.py

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

SimPEG/MT/Problem3D/__init__.py

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

SimPEG/MT/SrcMT.py

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

SimPEG/MT/SurveyMT.py

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

SimPEG/MT/Utils/MT1Danalytic.py

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

SimPEG/MT/Utils/MT1Dsolutions.py

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

SimPEG/MT/Utils/__init__.py

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

SimPEG/MT/Utils/dataUtils.py

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

SimPEG/MT/Utils/ediFilesUtils.py

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

SimPEG/MT/Utils/plotDataTypes.py

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

SimPEG/MT/Utils/sourceUtils.py

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

SimPEG/MT/Utils/srcUtils.py

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

SimPEG/MT/__init__.py

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

SimPEG/Maps.py

@@ -4,7 +4,7 @@ from Tests import checkDerivative
 from PropMaps import PropMap, Property
 from numpy.polynomial import polynomial
 from scipy.interpolate import UnivariateSpline
-import warnings
+from scipy.spatial import cKDTree
 
 class IdentityMap(object):
     """
@@ -122,7 +122,7 @@ class IdentityMap(object):
             if not self.shape[1] == '*' and not self.shape[1] == val.shape[0]:
                 raise ValueError('Dimension mismatch in %s and np.ndarray%s.' % (str(self), str(val.shape)))
             return self._transform(val)
-        raise Exception('Unrecognized data type to multiply. Try a map or a numpy.ndarray!')
+        raise Exception('Unrecognized data type to multiply. Try a map or a numpy.ndarray! Not a %s'%type(val))
 
     def __str__(self):
         return "%s(%s,%s)" % (self.__class__.__name__, self.shape[0], self.shape[1])
@@ -297,11 +297,11 @@ class LogMap(IdentityMap):
     def inverse(self, m):
         return np.exp(Utils.mkvc(m))
 
-class SurjectFull(IdentityMap):
+class FullMap(IdentityMap):
     """
-    SurjectFull
+    FullMap
 
-    Given a scalar, the SurjectFull maps the value to the
+    Given a scalar, the FullMap maps the value to the
     full model space.
     """
 
@@ -328,15 +328,9 @@ class SurjectFull(IdentityMap):
         """
         return np.ones([self.mesh.nC,1])
 
-class FullMap(SurjectFull):
-    def __init__(self,mesh,**kwargs):
-        warnings.warn(
-            "`FullMap` is deprecated and will be removed in future versions. Use `SurjectFull` instead",
-            FutureWarning)
-        SurjectFull.__init__(self,mesh,**kwargs)
 
-class SurjectVertical1D(IdentityMap):
-    """SurjectVertical1DMap
+class Vertical1DMap(IdentityMap):
+    """Vertical1DMap
 
         Given a 1D vector through the last dimension
         of the mesh, this will extend to the full
@@ -376,14 +370,8 @@ class SurjectVertical1D(IdentityMap):
                     ), shape=(repNum, 1))
         return sp.kron(sp.identity(self.nP), repVec)
 
-class Vertical1DMap(SurjectVertical1D):
-    def __init__(self,mesh,**kwargs):
-        warnings.warn(
-            "`Vertical1DMap` is deprecated and will be removed in future versions. Use `SurjectVertical1D` instead",
-            FutureWarning)
-        SurjectVertical1D.__init__(self,mesh,**kwargs)
 
-class Surject2Dto3D(IdentityMap):
+class Map2Dto3D(IdentityMap):
     """Map2Dto3D
 
         Given a 2D vector, this will extend to the full
@@ -438,13 +426,6 @@ class Surject2Dto3D(IdentityMap):
                 ), shape=(nC, nP))
         return P
 
-class Map2Dto3D(Surject2Dto3D):
-    def __init__(self,mesh,**kwargs):
-        warnings.warn(
-            "`Map2Dto3D` is deprecated and will be removed in future versions. Use `Surject2Dto3D` instead",
-            FutureWarning)
-        Surject2Dto3D.__init__(self,mesh,**kwargs)
-
 class Mesh2Mesh(IdentityMap):
     """
         Takes a model on one mesh are translates it to another mesh.
@@ -478,7 +459,90 @@ class Mesh2Mesh(IdentityMap):
         return self.P
 
 
-class InjectActiveCells(IdentityMap):
+class Mesh2MeshTopo(IdentityMap):
+    """
+        Takes a model on one mesh are translates it to another mesh
+        with consideration of topography
+
+    """
+    tree = None
+    nIterpPts = 6
+    P = None #: The CSR projection matrix.
+
+    def __init__(self, meshes, actinds, **kwargs):
+        Utils.setKwargs(self, **kwargs)
+
+        assert type(meshes) is list, "meshes must be a list of two meshes"
+        assert len(meshes) == 2, "meshes must be a list of two meshes"
+        assert type(actinds) is list, "actinds must be a list of two meshes"
+        assert len(actinds) == 2, "actinds must be a list of two meshes"
+        assert meshes[0].dim == meshes[1].dim, """The two meshes must be the same dimension"""
+
+        self.mesh  = meshes[0]
+        self.mesh2 = meshes[1]
+        self.actind = actinds[0]
+        self.actind2 = actinds[1]
+        self._createProjection()
+
+        # Old version using SimPEG interpolation
+        # self.P = self.mesh2.getInterpolationMat(self.mesh.gridCC,'CC',zerosOutside=True)
+
+    def genActiveindfromTopo(mesh, xyztopo):
+        #TODO: This possibly needs to be improved use vtk(?)
+        if mesh.dim==3:
+            nCxy = mesh.nCx*mesh.nCy
+            Zcc = mesh.gridCC[:,2].reshape((nCxy, mesh.nCz), order='F')
+            Ftopo = NearestNDInterpolator(xyztopo[:,:2], xyztopo[:,2])
+            XY = Utils.ndgrid(mesh.vectorCCx, mesh.vectorCCy)
+            XY.shape
+            topo = Ftopo(XY)
+            actind = []
+            for ixy in range(nCxy):
+                actind.append(topo[ixy] <= Zcc[ixy,:])
+        else:
+            raise NotImplementedError("Only 3D is working")
+
+        return Utils.mkvc(np.vstack(actind))
+
+    #Question .. is it only generated once?
+    def _createProjection(self):
+        """
+            KD Tree interpolation onto the active cells.
+        """
+        if self.tree==None:
+            self.tree = cKDTree(zip(self.mesh.gridCC[self.actind,0], self.mesh.gridCC[self.actind,1], self.mesh.gridCC[self.actind,2]))
+        d, inds = self.tree.query(zip(self.mesh2.gridCC[self.actind2,0],self.mesh2.gridCC[self.actind2,1],self.mesh2.gridCC[self.actind2,2]), k=self.nIterpPts)
+        # Not sure consideration of the volume ...
+        # vol = np.zeros((self.actind2.sum(), self.nIterpPts))
+        # for i in range(self.nIterpPts):
+        #     vol[:,i] = self.mesh.vol[inds[:,i]]
+        w = 1. / d**2
+        w = Utils.sdiag(1./np.sum(w, axis=1)) * (w)
+        I = Utils.mkvc(np.arange(inds.shape[0]).reshape([-1,1]).repeat(self.nIterpPts, axis=1))
+        J = Utils.mkvc(inds)
+        P = sp.coo_matrix( (Utils.mkvc(w),(I, J)), shape=(inds.shape[0], (self.actind).sum()) )
+        # self.P = Utils.sdiag(self.mesh2.vol[self.actind2])*P.tocsc()
+        self.P = P.tocsr()
+
+    @property
+    def shape(self):
+        """Number of parameters in the model."""
+        # return (self.mesh.nC, self.mesh2.nC)
+        return (self.actind2.sum(), self.actind.sum())
+
+    @property
+    def nP(self):
+        """Number of parameters in the model."""
+        # return self.mesh2.nC
+        return self.actind2.sum()
+
+    def _transform(self, m):
+        return self.P*m
+
+    def deriv(self, m):
+        return self.P
+
+class ActiveCells(IdentityMap):
     """
         Active model parameters.
 
@@ -526,12 +590,76 @@ class InjectActiveCells(IdentityMap):
     def deriv(self, m):
         return self.P
 
-class ActiveCells(InjectActiveCells):
-    def __init__(self, mesh, indActive, valInactive, nC=None):
-        warnings.warn(
-            "`ActiveCells` is deprecated and will be removed in future versions. Use `InjectActiveCells` instead",
-            FutureWarning)
-        InjectActiveCells.__init__(self, mesh, indActive, valInactive, nC)
+class ActiveCellsTopo(IdentityMap):
+    """
+        Active model parameters. Extend for cells on topography to air cell (only works for tensor mesh)
+
+    """
+
+    indActive   = None #: Active Cells
+    valInactive = None #: Values of inactive Cells
+    nC          = None #: Number of cells in the full model
+
+    def __init__(self, mesh, indActive, nC=None):
+        self.mesh  = mesh
+
+        self.nC = nC or mesh.nC
+
+        if indActive.dtype is not bool:
+            z = np.zeros(self.nC,dtype=bool)
+            z[indActive] = True
+            indActive = z
+        self.indActive = indActive
+
+        self.indInactive = np.logical_not(indActive)
+        inds = np.nonzero(self.indActive)[0]
+        self.P = sp.csr_matrix((np.ones(inds.size),(inds, range(inds.size))), shape=(self.nC, self.nP))
+
+    @property
+    def shape(self):
+        return (self.nC, self.nP)
+
+    @property
+    def nP(self):
+        """Number of parameters in the model."""
+        return self.indActive.sum()
+
+    def _transform(self, m):
+        val_temp = np.zeros(self.mesh.nC)
+        val_temp[self.indActive] = m
+        valInactive = np.zeros(self.mesh.nC)
+        #1D
+        if self.mesh.dim == 1:
+            z_temp = self.mesh.gridCC
+            val_temp[~self.indActive] = val_temp[np.argmax(z_temp[self.indActive])]
+        #2D
+        elif self.mesh.dim == 2:
+            act_temp = self.indActive.reshape((self.mesh.nCx, self.mesh.nCy), order = 'F')
+            val_temp = val_temp.reshape((self.mesh.nCx, self.mesh.nCy), order = 'F')
+            y_temp = self.mesh.gridCC[:,1].reshape((self.mesh.nCx, self.mesh.nCy), order = 'F')
+            for i in range(self.mesh.nCx):
+                act_tempx = act_temp[i,:] == 1
+                val_temp[i,~act_tempx] = val_temp[i,np.argmax(y_temp[i,act_tempx])]
+            valInactive[~self.indActive] = Utils.mkvc(val_temp)[~self.indActive]
+        #3D
+        elif self.mesh.dim == 3:
+            act_temp = self.indActive.reshape((self.mesh.nCx*self.mesh.nCy, self.mesh.nCz), order = 'F')
+            val_temp = val_temp.reshape((self.mesh.nCx*self.mesh.nCy, self.mesh.nCz), order = 'F')
+            z_temp = self.mesh.gridCC[:,2].reshape((self.mesh.nCx*self.mesh.nCy, self.mesh.nCz), order = 'F')
+            for i in range(self.mesh.nCx*self.mesh.nCy):
+                act_tempxy = act_temp[i,:] == 1
+                val_temp[i,~act_tempxy] = val_temp[i,np.argmax(z_temp[i,act_tempxy])]
+            valInactive[~self.indActive] = Utils.mkvc(val_temp)[~self.indActive]
+
+        self.valInactive = valInactive
+
+        return self.P*m + self.valInactive
+
+    def inverse(self, D):
+        return self.P.T*D
+
+    def deriv(self, m):
+        return self.P
 
 
 class Weighting(IdentityMap):
@@ -682,29 +810,15 @@ 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', actInd = None):
+    def __init__(self, mesh, order, logSigma=True, normal='X'):
         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):
@@ -722,8 +836,8 @@ class PolyMap(IdentityMap):
             sig1, sig2 = np.exp(sig1), np.exp(sig2)
         #2D
         if self.mesh.dim == 2:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
+            X = self.mesh.gridCC[:,0]
+            Y = self.mesh.gridCC[:,1]
             if self.normal =='X':
                 f = polynomial.polyval(Y, c) - X
             elif self.normal =='Y':
@@ -732,9 +846,9 @@ class PolyMap(IdentityMap):
                 raise(Exception("Input for normal = X or Y or Z"))
         #3D
         elif self.mesh.dim == 3:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
-            Z = self.mesh.gridCC[self.actInd,2]
+            X = self.mesh.gridCC[:,0]
+            Y = self.mesh.gridCC[:,1]
+            Z = self.mesh.gridCC[:,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':
@@ -743,7 +857,6 @@ 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"))
 
@@ -757,8 +870,8 @@ class PolyMap(IdentityMap):
             sig1, sig2 = np.exp(sig1), np.exp(sig2)
         #2D
         if self.mesh.dim == 2:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
+            X = self.mesh.gridCC[:,0]
+            Y = self.mesh.gridCC[:,1]
 
             if self.normal =='X':
                 f = polynomial.polyval(Y, c) - X
@@ -770,9 +883,9 @@ class PolyMap(IdentityMap):
                 raise(Exception("Input for normal = X or Y or Z"))
         #3D
         elif self.mesh.dim == 3:
-            X = self.mesh.gridCC[self.actInd,0]
-            Y = self.mesh.gridCC[self.actInd,1]
-            Z = self.mesh.gridCC[self.actInd,2]
+            X = self.mesh.gridCC[:,0]
+            Y = self.mesh.gridCC[:,1]
+            Z = self.mesh.gridCC[:,2]
 
             if self.normal =='X':
                 f = polynomial.polyval2d(Y, Z, c.reshape((self.order[0]+1,self.order[1]+1))) - X

SimPEG/Mesh/CurvilinearMesh.py

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

SimPEG/Mesh/CylMesh.py

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

SimPEG/Mesh/DiffOperators.py

@@ -307,28 +307,24 @@ class DiffOperators(object):
         return BC
     _cellGradBC_list = 'neumann'
 
-    def _cellGradStencil(self):
-        BC = self.setCellGradBC(self._cellGradBC_list)
-        n = self.vnC
-        if(self.dim == 1):
-            G = ddxCellGrad(n[0], BC[0])
-        elif(self.dim == 2):
-            G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC[0]))
-            G2 = sp.kron(ddxCellGrad(n[1], BC[1]), speye(n[0]))
-            G = sp.vstack((G1, G2), format="csr")
-        elif(self.dim == 3):
-            G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC[0]))
-            G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC[1]), speye(n[0]))
-            G3 = kron3(ddxCellGrad(n[2], BC[2]), speye(n[1]), speye(n[0]))
-            G = sp.vstack((G1, G2, G3), format="csr")
-        return G
-
     def cellGrad():
         doc = "The cell centered Gradient, takes you to cell faces."
 
         def fget(self):
             if(self._cellGrad is None):
-                G = self._cellGradStencil()
+                BC = self.setCellGradBC(self._cellGradBC_list)
+                n = self.vnC
+                if(self.dim == 1):
+                    G = ddxCellGrad(n[0], BC[0])
+                elif(self.dim == 2):
+                    G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC[0]))
+                    G2 = sp.kron(ddxCellGrad(n[1], BC[1]), speye(n[0]))
+                    G = sp.vstack((G1, G2), format="csr")
+                elif(self.dim == 3):
+                    G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC[0]))
+                    G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC[1]), speye(n[0]))
+                    G3 = kron3(ddxCellGrad(n[2], BC[2]), speye(n[1]), speye(n[0]))
+                    G = sp.vstack((G1, G2, G3), format="csr")
                 # Compute areas of cell faces & volumes
                 S = self.area
                 V = self.aveCC2F*self.vol  # Average volume between adjacent cells
@@ -365,24 +361,19 @@ class DiffOperators(object):
     _cellGradBC = None
     cellGradBC = property(**cellGradBC())
 
-    def _cellGradxStencil(self):
-        BC = ['neumann', 'neumann']
-        n = self.vnC
-        if(self.dim == 1):
-            G1 = ddxCellGrad(n[0], BC)
-        elif(self.dim == 2):
-            G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC))
-        elif(self.dim == 3):
-            G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC))
-        return G1
-
-
     def cellGradx():
         doc = "Cell centered Gradient in the x dimension. Has neumann boundary conditions."
 
         def fget(self):
             if getattr(self, '_cellGradx', None) is None:
-                G1 = self._cellGradxStencil()
+                BC = ['neumann', 'neumann']
+                n = self.vnC
+                if(self.dim == 1):
+                    G1 = ddxCellGrad(n[0], BC)
+                elif(self.dim == 2):
+                    G1 = sp.kron(speye(n[1]), ddxCellGrad(n[0], BC))
+                elif(self.dim == 3):
+                    G1 = kron3(speye(n[2]), speye(n[1]), ddxCellGrad(n[0], BC))
                 # Compute areas of cell faces & volumes
                 V = self.aveCC2F*self.vol
                 L = self.r(self.area/V, 'F','Fx', 'V')
@@ -391,22 +382,17 @@ class DiffOperators(object):
         return locals()
     cellGradx = property(**cellGradx())
 
-    def _cellGradyStencil(self):
-        if self.dim < 2: return None
-        BC = ['neumann', 'neumann']
-        n = self.vnC
-        if(self.dim == 2):
-            G2 = sp.kron(ddxCellGrad(n[1], BC), speye(n[0]))
-        elif(self.dim == 3):
-            G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC), speye(n[0]))
-        return G2
-
     def cellGrady():
         doc = "Cell centered Gradient in the x dimension. Has neumann boundary conditions."
         def fget(self):
             if self.dim < 2: return None
             if getattr(self, '_cellGrady', None) is None:
-                G2 = self._cellGradyStencil()
+                BC = ['neumann', 'neumann']
+                n = self.vnC
+                if(self.dim == 2):
+                    G2 = sp.kron(ddxCellGrad(n[1], BC), speye(n[0]))
+                elif(self.dim == 3):
+                    G2 = kron3(speye(n[2]), ddxCellGrad(n[1], BC), speye(n[0]))
                 # Compute areas of cell faces & volumes
                 V = self.aveCC2F*self.vol
                 L = self.r(self.area/V, 'F','Fy', 'V')
@@ -415,19 +401,14 @@ class DiffOperators(object):
         return locals()
     cellGrady = property(**cellGrady())
 
-    def _cellGradzStencil(self):
-        if self.dim < 3: return None
-        BC = ['neumann', 'neumann']
-        n = self.vnC
-        G3 = kron3(ddxCellGrad(n[2], BC), speye(n[1]), speye(n[0]))
-        return G3
-
     def cellGradz():
         doc = "Cell centered Gradient in the x dimension. Has neumann boundary conditions."
         def fget(self):
             if self.dim < 3: return None
             if getattr(self, '_cellGradz', None) is None:
-                G3 = self._cellGradzStencil()
+                BC = ['neumann', 'neumann']
+                n = self.vnC
+                G3 = kron3(ddxCellGrad(n[2], BC), speye(n[1]), speye(n[0]))
                 # Compute areas of cell faces & volumes
                 V = self.aveCC2F*self.vol
                 L = self.r(self.area/V, 'F','Fz', 'V')
@@ -584,67 +565,58 @@ class DiffOperators(object):
 
         return Pbc, Pin, Pout
 
-    def getBCProjWF_simple(self, discretization='CC'):
-        """
-
-        The weak form boundary condition projection matrices
-        when mixed boundary condition is used
-
-
-        """
-
-        if discretization is not 'CC':
-            raise NotImplementedError('Boundary conditions only implemented for CC discretization.')
-
-        def projBC(n):
-            ij = ([0,n], [0,1])
-            vals = [0,0]
-            vals[0] = 1
-            vals[1] = 1
-            return sp.csr_matrix((vals, ij), shape=(n+1,2))
-
-        def projDirichlet(n, bc):
-            bc = checkBC(bc)
-            ij = ([0,n], [0,1])
-            vals = [0,0]
-            if(bc[0] == 'dirichlet'):
-                vals[0] = -1
-            if(bc[1] == 'dirichlet'):
-                vals[1] = 1
-            return sp.csr_matrix((vals, ij), shape=(n+1,2))
-
-        BC = [['dirichlet','dirichlet'],['dirichlet','dirichlet'],['dirichlet','dirichlet']]
-        n = self.vnC
-        indF = self.faceBoundaryInd
-        if(self.dim == 1):
-            Pbc = projDirichlet(n[0], BC[0])
-            B = projBC(n[0])
-            indF = indF[0] | indF[1]
-            Pbc = Pbc*sdiag(self.area[indF])
-
-        elif(self.dim == 2):
-            Pbc1 = sp.kron(speye(n[1]), projDirichlet(n[0], BC[0]))
-            Pbc2 = sp.kron(projDirichlet(n[1], BC[1]), speye(n[0]))
-            Pbc = sp.block_diag((Pbc1, Pbc2), format="csr")
-            B1 = sp.kron(speye(n[1]), projBC(n[0]))
-            B2 = sp.kron(projBC(n[1]), speye(n[0]))
-            B = sp.block_diag((B1, B2), format="csr")
-            indF = np.r_[(indF[0] | indF[1]), (indF[2] | indF[3])]
-            Pbc = Pbc*sdiag(self.area[indF])
-
-        elif(self.dim == 3):
-            Pbc1 = kron3(speye(n[2]), speye(n[1]), projDirichlet(n[0], BC[0]))
-            Pbc2 = kron3(speye(n[2]), projDirichlet(n[1], BC[1]), speye(n[0]))
-            Pbc3 = kron3(projDirichlet(n[2], BC[2]), speye(n[1]), speye(n[0]))
-            Pbc = sp.block_diag((Pbc1, Pbc2, Pbc3), format="csr")
-            B1 = kron3(speye(n[2]), speye(n[1]), projBC(n[0]))
-            B2 = kron3(speye(n[2]), projBC(n[1]), speye(n[0]))
-            B3 = kron3(projBC(n[2]), speye(n[1]), speye(n[0]))
-            B = sp.block_diag((B1, B2, B3), format="csr")
-            indF = np.r_[(indF[0] | indF[1]), (indF[2] | indF[3]), (indF[4] | indF[5])]
-            Pbc = Pbc*sdiag(self.area[indF])
-
-        return Pbc, B.T
+    
+    def unitCellGradx():
+        doc = """Cell centered Gradient in the x dimension used for 
+                regularization. The gradient operator is square (nC-by-nC)"""
+        def fget(self):
+            if self.dim < 3: return None
+            if getattr(self, '_unitCellGradx', None) is None:
+                
+                n = self.vnC
+                gx = ddx(n[0]-1)
+                gx_square = sp.vstack((gx,gx[-1,:]*-1), format="csr")
+                
+                self._unitCellGradx = kron3(speye(n[2]), speye(n[1]), gx_square)
+        
+            return self._unitCellGradx
+        return locals()
+    unitCellGradx = property(**unitCellGradx())
+    
+    def unitCellGrady():
+        doc = """Cell centered Gradient in they dimension used for 
+                regularization. The gradient operator is square (nC-by-nC)"""
+        def fget(self):
+            if self.dim < 3: return None
+            if getattr(self, '_unitCellGrady', None) is None:
+        
+                n = self.vnC
+                gy = ddx(n[1]-1)
+                gy_square = sp.vstack((gy,gy[-1,:]*-1), format="csr")
+                
+                self._unitCellGrady = kron3(speye(n[2]), gy_square, speye(n[0]))
+            
+            return self._unitCellGrady
+        return locals()
+    unitCellGrady = property(**unitCellGrady())
+        
+    def unitCellGradz():
+        doc = """Cell centered Gradient in they dimension used for 
+                regularization. The gradient operator is square (nC-by-nC)"""
+        def fget(self):
+            if self.dim < 3: return None
+            if getattr(self, '_unitCellGradz', None) is None:
+        
+                n = self.vnC
+                gz = ddx(n[2]-1)
+                gz_square = sp.vstack((gz,gz[-1,:]*-1), format="csr")
+                
+                self._unitCellGradz = kron3( gz_square , speye(n[1]), speye(n[0]))
+            
+            return self._unitCellGradz
+        return locals()
+    unitCellGradz = property(**unitCellGradz())        
+        
     # --------------- Averaging ---------------------
 
     @property
@@ -825,3 +797,4 @@ class DiffOperators(object):
                                           kron3(av(n[2]), speye(n[1]+1), av(n[0])),
                                           kron3(speye(n[2]+1), av(n[1]), av(n[0]))), format="csr")
         return self._aveN2F
+

SimPEG/Mesh/MeshIO.py

@@ -21,9 +21,10 @@ class TensorMeshIO(object):
                 if '*' in seg:
                     st = seg
                     sp = seg.split('*')
-                    re = int(sp[0])*(' ' + sp[1])
+                    re = np.array(sp[0],dtype=int)*(' ' + 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='!')
 

SimPEG/Mesh/TensorMesh.py

@@ -234,9 +234,6 @@ class BaseTensorMesh(BaseMesh):
             'Fz'    -> z-component of field defined on faces
             'N'     -> scalar field defined on nodes
             'CC'    -> scalar field defined on cell centers
-            'CCVx'  -> x-component of vector field defined on cell centers
-            'CCVy'  -> y-component of vector field defined on cell centers
-            'CCVz'  -> z-component of vector field defined on cell centers
         """
         if self._meshType == 'CYL' and self.isSymmetric and locType in ['Ex','Ez','Fy']:
             raise Exception('Symmetric CylMesh does not support %s interpolation, as this variable does not exist.' % locType)
@@ -260,16 +257,6 @@ class BaseTensorMesh(BaseMesh):
             Q = sp.hstack(components)
         elif locType in ['CC', 'N']:
             Q = Utils.interpmat(loc, *self.getTensor(locType))
-        elif locType in ['CCVx', 'CCVy', 'CCVz']:
-            Q = Utils.interpmat(loc, *self.getTensor('CC'))
-            Z = Utils.spzeros(loc.shape[0],self.nC)
-            if locType == 'CCVx':
-                Q = sp.hstack([Q,Z,Z])
-            elif locType == 'CCVy':
-                Q = sp.hstack([Z,Q,Z])
-            elif locType == 'CCVz':
-                Q = sp.hstack([Z,Z,Q])
-
         else:
             raise NotImplementedError('getInterpolationMat: locType=='+locType+' and mesh.dim=='+str(self.dim))
 

SimPEG/Mesh/TreeMesh.py

@@ -2131,16 +2131,10 @@ 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=None,
-        streamOpts=None,
-        gridOpts=None):
+        pcolorOpts={},
+        streamOpts={'color':'k'},
+        gridOpts={'color':'k', 'alpha':0.5}):
 
-        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=None,
-              streamOpts=None,
-              gridOpts=None,
+              pcolorOpts={},
+              streamOpts={'color':'k'},
+              gridOpts={'color':'k'},
               numbering=True, annotationColor='w'
               ):
         """
@@ -84,12 +84,6 @@ class TensorView(object):
             M.plotImage(v, annotationColor='k', showIt=True)
 
         """
-        if pcolorOpts is None:
-            pcolorOpts = {}
-        if streamOpts is None:
-            streamOpts = {'color':'k'}
-        if gridOpts is None:
-            gridOpts = {'color':'k'}
 
         if ax is None:
             fig = plt.figure()
@@ -180,9 +174,9 @@ class TensorView(object):
     def plotSlice(self, v, vType='CC',
                   normal='Z', ind=None, grid=False, view='real',
                   ax=None, clim=None, showIt=False,
-                  pcolorOpts=None,
-                  streamOpts=None,
-                  gridOpts=None
+                  pcolorOpts={},
+                  streamOpts={'color':'k'},
+                  gridOpts={'color':'k', 'alpha':0.5}
                   ):
 
         """
@@ -203,12 +197,6 @@ class TensorView(object):
             M.plotSlice(M.cellGrad*b, 'F', view='vec', grid=True, showIt=True, pcolorOpts={'alpha':0.8})
 
         """
-        if pcolorOpts is None:
-            pcolorOpts = {}
-        if streamOpts is None:
-            streamOpts = {'color':'k'}
-        if gridOpts is None:
-            gridOpts = {'color':'k', 'alpha':0.5}
         if type(vType) in [list, tuple]:
             assert ax is None, "cannot specify an axis to plot on with this function."
             fig, axs = plt.subplots(1,len(vType))
@@ -218,7 +206,7 @@ class TensorView(object):
             return out
         viewOpts = ['real','imag','abs','vec']
         normalOpts = ['X', 'Y', 'Z']
-        vTypeOpts = ['CC', 'CCv','N','F','E','Fx','Fy','Fz','E','Ex','Ey','Ez']
+        vTypeOpts = ['CC', 'CCv','F','E','Fx','Fy','Fz','E','Ex','Ey','Ez']
 
         # Some user error checking
         assert vType in vTypeOpts, "vType must be in ['%s']" % "','".join(vTypeOpts)
@@ -301,17 +289,11 @@ class TensorView(object):
 
     def _plotImage2D(self, v, vType='CC', grid=False, view='real',
               ax=None, clim=None, showIt=False,
-              pcolorOpts=None,
-              streamOpts=None,
-              gridOpts=None
+              pcolorOpts={},
+              streamOpts={'color':'k'},
+              gridOpts={'color':'k'}
               ):
 
-        if pcolorOpts is None:
-            pcolorOpts = {}
-        if streamOpts is None:
-            streamOpts = {'color':'k'}
-        if gridOpts is None:
-            gridOpts = {'color':'k'}
         vTypeOptsCC = ['N','CC','Fx','Fy','Ex','Ey']
         vTypeOptsV = ['CCv','F','E']
         vTypeOpts = vTypeOptsCC + vTypeOptsV
@@ -552,8 +534,7 @@ class CurvView(object):
     def __init__(self):
         pass
 
-
-    def plotGrid(self, ax=None, nodes=False, faces=False, centers=False, edges=False, lines=True,  showIt=False):
+    def plotGrid(self, length=0.05, showIt=False):
         """Plot the nodal, cell-centered and staggered grids for 1,2 and 3 dimensions.
 
 
@@ -561,63 +542,60 @@ class CurvView(object):
             :include-source:
 
             from SimPEG import Mesh, Utils
-            X, Y = Utils.exampleLrmGrid([3,3],'rotate')
+            X, Y = Utils.exampleCurvGird([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()
 
-            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()
 
-                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]
 
-                X = np.r_[X1, X2]
-                Y = np.r_[Y1, Y2]
+            plt.plot(X, Y)
 
-                ax.plot(X, Y, 'b-')
-            if centers:
-                ax.plot(self.gridCC[:,0],self.gridCC[:,1],'ro')
+            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')
 
-            # 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')
+            plt.plot(self.gridN[:, 0], self.gridN[:, 1], 'bo')
 
-            # 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()
+            plt.plot(self.gridFx[:, 0], self.gridFx[:, 1], 'rs')
+            plt.plot(nX, nY, 'r-')
 
-            # 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()
+            #plt.plot(self.gridFy[:, 0], self.gridFy[:, 1], 'gs')
+            plt.plot(nX, nY, 'g-')
 
-            # 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()
+            plt.plot(self.gridEx[:, 0], self.gridEx[:, 1], 'r^')
+            plt.plot(tX, tY, '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()
-            # 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-')
+            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')
 
         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()
@@ -634,50 +612,16 @@ class CurvView(object):
             Y = np.r_[Y1, Y2, Y3]
             Z = np.r_[Z1, Z2, Z3]
 
-            ax.plot(X, Y, 'b', zs=Z)
+            plt.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

@@ -888,8 +888,6 @@ class ProjectedGNCG(BFGS, Minimize, Remember):
     maxIterCG = 5
     tolCG = 1e-1
 
-    stepOffBoundsFact = 0.1 # perturbation of the inactive set off the bounds
-
     lower = -np.inf
     upper = np.inf
 
@@ -991,19 +989,17 @@ class ProjectedGNCG(BFGS, Minimize, Remember):
                 if np.logical_or(norm(resid)/normResid0 <= self.tolCG, cgiter == self.maxIterCG):
                     cgFlag = 1
                 # End CG Iterations
-
+                    
             # Take a gradient step on the active cells if exist
             if temp != self.xc.size:
-
+        
                 rhs_a = (Active) * -self.g
-
+                
                 dm_i = max( abs( delx ) )
-                dm_a = max( abs(rhs_a) )
-
-                # perturb inactive set off of bounds so that they are included in the step
-                delx = delx + self.stepOffBoundsFact * (rhs_a * dm_i / dm_a)
-
-
+                dm_a = max( abs(rhs_a) )           
+    
+                delx = delx + rhs_a * dm_i / dm_a /10.
+                    
             # 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.