- rx.projectFields --> rx.eval

- rx.projectFieldsDeriv --> rx.evalDeriv

SimPEG/EM/FDEM/FDEM.py

@@ -98,7 +98,7 @@ def Jvec(self, m, v, u=None):
 
                     Df_Dm = np.array(df_dudu_dm + df_dm,dtype=complex)
 
-                    P = lambda v: rx.projectFieldsDeriv(src, self.mesh, u, v) # wrt u, also have wrt m
+                    P = lambda v: rx.evalDeriv(src, self.mesh, u, v) # wrt u, also have wrt m
 
                     Jv[src, rx] = P(Df_Dm)
 
@@ -136,7 +136,7 @@ def Jtvec(self, m, v, u=None):
                 u_src = u[src, ftype]
 
                 for rx in src.rxList:
-                    PTv = rx.projectFieldsDeriv(src, self.mesh, u, v[src, rx], adjoint=True) # wrt u, need possibility wrt m
+                    PTv = rx.evalDeriv(src, self.mesh, u, v[src, rx], adjoint=True) # wrt u, need possibility wrt m
 
                     df_duTFun = getattr(u, '_%sDeriv_u'%rx.projField, None)
                     df_duT = df_duTFun(src, PTv, adjoint=True)

SimPEG/EM/FDEM/SurveyFDEM.py

@@ -66,7 +66,7 @@ def projComp(self):
         """Component projection (real/imag)"""
         return self.knownRxTypes[self.rxType][2]
 
-    def projectFields(self, src, mesh, f):
+    def eval(self, src, mesh, f):
         """
         Project fields to recievers to get data.
 
@@ -82,7 +82,7 @@ def projectFields(self, src, mesh, f):
         u_part = getattr(u_part_complex, real_or_imag)
         return P*u_part
 
-    def projectFieldsDeriv(self, src, mesh, f, v, adjoint=False):
+    def evalDeriv(self, src, mesh, f, v, adjoint=False):
         """
         Derivative of projected fields with respect to the inversion model times a vector.
 
@@ -170,7 +170,7 @@ def getSrcByFreq(self, freq):
         assert freq in self._freqDict, "The requested frequency is not in this survey."
         return self._freqDict[freq]
 
-    def projectFields(self, u):
+    def eval(self, u):
         """
         Project fields to receiver locations
         :param Fields u: fields object
@@ -180,8 +180,8 @@ 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)
+                data[src, rx] = rx.eval(src, self.mesh, u)
         return data
 
-    def projectFieldsDeriv(self, u):
+    def evalDeriv(self, u):
         raise Exception('Use Receivers to project fields deriv.')

SimPEG/EM/TDEM/BaseTDEM.py

@@ -128,7 +128,7 @@ def Jvec(self, m, v, u=None):
             u = self.fields(m)
         p = self.Gvec(m, v, u)
         y = self.solveAh(m, p)
-        Jv = self.survey.projectFieldsDeriv(u, v=y)
+        Jv = self.survey.evalDeriv(u, v=y)
         if self.verbose: print '%s\nDone calculating J(v)\n%s'%('*'*50,'*'*50)
         return - mkvc(Jv)
 
@@ -155,7 +155,7 @@ def Jtvec(self, m, v, u=None):
         if not isinstance(v, self.dataPair):
             v = self.dataPair(self.survey, v)
 
-        p = self.survey.projectFieldsDeriv(u, v=v, adjoint=True)
+        p = self.survey.evalDeriv(u, v=v, adjoint=True)
         y = self.solveAht(m, p)
         w = self.Gtvec(m, y, u)
         if self.verbose: print '%s\nDone calculating J^T(v)\n%s'%('*'*50,'*'*50)

SimPEG/EM/TDEM/SurveyTDEM.py

@@ -51,12 +51,12 @@ def getTimeP(self, timeMesh):
         else:
             return timeMesh.getInterpolationMat(self.times, self.projTLoc)
 
-    def projectFields(self, src, mesh, timeMesh, u):
+    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 projectFieldsDeriv(self, src, mesh, timeMesh, u, v, adjoint=False):
+    def evalDeriv(self, src, mesh, timeMesh, u, v, adjoint=False):
         P = self.getP(mesh, timeMesh)
 
         if not adjoint:
@@ -168,27 +168,27 @@ def __init__(self, srcList, **kwargs):
         self.srcList = srcList
         Survey.BaseSurvey.__init__(self, **kwargs)
 
-    def projectFields(self, u):
+    def eval(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)
+                data[src, rx] = rx.eval(src, self.mesh, self.prob.timeMesh, u)
         return data
 
-    def projectFieldsDeriv(self, u, v=None, adjoint=False):
+    def evalDeriv(self, u, v=None, adjoint=False):
         assert v is not None, 'v to multiply must be provided.'
 
         if not adjoint:
             data = Survey.Data(self)
             for src in self.srcList:
                 for rx in src.rxList:
-                    data[src, rx] = rx.projectFieldsDeriv(src, self.mesh, self.prob.timeMesh, u, v)
+                    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.projectFieldsDeriv(src, self.mesh, self.prob.timeMesh, u, v, adjoint=True)
+                    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

SimPEG/Examples/Inversion_Linear.py

@@ -11,7 +11,7 @@ def run(N=100, plotIt=True):
     """
 
     class LinearSurvey(Survey.BaseSurvey):
-        def projectFields(self, u):
+        def eval(self, u):
             return u
 
     class LinearProblem(Problem.BaseProblem):

SimPEG/Examples/MT_3D_Foward.py

@@ -52,7 +52,7 @@ def run(plotIt=True, nFreq=1):
 
     # Calculate the data
     fields = problem.fields(sig)
-    dataVec = survey.projectFields(fields)
+    dataVec = survey.eval(fields)
 
     # Make the data
     mtData = MT.Data(survey,dataVec)

SimPEG/FLOW/Richards/RichardsProblem.py

@@ -8,7 +8,7 @@ class RichardsRx(Survey.BaseTimeRx):
 
     knownRxTypes = ['saturation','pressureHead']
 
-    def projectFields(self, U, m, mapping, mesh, timeMesh):
+    def eval(self, U, m, mapping, mesh, timeMesh):
 
         if self.rxType == 'pressureHead':
             u = np.concatenate(U)
@@ -17,7 +17,7 @@ def projectFields(self, U, m, mapping, mesh, timeMesh):
 
         return self.getP(mesh, timeMesh) * u
 
-    def projectFieldsDeriv(self, U, m, mapping, mesh, timeMesh):
+    def evalDeriv(self, U, m, mapping, mesh, timeMesh):
 
         P = self.getP(mesh, timeMesh)
         if self.rxType == 'pressureHead':
@@ -57,25 +57,25 @@ def dpred(self, m, u=None):
             Where P is a projection of the fields onto the data space.
         """
         if u is None: u = self.prob.fields(m)
-        return Utils.mkvc(self.projectFields(u, m))
+        return Utils.mkvc(self.eval(u, m))
 
     @Utils.requires('prob')
-    def projectFields(self, U, m):
+    def eval(self, U, m):
         Ds = range(len(self.rxList))
         for ii, rx in enumerate(self.rxList):
-            Ds[ii] = rx.projectFields(U, m,
+            Ds[ii] = rx.eval(U, m,
                                 self.prob.mapping,
                                 self.prob.mesh,
                                 self.prob.timeMesh)
 
         return np.concatenate(Ds)
 
     @Utils.requires('prob')
-    def projectFieldsDeriv(self, U, m):
+    def evalDeriv(self, U, m):
         """The Derivative with respect to the fields."""
         Ds = range(len(self.rxList))
         for ii, rx in enumerate(self.rxList):
-            Ds[ii] = rx.projectFieldsDeriv(U, m,
+            Ds[ii] = rx.evalDeriv(U, m,
                                 self.prob.mapping,
                                 self.prob.mesh,
                                 self.prob.timeMesh)
@@ -251,7 +251,7 @@ def Jfull(self, m, u=None):
         B = np.array(sp.vstack(Bs).todense())
 
         Ainv = self.Solver(A, **self.solverOpts)
-        P = self.survey.projectFieldsDeriv(u, m)
+        P = self.survey.evalDeriv(u, m)
         AinvB = Ainv * B
         z = np.zeros((self.mesh.nC, B.shape[1]))
         zAinvB = np.vstack((z, AinvB))
@@ -277,15 +277,15 @@ def Jvec(self, m, v, u=None):
             Adiaginv = self.Solver(Adiag, **self.solverOpts)
             JvC[ii] = Adiaginv * (B*v - Asub*JvC[ii-1])
 
-        P = self.survey.projectFieldsDeriv(u, m)
+        P = self.survey.evalDeriv(u, m)
         return P * np.concatenate([np.zeros(self.mesh.nC)] + JvC)
 
     @Utils.timeIt
     def Jtvec(self, m, v, u=None):
         if u is None:
             u = self.field(m)
 
-        P = self.survey.projectFieldsDeriv(u, m)
+        P = self.survey.evalDeriv(u, m)
         PTv = P.T*v
 
         # This is done via backward substitution.

SimPEG/MT/BaseMT.py

@@ -68,7 +68,7 @@ def Jvec(self, m, v, u=None):
                 for rx in src.rxList:
                     # Get the projection derivative
                     # v should be of size 2*nE (for 2 polarizations)
-                    PDeriv_u = lambda t: rx.projectFieldsDeriv(src, self.mesh, u, t) # wrt u, we don't have have PDeriv wrt m
+                    PDeriv_u = lambda t: rx.evalDeriv(src, self.mesh, u, 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
@@ -106,9 +106,9 @@ def Jtvec(self, m, v, u=None):
                 u_src = u[src, :]
 
                 for rx in src.rxList:
-                    # Get the adjoint projectFieldsDeriv
+                    # Get the adjoint evalDeriv
                     # PTv needs to be nE,
-                    PTv = rx.projectFieldsDeriv(src, self.mesh, u, mkvc(v[src, rx],2), adjoint=True) # wrt u, need possibility wrt m
+                    PTv = rx.evalDeriv(src, self.mesh, u, 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, u_src, mkvc(dA_duIT), adjoint=True)

SimPEG/MT/SurveyMT.py

@@ -59,7 +59,7 @@ def projComp(self):
         """Component projection (real/imag)"""
         return self.knownRxTypes[self.rxType][1]
 
-    def projectFields(self, src, mesh, f):
+    def eval(self, src, mesh, f):
         '''
         Project the fields to natural source data.
 
@@ -139,7 +139,7 @@ def projectFields(self, src, mesh, f):
         # print f_part
         return f_part
 
-    def projectFieldsDeriv(self, src, mesh, f, v, adjoint=False):
+    def evalDeriv(self, src, mesh, f, v, adjoint=False):
         """
         The derivative of the projection wrt u
 
@@ -427,15 +427,15 @@ def getSrcByFreq(self, freq):
         assert freq in self._freqDict, "The requested frequency is not in this survey."
         return self._freqDict[freq]
 
-    def projectFields(self, u):
+    def eval(self, u):
         data = Data(self)
         for src in self.srcList:
             sys.stdout.flush()
             for rx in src.rxList:
-                data[src, rx] = rx.projectFields(src, self.mesh, u)
+                data[src, rx] = rx.eval(src, self.mesh, u)
         return data
 
-    def projectFieldsDeriv(self, u):
+    def evalDeriv(self, u):
         raise Exception('Use Transmitters to project fields deriv.')
 
 #################

SimPEG/Survey.py

@@ -307,32 +307,32 @@ def dpred(self, m, u=None):
             Where P is a projection of the fields onto the data space.
         """
         if u is None: u = self.prob.fields(m)
-        return Utils.mkvc(self.projectFields(u))
+        return Utils.mkvc(self.eval(u))
 
 
     @Utils.count
-    def projectFields(self, u):
-        """projectFields(u)
+    def eval(self, u):
+        """eval(u)
 
             This function projects the fields onto the data space.
 
             .. math::
 
                 d_\\text{pred} = \mathbf{P} u(m)
         """
-        raise NotImplemented('projectFields is not yet implemented.')
+        raise NotImplemented('eval is not yet implemented.')
 
     @Utils.count
-    def projectFieldsDeriv(self, u):
-        """projectFieldsDeriv(u)
+    def evalDeriv(self, u):
+        """evalDeriv(u)
 
             This function s the derivative of projects the fields onto the data space.
 
             .. math::
 
                 \\frac{\partial d_\\text{pred}}{\partial u} = \mathbf{P}
         """
-        raise NotImplemented('projectFields is not yet implemented.')
+        raise NotImplemented('eval is not yet implemented.')
 
     @Utils.count
     def residual(self, m, u=None):

tests/em/tdem/test_TDEM_b_DerivAdjoint.py

@@ -204,8 +204,8 @@ def test_projectAdjoint(self):
         d = Survey.Data(survey,v=d_vec)
 
         # Check that d.T*Q*f = f.T*Q.T*d
-        V1 = d_vec.dot(survey.projectFieldsDeriv(None, v=f).tovec())
-        V2 = f.tovec().dot(survey.projectFieldsDeriv(None, v=d, adjoint=True).tovec())
+        V1 = d_vec.dot(survey.evalDeriv(None, v=f).tovec())
+        V2 = f.tovec().dot(survey.evalDeriv(None, v=d, adjoint=True).tovec())
 
         self.assertTrue((V1-V2)/np.abs(V1) < tol)
 

tests/em/tdem/test_TDEM_b_MultiSrc_DerivAdjoint.py

@@ -108,8 +108,8 @@ def test_projectAdjoint(self):
         d = Survey.Data(survey,v=d_vec)
 
         # Check that d.T*Q*f = f.T*Q.T*d
-        V1 = d_vec.dot(survey.projectFieldsDeriv(None, v=f).tovec())
-        V2 = np.sum((f.tovec())*(survey.projectFieldsDeriv(None, v=d, adjoint=True).tovec()))
+        V1 = d_vec.dot(survey.evalDeriv(None, v=f).tovec())
+        V2 = np.sum((f.tovec())*(survey.evalDeriv(None, v=d, adjoint=True).tovec()))
 
         self.assertTrue((V1-V2)/np.abs(V1) < 1e-6)
 

tests/mt/test_Problem1D_againstAnalyticHalfspace.py

@@ -70,7 +70,7 @@ def appRes_TotalFieldNorm(sigmaHalf):
     fields = problem.fields(sigma)
 
     # Project the data
-    data = survey.projectFields(fields)
+    data = survey.eval(fields)
 
     # Calculate the app res and phs
     app_r = np.array(getAppResPhs(data))[:,0]
@@ -88,7 +88,7 @@ def appPhs_TotalFieldNorm(sigmaHalf):
     fields = problem.fields(sigma)
 
     # Project the data
-    data = survey.projectFields(fields)
+    data = survey.eval(fields)
 
     # Calculate the app  phs
     app_p = np.array(getAppResPhs(data))[:,1]
@@ -106,7 +106,7 @@ def appRes_psFieldNorm(sigmaHalf):
     fields = problem.fields(sigma)
 
     # Project the data
-    data = survey.projectFields(fields)
+    data = survey.eval(fields)
 
     # Calculate the app res and phs
     app_r = np.array(getAppResPhs(data))[:,0]
@@ -124,7 +124,7 @@ def appPhs_psFieldNorm(sigmaHalf):
     fields = problem.fields(sigma)
 
     # Project the data
-    data = survey.projectFields(fields)
+    data = survey.eval(fields)
 
     # Calculate the app  phs
     app_p = np.array(getAppResPhs(data))[:,1]

tests/mt/test_Problem3D_againstAnalytic.py

@@ -210,7 +210,7 @@ def fun(u):
         f = problem.fieldsPair(survey.mesh,survey)
         f[src,'e_pxSolution'] = u[:len(u)/2]
         f[src,'e_pySolution'] = u[len(u)/2::]
-        return rx.projectFields(src,survey.mesh,f), lambda t: rx.projectFieldsDeriv(src,survey.mesh,f0,simpeg.mkvc(t,2))
+        return rx.eval(src,survey.mesh,f), lambda t: rx.evalDeriv(src,survey.mesh,f0,simpeg.mkvc(t,2))
 
     return simpeg.Tests.checkDerivative(fun, u0, num=3, plotIt=False, eps=FLR)