diff --git a/.bumpversion.cfg b/.bumpversion.cfg index ea37cced..84469e3f 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,4 +1,4 @@ [bumpversion] -current_version = 0.1.9 +current_version = 0.1.10 files = setup.py SimPEG/__init__.py docs/conf.py diff --git a/.travis.yml b/.travis.yml index bec55e9c..a4614a6b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,7 +18,9 @@ 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 @@ -54,3 +56,5 @@ notifications: email: - rowanc1@gmail.com - lindseyheagy@gmail.com + - gkrosen@gmail.com + - sgkang09@gmail.com diff --git a/SimPEG/DCIP/BaseDC.py b/SimPEG/DCIP/BaseDC.py new file mode 100644 index 00000000..e3d353d7 --- /dev/null +++ b/SimPEG/DCIP/BaseDC.py @@ -0,0 +1,294 @@ +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, u=None): + """ + :param numpy.array m: model + :param numpy.array v: vector to multiply + :param numpy.array u: 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 u is None: + # Run forward simulation if $u$ not provided + u = self.fields(self.curModel)[self.survey.srcList, 'phi_sol'] + else: + u = u[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, u=None): + + self.curModel = m + sigma = self.curModel.transform # $\sigma = \mathcal{M}(\m)$ + if u is None: + # Run forward simulation if $u$ not provided + u = self.fields(self.curModel)[self.survey.srcList, 'phi_sol'] + else: + u = u[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 + + + + + diff --git a/SimPEG/DCIP/BaseIP.py b/SimPEG/DCIP/BaseIP.py new file mode 100644 index 00000000..cec0ea2e --- /dev/null +++ b/SimPEG/DCIP/BaseIP.py @@ -0,0 +1,182 @@ +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, u=None): + """ + Predicted data. + + .. math:: + d_\\text{pred} = Pu(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, u=None): + return self.forward(v) + + def Jtvec(self, m, v, u=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 + diff --git a/SimPEG/DCIP/DCIPUtils.py b/SimPEG/DCIP/DCIPUtils.py new file mode 100644 index 00000000..90bbbca0 --- /dev/null +++ b/SimPEG/DCIP/DCIPUtils.py @@ -0,0 +1,934 @@ +from SimPEG import np +import BaseDC as DC +import BaseDC as IP + +def getActiveindfromTopo(mesh, topo): +# def genActiveindfromTopo(mesh, topo): + """ + Get active indices from topography + """ + from scipy.interpolate import NearestNDInterpolator + if mesh.dim==3: + nCxy = mesh.nCx*mesh.nCy + Zcc = mesh.gridCC[:,2].reshape((nCxy, mesh.nCz), order='F') + Ftopo = NearestNDInterpolator(topo[:,:2], topo[:,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)) + +def gettopoCC(mesh, airind): +# def gettopoCC(mesh, airind): + """ + Get topography from active indices of mesh. + """ + mesh2D = Mesh.TensorMesh([mesh.hx, mesh.hy], mesh.x0[:2]) + zc = mesh.gridCC[:,2] + AIRIND = airind.reshape((mesh.vnC[0]*mesh.vnC[1],mesh.vnC[2]), order='F') + ZC = zc.reshape((mesh.vnC[0]*mesh.vnC[1], mesh.vnC[2]), order='F') + topo = np.zeros(ZC.shape[0]) + topoCC = np.zeros(ZC.shape[0]) + for i in range(ZC.shape[0]): + ind = np.argmax(ZC[i,:][~AIRIND[i,:]]) + topo[i] = ZC[i,:][~AIRIND[i,:]].max() + mesh.hz[~AIRIND[i,:]][ind]*0.5 + topoCC[i] = ZC[i,:][~AIRIND[i,:]].max() + XY = Utils.ndgrid(mesh.vectorCCx, mesh.vectorCCy) + return mesh2D, topoCC + +def readUBC_DC3Dobstopo(filename,mesh,topo,probType="CC"): + """ + Seogi's personal readObs function. + + """ + text_file = open(filename, "r") + lines = text_file.readlines() + text_file.close() + SRC = [] + DATA = [] + srcLists = [] + isrc = 0 + # airind = getActiveindfromTopo(mesh, topo) + # mesh2D, topoCC = gettopoCC(mesh, airind) + + for line in lines: + if "!" in line.split(): continue + elif line == '\n': continue + elif line == ' \n': continue + temp = map(float, line.split()) + # Read a line for the current electrode + if len(temp) == 5: # SRC: Only X and Y are provided (assume no topography) + #TODO consider topography and assign the closest cell center in the earth + if isrc == 0: + DATA_temp = [] + else: + DATA.append(np.asarray(DATA_temp)) + DATA_temp = [] + indM = Utils.closestPoints(mesh2D, DATA[isrc-1][:,1:3]) + indN = Utils.closestPoints(mesh2D, DATA[isrc-1][:,3:5]) + rx = DCIP.RxDipole(np.c_[DATA[isrc-1][:,1:3], topoCC[indM]], np.c_[DATA[isrc-1][:,3:5], topoCC[indN]]) + temp = np.asarray(temp) + if [SRC[isrc-1][0], SRC[isrc-1][1]] == [SRC[isrc-1][2], SRC[isrc-1][3]]: + indA = Utils.closestPoints(mesh2D, [SRC[isrc-1][0], SRC[isrc-1][1]]) + tx = DCIP.SrcDipole([rx], [SRC[isrc-1][0], SRC[isrc-1][1], topoCC[indA]],[mesh.vectorCCx.max(), mesh.vectorCCy.max(), topoCC[-1]]) + else: + indA = Utils.closestPoints(mesh2D, [SRC[isrc-1][0], SRC[isrc-1][1]]) + indB = Utils.closestPoints(mesh2D, [SRC[isrc-1][2], SRC[isrc-1][3]]) + tx = DCIP.SrcDipole([rx], [SRC[isrc-1][0], SRC[isrc-1][1], topoCC[indA]],[SRC[isrc-1][2], SRC[isrc-1][3], topoCC[indB]]) + srcLists.append(tx) + SRC.append(temp) + isrc += 1 + elif len(temp) == 7: # SRC: X, Y and Z are provided + SRC.append(temp) + isrc += 1 + elif len(temp) == 6: # + DATA_temp.append(np.r_[isrc, np.asarray(temp)]) + elif len(temp) > 7: + DATA_temp.append(np.r_[isrc, np.asarray(temp)]) + + DATA.append(np.asarray(DATA_temp)) + DATA_temp = [] + indM = Utils.closestPoints(mesh2D, DATA[isrc-1][:,1:3]) + indN = Utils.closestPoints(mesh2D, DATA[isrc-1][:,3:5]) + rx = DCIP.RxDipole(np.c_[DATA[isrc-1][:,1:3], topoCC[indM]], np.c_[DATA[isrc-1][:,3:5], topoCC[indN]]) + temp = np.asarray(temp) + if [SRC[isrc-1][0], SRC[isrc-1][1]] == [SRC[isrc-1][2], SRC[isrc-1][3]]: + indA = Utils.closestPoints(mesh2D, [SRC[isrc-1][0], SRC[isrc-1][1]]) + tx = DCIP.SrcDipole([rx], [SRC[isrc-1][0], SRC[isrc-1][1], topoCC[indA]],[mesh.vectorCCx.max(), mesh.vectorCCy.max(), topoCC[-1]]) + else: + indA = Utils.closestPoints(mesh2D, [SRC[isrc-1][0], SRC[isrc-1][1]]) + indB = Utils.closestPoints(mesh2D, [SRC[isrc-1][2], SRC[isrc-1][3]]) + tx = DCIP.SrcDipole([rx], [SRC[isrc-1][0], SRC[isrc-1][1], topoCC[indA]],[SRC[isrc-1][2], SRC[isrc-1][3], topoCC[indB]]) + srcLists.append(tx) + text_file.close() + survey = DCIP.SurveyDC(srcLists) + + # Do we need this? + SRC = np.asarray(SRC) + DATA = np.vstack(DATA) + survey.dobs = np.vstack(DATA)[:,-2] + + + return {'DCsurvey':survey, 'airind':airind, 'topoCC':topoCC, 'SRC':SRC} + +def readUBC_DC2DModel(fileName): + """ + Read UBC GIF 2DTensor model and generate 2D Tensor model in simpeg + + Input: + :param fileName, path to the UBC GIF 2D model file + + Output: + :param SimPEG TensorMesh 2D object + :return + + Created on Thu Nov 12 13:14:10 2015 + + @author: dominiquef + + """ + from SimPEG import np, mkvc + + # Open fileand skip header... assume that we know the mesh already + obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!') + + dim = np.array(obsfile[0].split(),dtype=float) + + temp = np.array(obsfile[1].split(),dtype=float) + + if len(temp) > 1: + model = np.zeros(dim) + + for ii in range(len(obsfile)-1): + mm = np.array(obsfile[ii+1].split(),dtype=float) + model[:,ii] = mm + + model = model[:,::-1] + + else: + + if len(obsfile[1:])==1: + mm = np.array(obsfile[1:].split(),dtype=float) + + else: + mm = np.array(obsfile[1:],dtype=float) + + # Permute the second dimension to flip the order + model = mm.reshape(dim[1],dim[0]) + + model = model[::-1,:] + model = np.transpose(model, (1, 0)) + + model = mkvc(model) + + + return model + +def plot_pseudoSection(DCsurvey, axs, stype): + """ + 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) + + 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 = [] + 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 + MA = np.abs(Tx[0][0] - Rx[0][:,0]) + MB = np.abs(Tx[1][0] - Rx[0][:,0]) + NB = np.abs(Tx[1][0] - Rx[1][:,0]) + NA = np.abs(Tx[0][0] - Rx[1][:,0]) + MN = np.abs(Rx[1][:,0] - Rx[0][:,0]) + + # Create mid-point location + Cmid = (Tx[0][0] + Tx[1][0])/2 + Pmid = (Rx[0][:,0] + Rx[1][:,0])/2 + + # Compute pant leg of apparent rho + if stype == 'pdp': + leg = data * 2*np.pi * MA * ( MA + MN ) / MN + + leg = np.log10(abs(1/leg)) + + elif stype == 'dpdp': + leg = data * 2*np.pi / ( 1/MA - 1/MB - 1/NB + 1/NA ) + + + midx = np.hstack([midx, ( Cmid + Pmid )/2 ]) + midz = np.hstack([midz, -np.abs(Cmid-Pmid)/2 + z0 ]) + rho = np.hstack([rho,leg]) + + + 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') + + + plt.imshow(grid_rho.T, extent = (np.min(midx),np.max(midx),np.min(midz),np.max(midz)), origin='lower', alpha=0.8, vmin = np.min(rho), vmax = np.max(rho)) + cbar = plt.colorbar(format = '%.2f',fraction=0.04,orientation="horizontal") + + cmin,cmax = cbar.get_clim() + ticks = np.linspace(cmin,cmax,3) + cbar.set_ticks(ticks) + + # Plot apparent resistivity + plt.scatter(midx,midz,s=50,c=rho.T) + + ax.set_xticklabels([]) + + ax.set_ylabel('Z') + ax.yaxis.tick_right() + ax.yaxis.set_label_position('right') + plt.gca().set_aspect('equal', adjustable='box') + + + return ax + +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 + + # Create line of P1 locations + M = np.c_[stn_x, stn_y, np.ones(nstn).T*mesh.vectorNz[-1]] + + # Create line of P2 locations + N = np.c_[stn_x+a*dl_x, stn_y+a*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]] + + ## 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] + Tx = [] + Rx = [] + 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 + # Create line of P1 locations + P1 = np.c_[stn_x, stn_y, np.ones(nstn).T*mesh.vectorNz[-1]] + + # Create line of P2 locations + P2 = np.c_[stn_x+a*dl_x, stn_y+a*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]] + + Rx.append(np.c_[P1,P2]) + rxClass = DC.RxDipole(P1, P2) + Tx.append(tx) + if stype == 'dpdp': + srcClass = DC.SrcDipole([rxClass], M[ii,:],N[ii,:]) + elif stype == 'pdp': + srcClass = DC.SrcDipole([rxClass], M[ii,:],M[ii,:]) + SrcList.append(srcClass) + +#============================================================================== +# elif re.match(stype,'dpdp'): +# +# for ii in range(0, int(nstn)-2): +# +# indx = np.min([ii+n+1,nstn]) +# Tx.append(np.c_[M[ii,:],N[ii,:]]) +# Rx.append(np.c_[M[ii+2:indx,:],N[ii+2:indx,:]]) +#============================================================================== + + 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 + + Tx.append(np.c_[M[0,:],N[-1,:]]) + + # Get the edge limit of survey area + min_x = endl[0,0] + dl_x * b + min_y = endl[0,1] + dl_y * b + + 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*mesh.vectorNz[-1]] + N = np.c_[ lxx+a*dl_x, lyy+a*dl_y, np.ones(nstn).T*mesh.vectorNz[-1]] + + rx[(ii*nstn):((ii+1)*nstn),:] = np.c_[M,N] + + Rx.append(rx) + rxClass = DC.RxDipole(rx[:,:3], rx[:,3:]) + srcClass = DC.SrcDipole([rxClass], M[0,:], N[-1,:]) + SrcList.append(srcClass) + else: + print """stype must be either 'pdp', 'dpdp' or 'gradient'. """ + + survey = DC.SurveyDC(SrcList) + return survey, Tx, Rx + +def writeUBC_DCobs(fileName, DCsurvey, dtype, stype): + """ + Write UBC GIF DCIP 2D or 3D observation file + + Input: + :string fileName -> including path where the file is written out + :DCsurvey -> DC survey class object + :string dtype -> either '2D' | '3D' + :string stype -> either 'SURFACE' | 'GENERAL' + + Output: + :param UBC2D-Data file + :return + + Last edit: February 16th, 2016 + + @author: dominiquef + + """ + from SimPEG import mkvc + + assert (dtype=='2D') | (dtype=='3D'), "Data must be either '2D' | '3D'" + assert (stype=='SURFACE') | (stype=='GENERAL') | (stype=='SIMPLE'), "Data must be either 'SURFACE' | 'GENERAL' | 'SIMPLE'" + + fid = open(fileName,'w') + fid.write('! ' + stype + ' FORMAT\n') + + count = 0 + + for ii in range(DCsurvey.nSrc): + + tx = np.c_[DCsurvey.srcList[ii].loc] + + rx = DCsurvey.srcList[ii].rxList[0].locs + + nD = DCsurvey.srcList[ii].nD + + M = rx[0] + N = rx[1] + + # Adapt source-receiver location for dtype and stype + if dtype=='2D': + + if stype == 'SIMPLE': + + #fid.writelines("%e " % ii for ii in mkvc(tx[0,:])) + A = np.repeat(tx[0,0],M.shape[0],axis=0) + B = np.repeat(tx[0,1],M.shape[0],axis=0) + M = M[:,0] + N = N[:,0] + + np.savetxt(fid, np.c_[A, B, M, N , DCsurvey.dobs[count:count+nD], DCsurvey.std[count:count+nD] ], fmt='%e',delimiter=' ',newline='\n') + + + else: + + if stype == 'SURFACE': + + fid.writelines("%e " % ii for ii in mkvc(tx[0,:])) + M = M[:,0] + N = N[:,0] + + if stype == 'GENERAL': + + fid.writelines("%e " % ii for ii in mkvc(tx[::2,:])) + M = M[:,0::2] + N = N[:,0::2] + + fid.write('%i\n'% nD) + np.savetxt(fid, np.c_[ M, N , DCsurvey.dobs[count:count+nD], DCsurvey.std[count:count+nD] ], fmt='%e',delimiter=' ',newline='\n') + + if dtype=='3D': + + if stype == 'SURFACE': + + fid.writelines("%e " % ii for ii in mkvc(tx[0:2,:])) + M = M[:,0:2] + N = N[:,0:2] + + if stype == 'GENERAL': + + fid.writelines("%e " % ii for ii in mkvc(tx)) + + fid.write('%i\n'% nD) + np.savetxt(fid, np.c_[ M, N , DCsurvey.dobs[count:count+nD], DCsurvey.std[count:count+nD] ], fmt='%e',delimiter=' ',newline='\n') + + count += nD + + fid.close() + +def convertObs_DC3D_to_2D(DCsurvey,lineID): + """ + Read DC survey and data and change + coordinate system to distance along line assuming + all data is acquired along line. + First transmitter pole is assumed to be at the origin + + Assumes flat topo for now... + + Input: + :param Tx, Rx + + Output: + :figure Tx2d, Rx2d + + Edited Feb 17th, 2016 + + @author: dominiquef + + """ + from SimPEG import np + + def stn_id(v0,v1,r): + """ + Compute station ID along line + """ + + dl = int(v0.dot(v1)) * r + + return dl + + srcLists = [] + + srcMat = getSrc_locs(DCsurvey) + + # Find all unique line id + uniqueID = np.unique(lineID) + + for jj in range(len(uniqueID)): + + indx = np.where(lineID==uniqueID[jj])[0] + + # Find origin of survey + r = 1e+8 # Initialize to some large number + + Tx = srcMat[indx] + + x0 = Tx[0][0,0:2] # Define station zero along line + + vecTx, r1 = r_unit(x0,Tx[-1][1,0:2]) + + for ii in range(len(indx)): + + # Get all receivers + Rx = DCsurvey.srcList[indx[ii]].rxList[0].locs + nrx = Rx[0].shape[0] + + # Find A electrode along line + vec, r = r_unit(x0,Tx[ii][0,0:2]) + A = stn_id(vecTx,vec,r) + + # Find B electrode along line + vec, r = r_unit(x0,Tx[ii][1,0:2]) + B = stn_id(vecTx,vec,r) + + M = np.zeros(nrx) + N = np.zeros(nrx) + for kk in range(nrx): + + # Find all M electrodes along line + vec, r = r_unit(x0,Rx[0][kk,0:2]) + M[kk] = stn_id(vecTx,vec,r) + + # Find all N electrodes along line + vec, r = r_unit(x0,Rx[1][kk,0:2]) + N[kk] = stn_id(vecTx,vec,r) + + Rx = DC.RxDipole(np.c_[M,np.zeros(nrx),Rx[0][:,2]],np.c_[N,np.zeros(nrx),Rx[1][:,2]]) + + srcLists.append( DC.SrcDipole( [Rx], np.asarray([A,0,Tx[ii][0,2]]),np.asarray([B,0,Tx[ii][1,2]]) ) ) + + + DCsurvey2D = DC.SurveyDC(srcLists) + + DCsurvey2D.dobs = np.asarray(DCsurvey.dobs) + DCsurvey2D.std = np.asarray(DCsurvey.std) + + return DCsurvey2D + +def readUBC_DC3Dobs(fileName): + """ + Read UBC GIF DCIP 3D observation file and generate arrays for tx-rx location + + Input: + :param fileName, path to the UBC GIF 3D obs file + + Output: + :param rx, tx, d, wd + :return + + Created on Mon December 7th, 2015 + + @author: dominiquef + + """ + + # Load file + obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!') + + # Pre-allocate + srcLists = [] + Rx = [] + d = [] + wd = [] + zflag = True # Flag for z value provided + + # Countdown for number of obs/tx + count = 0 + for ii in range(obsfile.shape[0]): + + if not obsfile[ii]: + continue + + # First line is transmitter with number of receivers + if count==0: + + temp = (np.fromstring(obsfile[ii], dtype=float,sep=' ').T) + count = int(temp[-1]) + + # Check if z value is provided, if False -> nan + if len(temp)==5: + tx = np.r_[temp[0:2],np.nan,temp[0:2],np.nan] + zflag = False + + else: + tx = temp[:-1] + + rx = [] + continue + + temp = np.fromstring(obsfile[ii], dtype=float,sep=' ') + + if zflag: + + rx.append(temp[:-2]) + # Check if there is data with the location + if len(temp)==8: + d.append(temp[-2]) + wd.append(temp[-1]) + + else: + rx.append(np.r_[temp[0:2],np.nan,temp[0:2],np.nan] ) + # Check if there is data with the location + if len(temp)==6: + d.append(temp[-2]) + wd.append(temp[-1]) + + count = count -1 + + # Reach the end of transmitter block + if count == 0: + rx = np.asarray(rx) + Rx = DC.RxDipole(rx[:,:3],rx[:,3:]) + srcLists.append( DC.SrcDipole( [Rx], tx[:3],tx[3:]) ) + + # Create survey class + survey = DC.SurveyDC(srcLists) + + survey.dobs = np.asarray(d) + survey.std = np.asarray(wd) + + return {'DCsurvey':survey} + +def readUBC_DC2Dobs(fileName): + """ + Read UBC GIF 2D observation file and generate arrays for tx-rx location + + Input: + :param fileName, path to the UBC GIF 2D model file + + Output: + :param rx, tx + :return + + Created on Thu Nov 12 13:14:10 2015 + + @author: dominiquef + + """ + + from SimPEG import np + + # Load file + obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!') + + # Check first line and figure out if 2D or 3D file format + line = np.array(obsfile[0].split(),dtype=float) + + tx_A = [] + tx_B = [] + rx_M = [] + rx_N = [] + d = [] + wd = [] + + for ii in range(obsfile.shape[0]): + + # If len==3, then simple format where tx-rx is listed on each line + if len(line) == 4: + + temp = np.fromstring(obsfile[ii], dtype=float,sep=' ') + tx_A = np.hstack((tx_A,temp[0])) + tx_B = np.hstack((tx_B,temp[1])) + rx_M = np.hstack((rx_M,temp[2])) + rx_N = np.hstack((rx_N,temp[3])) + + + rx = np.transpose(np.array((rx_M,rx_N))) + tx = np.transpose(np.array((tx_A,tx_B))) + + return tx, rx, d, wd + +def readUBC_DC2DMesh(fileName): + """ + Read UBC GIF 2DTensor mesh and generate 2D Tensor mesh in simpeg + + Input: + :param fileName, path to the UBC GIF mesh file + + Output: + :param SimPEG TensorMesh 2D object + :return + + Created on Thu Nov 12 13:14:10 2015 + + @author: dominiquef + + """ + + from SimPEG import np + # Open file + fopen = open(fileName,'r') + + # Read down the file and unpack dx vector + def unpackdx(fid,nrows): + for ii in range(nrows): + + line = fid.readline() + var = np.array(line.split(),dtype=float) + + if ii==0: + x0= var[0] + xvec = np.ones(int(var[2])) * (var[1] - var[0]) / int(var[2]) + xend = var[1] + + else: + xvec = np.hstack((xvec,np.ones(int(var[1])) * (var[0] - xend) / int(var[1]))) + xend = var[0] + + return x0, xvec + + #%% Start with dx block + # First line specifies the number of rows for x-cells + line = fopen.readline() + nl = np.array(line.split(),dtype=float) + + [x0, dx] = unpackdx(fopen,nl) + + + #%% Move down the file until reaching the z-block + line = fopen.readline() + if not line: + line = fopen.readline() + + #%% End with dz block + # First line specifies the number of rows for z-cells + line = fopen.readline() + nl = np.array(line.split(),dtype=float) + + [z0, dz] = unpackdx(fopen,nl) + + # Flip z0 to be the bottom of the mesh for SimPEG + z0 = z0 - sum(dz) + dz = dz[::-1] + #%% Make the mesh using SimPEG + + from SimPEG import Mesh + tensMsh = Mesh.TensorMesh([dx,dz],(x0, z0)) + return tensMsh + +def xy_2_lineID(DCsurvey): + """ + Read DC survey class and append line ID. + Assumes that the locations are listed in the order + they were collected. May need to generalize for random + point locations, but will be more expensive + + Input: + :param DCdict Vectors of station location + + Output: + :param LineID Vector of integers + :return + + Created on Thu Feb 11, 2015 + + @author: dominiquef + + """ + + # Compute unit vector between two points + nstn = DCsurvey.nSrc + + # Pre-allocate space + lineID = np.zeros(nstn) + + linenum = 0 + indx = 0 + + for ii in range(nstn): + + if ii == 0: + + A = DCsurvey.srcList[ii].loc[0] + B = DCsurvey.srcList[ii].loc[1] + + xout = np.mean([A[0:2],B[0:2]], axis = 0) + + xy0 = A[:2] + xym = xout + + # Deal with replicate pole location + if np.all(xy0==xym): + + xym[0] = xym[0] + 1e-3 + + continue + + A = DCsurvey.srcList[ii].loc[0] + B = DCsurvey.srcList[ii].loc[1] + + xin = np.mean([A[0:2],B[0:2]], axis = 0) + + # Compute vector between neighbours + vec1, r1 = r_unit(xout,xin) + + # Compute vector between current stn and mid-point + vec2, r2 = r_unit(xym,xin) + + # Compute vector between current stn and start line + vec3, r3 = r_unit(xy0,xin) + + # Compute vector between mid-point and start line + vec4, r4 = r_unit(xym,xy0) + + # Compute dot product + ang1 = np.abs(vec1.dot(vec2)) + ang2 = np.abs(vec3.dot(vec4)) + + # If the angles are smaller then 45d, than next point is on a new line + if ((ang1 < np.cos(np.pi/4.)) | (ang2 < np.cos(np.pi/4.))) & (np.all(np.r_[r1,r2,r3,r4] > 0)): + + # Re-initiate start and mid-point location + xy0 = A[:2] + xym = xin + + # Deal with replicate pole location + if np.all(xy0==xym): + + xym[0] = xym[0] + 1e-3 + + linenum += 1 + indx = ii + + else: + xym = np.mean([xy0,xin], axis = 0) + + lineID[ii] = linenum + xout = xin + + return lineID + +def r_unit(p1,p2): + """ + r_unit(x,y) : Function computes the unit vector + between two points with coordinates p1(x1,y1) and p2(x2,y2) + + """ + + assert len(p1)==len(p2), 'locs must be the same shape.' + + dx = [] + for ii in range(len(p1)): + dx.append((p2[ii] - p1[ii])) + + # Compute length of vector + r = np.linalg.norm(np.asarray(dx)) + + + if r!=0: + vec = dx/r + + else: + vec = np.zeros(len(p1)) + + return vec, r + +def getSrc_locs(DCsurvey): + """ + + + """ + + srcMat = np.zeros((DCsurvey.nSrc,2,3)) + for ii in range(DCsurvey.nSrc): + print np.asarray(DCsurvey.srcList[ii].loc).shape + srcMat[ii,:,:] = np.asarray(DCsurvey.srcList[ii].loc) + + return srcMat diff --git a/SimPEG/DCIP/Utils.py b/SimPEG/DCIP/Utils.py new file mode 100644 index 00000000..702a2333 --- /dev/null +++ b/SimPEG/DCIP/Utils.py @@ -0,0 +1,38 @@ +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 diff --git a/SimPEG/DCIP/__init__.py b/SimPEG/DCIP/__init__.py new file mode 100644 index 00000000..08d1fe12 --- /dev/null +++ b/SimPEG/DCIP/__init__.py @@ -0,0 +1,4 @@ +from BaseDC import * +from BaseIP import * +from DCIPUtils import * +import Utils diff --git a/SimPEG/Directives.py b/SimPEG/Directives.py index 46576df5..2ed27c20 100644 --- a/SimPEG/Directives.py +++ b/SimPEG/Directives.py @@ -237,6 +237,39 @@ class SaveOutputDictEveryIteration(_SaveEveryIteration): # Save the file as a npz np.savez('{:03d}-{:s}'.format(self.opt.iter,self.fileName), iter=self.opt.iter, beta=self.invProb.beta, phi_d=self.invProb.phi_d, phi_m=self.invProb.phi_m, phi_ms=phi_ms, phi_mx=phi_mx, phi_my=phi_my, phi_mz=phi_mz,f=self.opt.f, m=self.invProb.curModel,dpred=self.invProb.dpred) +class SaveOutputDictEveryIteration(_SaveEveryIteration): + """SaveOutputDictEveryIteration + A directive that saves some relevant information from the inversion run to a numpy .npz dictionary file (see numpy.savez function for further info). + """ + + def initialize(self): + print "SimPEG.SaveOutputDictEveryIteration will save your inversion progress as dictionary: '%s-###.npz'"%self.fileName + + def endIter(self): + # Save the data. + ms = self.reg.Ws * ( self.reg.mapping * (self.invProb.curModel - self.reg.mref) ) + phi_ms = 0.5*ms.dot(ms) + if self.reg.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: + my = self.reg.Wy * ( self.reg.mapping * (self.invProb.curModel - mref) ) + phi_my = 0.5 * my.dot(my) + else: + phi_my = 'NaN' + if self.prob.mesh.dim==3 and 'CYL' not in self.prob.mesh._meshType: + mz = self.reg.Wz * ( self.reg.mapping * (self.invProb.curModel - mref) ) + phi_mz = 0.5 * mz.dot(mz) + else: + phi_mz = 'NaN' + + + # Save the file as a npz + np.savez('{:s}-{:03d}'.format(self.fileName,self.opt.iter), iter=self.opt.iter, beta=self.invProb.beta, phi_d=self.invProb.phi_d, phi_m=self.invProb.phi_m, phi_ms=phi_ms, phi_mx=phi_mx, phi_my=phi_my, phi_mz=phi_mz,f=self.opt.f, m=self.invProb.curModel,dpred=self.invProb.dpred) + # class UpdateReferenceModel(Parameter): diff --git a/SimPEG/EM/FDEM/FDEM.py b/SimPEG/EM/FDEM/FDEM.py index 4b137b2c..cf3dee7f 100644 --- a/SimPEG/EM/FDEM/FDEM.py +++ b/SimPEG/EM/FDEM/FDEM.py @@ -54,8 +54,7 @@ class BaseFDEMProblem(BaseEMProblem): Ainv = self.Solver(A, **self.solverOpts) sol = Ainv * rhs Srcs = self.survey.getSrcByFreq(freq) - ftype = self._fieldType + 'Solution' - F[Srcs, ftype] = sol + F[Srcs, self._solutionType] = sol Ainv.clean() return F @@ -78,30 +77,19 @@ class BaseFDEMProblem(BaseEMProblem): Jv = self.dataPair(self.survey) for freq in self.survey.freqs: - A = self.getA(freq) # + A = self.getA(freq) Ainv = self.Solver(A, **self.solverOpts) for src in self.survey.getSrcByFreq(freq): - ftype = self._fieldType + 'Solution' - u_src = u[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 ) + u_src = u[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_duFun = getattr(u, '_%sDeriv_u'%rx.projField, None) - df_dudu_dm = df_duFun(src, du_dm, adjoint=False) - - df_dmFun = getattr(u, '_%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, u, v) # wrt u, also have wrt m - - Jv[src, rx] = P(Df_Dm) - + df_dmFun = getattr(u, '_%sDeriv'%rx.projField, None) + df_dm_v = df_dmFun(src, du_dm_v, v, adjoint=False) + Jv[src, rx] = rx.evalDeriv(src, self.mesh, u, df_dm_v) Ainv.clean() return Utils.mkvc(Jv) @@ -132,32 +120,28 @@ class BaseFDEMProblem(BaseEMProblem): ATinv = self.Solver(AT, **self.solverOpts) for src in self.survey.getSrcByFreq(freq): - ftype = self._fieldType + 'Solution' - u_src = u[src, ftype] + u_src = u[src, self._solutionType] 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'%rx.projField, None) + df_duT, df_dmT = df_duTFun(src, None, PTv, adjoint=True) - df_duTFun = getattr(u, '_%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) + 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_dmFun = getattr(u, '_%sDeriv_m'%rx.projField, None) - dfT_dm = df_dmFun(src, PTv, adjoint=True) + df_dmT = df_dmT + du_dmT - du_dmT += dfT_dm - - # TODO: this should be taken care of by the reciever + # TODO: this should be taken care of by the reciever? real_or_imag = rx.projComp if real_or_imag is 'real': - Jtv += np.array(du_dmT,dtype=complex).real + Jtv += np.array(df_dmT, dtype=complex).real elif real_or_imag is 'imag': - Jtv += - np.array(du_dmT,dtype=complex).real + Jtv += - np.array(df_dmT, dtype=complex).real else: raise Exception('Must be real or imag') @@ -174,10 +158,10 @@ class BaseFDEMProblem(BaseEMProblem): :return: S_m, S_e (nE or nF, nSrc) """ Srcs = self.survey.getSrcByFreq(freq) - if self._eqLocs is 'FE': + 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._eqLocs is 'EF': + 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) @@ -213,9 +197,9 @@ class Problem_e(BaseFDEMProblem): :param SimPEG.Mesh mesh: mesh """ - _fieldType = 'e' - _eqLocs = 'FE' - fieldsPair = Fields_e + _solutionType = 'eSolution' + _formulation = 'EB' + fieldsPair = Fields_e def __init__(self, mesh, **kwargs): BaseFDEMProblem.__init__(self, mesh, **kwargs) @@ -239,7 +223,7 @@ class Problem_e(BaseFDEMProblem): return C.T*MfMui*C + 1j*omega(freq)*MeSigma - def getADeriv_m(self, freq, u, v, adjoint=False): + def getADeriv(self, freq, u, v, adjoint=False): """ Product of the derivative of our system matrix with respect to the model and a vector @@ -280,7 +264,7 @@ class Problem_e(BaseFDEMProblem): return C.T * (MfMui * S_m) -1j * omega(freq) * S_e - def getRHSDeriv_m(self, freq, src, v, adjoint=False): + def getRHSDeriv(self, freq, src, v, adjoint=False): """ Derivative of the right hand side with respect to the model @@ -324,9 +308,9 @@ class Problem_b(BaseFDEMProblem): :param SimPEG.Mesh mesh: mesh """ - _fieldType = 'b' - _eqLocs = 'FE' - fieldsPair = Fields_b + _solutionType = 'bSolution' + _formulation = 'EB' + fieldsPair = Fields_b def __init__(self, mesh, **kwargs): BaseFDEMProblem.__init__(self, mesh, **kwargs) @@ -354,7 +338,7 @@ class Problem_b(BaseFDEMProblem): return MfMui.T*A return A - def getADeriv_m(self, freq, u, v, adjoint=False): + def getADeriv(self, freq, u, v, adjoint=False): """ Product of the derivative of our system matrix with respect to the model and a vector @@ -411,7 +395,7 @@ class Problem_b(BaseFDEMProblem): return RHS - def getRHSDeriv_m(self, freq, src, v, adjoint=False): + def getRHSDeriv(self, freq, src, v, adjoint=False): """ Derivative of the right hand side with respect to the model @@ -472,9 +456,9 @@ class Problem_j(BaseFDEMProblem): :param SimPEG.Mesh mesh: mesh """ - _fieldType = 'j' - _eqLocs = 'EF' - fieldsPair = Fields_j + _solutionType = 'jSolution' + _formulation = 'HJ' + fieldsPair = Fields_j def __init__(self, mesh, **kwargs): BaseFDEMProblem.__init__(self, mesh, **kwargs) @@ -503,7 +487,7 @@ class Problem_j(BaseFDEMProblem): return A - def getADeriv_m(self, freq, u, v, adjoint=False): + def getADeriv(self, freq, u, v, adjoint=False): """ Product of the derivative of our system matrix with respect to the model and a vector @@ -524,16 +508,16 @@ class Problem_j(BaseFDEMProblem): MeMuI = self.MeMuI MfRho = self.MfRho C = self.mesh.edgeCurl - MfRhoDeriv_m = self.MfRhoDeriv(u) + MfRhoDeriv = self.MfRhoDeriv(u) if adjoint: if self._makeASymmetric is True: v = MfRho * v - return MfRhoDeriv_m.T * (C * (MeMuI.T * (C.T * v))) + return MfRhoDeriv.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))) + return MfRho.T * (C * ( MeMuI * (C.T * (MfRhoDeriv * v) ))) + return C * (MeMuI * (C.T * (MfRhoDeriv * v))) def getRHS(self, freq): @@ -560,7 +544,7 @@ class Problem_j(BaseFDEMProblem): return RHS - def getRHSDeriv_m(self, freq, src, v, adjoint=False): + def getRHSDeriv(self, freq, src, v, adjoint=False): """ Derivative of the right hand side with respect to the model @@ -610,9 +594,9 @@ class Problem_h(BaseFDEMProblem): :param SimPEG.Mesh mesh: mesh """ - _fieldType = 'h' - _eqLocs = 'EF' - fieldsPair = Fields_h + _solutionType = 'hSolution' + _formulation = 'HJ' + fieldsPair = Fields_h def __init__(self, mesh, **kwargs): BaseFDEMProblem.__init__(self, mesh, **kwargs) @@ -635,7 +619,7 @@ class Problem_h(BaseFDEMProblem): return C.T * (MfRho * C) + 1j*omega(freq)*MeMu - def getADeriv_m(self, freq, u, v, adjoint=False): + def getADeriv(self, freq, u, v, adjoint=False): """ Product of the derivative of our system matrix with respect to the model and a vector @@ -652,11 +636,11 @@ class Problem_h(BaseFDEMProblem): MeMu = self.MeMu C = self.mesh.edgeCurl - MfRhoDeriv_m = self.MfRhoDeriv(C*u) + MfRhoDeriv = self.MfRhoDeriv(C*u) if adjoint: - return MfRhoDeriv_m.T * (C * v) - return C.T * (MfRhoDeriv_m * v) + return MfRhoDeriv.T * (C * v) + return C.T * (MfRhoDeriv * v) def getRHS(self, freq): """ @@ -677,7 +661,7 @@ class Problem_h(BaseFDEMProblem): return S_m + C.T * ( MfRho * S_e ) - def getRHSDeriv_m(self, freq, src, v, adjoint=False): + def getRHSDeriv(self, freq, src, v, adjoint=False): """ Derivative of the right hand side with respect to the model diff --git a/SimPEG/EM/FDEM/FieldsFDEM.py b/SimPEG/EM/FDEM/FieldsFDEM.py index e171a5c5..0f0a4963 100644 --- a/SimPEG/EM/FDEM/FieldsFDEM.py +++ b/SimPEG/EM/FDEM/FieldsFDEM.py @@ -3,7 +3,7 @@ import scipy.sparse as sp import SimPEG from SimPEG import Utils from SimPEG.EM.Utils import omega -from SimPEG.Utils import Zero, Identity +from SimPEG.Utils import Zero, Identity, sdiag class Fields(SimPEG.Problem.Fields): @@ -32,6 +32,134 @@ class Fields(SimPEG.Problem.Fields): knownFields = {} dtype = complex + def _e(self, solution, srcList): + """ + Total electric field is sum of primary and secondary + + :param numpy.ndarray solution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: total electric field + """ + if getattr(self, '_ePrimary', None) is None or getattr(self, '_eSecondary', None) is None: + raise NotImplementedError ('Getting e from %s is not implemented' %self.knownFields.keys()[0]) + + return self._ePrimary(solution,srcList) + self._eSecondary(solution,srcList) + + def _b(self, solution, srcList): + """ + Total magnetic flux density is sum of primary and secondary + + :param numpy.ndarray solution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: total magnetic flux density + """ + if getattr(self, '_bPrimary', None) is None or getattr(self, '_bSecondary', None) is None: + raise NotImplementedError ('Getting b from %s is not implemented' %self.knownFields.keys()[0]) + + return self._bPrimary(solution, srcList) + self._bSecondary(solution, srcList) + + def _h(self, solution, srcList): + """ + Total magnetic field is sum of primary and secondary + + :param numpy.ndarray solution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: total magnetic field + """ + if getattr(self, '_hPrimary', None) is None or getattr(self, '_hSecondary', None) is None: + raise NotImplementedError ('Getting h from %s is not implemented' %self.knownFields.keys()[0]) + + return self._hPrimary(solution, srcList) + self._hSecondary(solution, srcList) + + def _j(self, solution, srcList): + """ + Total current density is sum of primary and secondary + + :param numpy.ndarray solution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: total current density + """ + if getattr(self, '_jPrimary', None) is None or getattr(self, '_jSecondary', None) is None: + raise NotImplementedError ('Getting j from %s is not implemented' %self.knownFields.keys()[0]) + + return self._jPrimary(solution, srcList) + self._jSecondary(solution, srcList) + + def _eDeriv(self, src, du_dm_v, v, adjoint = False): + """ + Total derivative of e with respect to the inversion model. Returns :math:`d\mathbf{e}/d\mathbf{m}` for forward and (:math:`d\mathbf{e}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint + + :param Src src: sorce + :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint) + :param numpy.ndarray v: vector to take sensitivity product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: derivative times a vector (or tuple for adjoint) + """ + 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 = complex) + + def _bDeriv(self, src, du_dm_v, v, adjoint = False): + """ + Total derivative of b with respect to the inversion model. Returns :math:`d\mathbf{b}/d\mathbf{m}` for forward and (:math:`d\mathbf{b}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint + + :param Src src: sorce + :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint) + :param numpy.ndarray v: vector to take sensitivity product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: derivative times a vector (or tuple for adjoint) + """ + if getattr(self, '_bDeriv_u', None) is None or getattr(self, '_bDeriv_m', None) is None: + raise NotImplementedError ('Getting bDerivs from %s is not implemented' %self.knownFields.keys()[0]) + + if adjoint: + return self._bDeriv_u(src, v, adjoint), self._bDeriv_m(src, v, adjoint) + return np.array(self._bDeriv_u(src, du_dm_v, adjoint) + self._bDeriv_m(src, v, adjoint), dtype = complex) + + def _hDeriv(self, src, du_dm_v, v, adjoint = False): + """ + Total derivative of h with respect to the inversion model. Returns :math:`d\mathbf{h}/d\mathbf{m}` for forward and (:math:`d\mathbf{h}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint + + :param Src src: sorce + :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint) + :param numpy.ndarray v: vector to take sensitivity product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: derivative times a vector (or tuple for adjoint) + """ + if getattr(self, '_hDeriv_u', None) is None or getattr(self, '_hDeriv_m', None) is None: + raise NotImplementedError ('Getting hDerivs from %s is not implemented' %self.knownFields.keys()[0]) + + if adjoint: + return self._hDeriv_u(src, v, adjoint), self._hDeriv_m(src, v, adjoint) + return np.array(self._hDeriv_u(src, du_dm_v, adjoint) + self._hDeriv_m(src, v, adjoint), dtype = complex) + + def _jDeriv(self, src, du_dm_v, v, adjoint = False): + """ + Total derivative of j with respect to the inversion model. Returns :math:`d\mathbf{j}/d\mathbf{m}` for forward and (:math:`d\mathbf{j}/d\mathbf{u}`, :math:`d\mathb{u}/d\mathbf{m}`) for the adjoint + + :param Src src: sorce + :param numpy.ndarray du_dm_v: derivative of the solution vector with respect to the model times a vector (is None for adjoint) + :param numpy.ndarray v: vector to take sensitivity product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: derivative times a vector (or tuple for adjoint) + """ + 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 = complex) + class Fields_e(Fields): """ Fields object for Problem_e. @@ -47,15 +175,34 @@ class Fields_e(Fields): 'eSecondary' : ['eSolution','E','_eSecondary'], 'b' : ['eSolution','F','_b'], 'bPrimary' : ['eSolution','F','_bPrimary'], - 'bSecondary' : ['eSolution','F','_bSecondary'] + 'bSecondary' : ['eSolution','F','_bSecondary'], + 'j' : ['eSolution','CCV','_j'], + 'h' : ['eSolution','CCV','_h'], } - def __init__(self,mesh,survey,**kwargs): + def __init__(self, mesh, survey, **kwargs): Fields.__init__(self,mesh,survey,**kwargs) def startup(self): self.prob = self.survey.prob self._edgeCurl = self.survey.prob.mesh.edgeCurl + self._aveE2CCV = self.survey.prob.mesh.aveE2CCV + self._aveF2CCV = self.survey.prob.mesh.aveF2CCV + self._nC = self.survey.prob.mesh.nC + self._MeSigma = self.survey.prob.MeSigma + self._MeSigmaDeriv = self.survey.prob.MeSigmaDeriv + self._MfMui = self.survey.prob.MfMui + + def _GLoc(self, fieldType): + if fieldType == 'e': + return 'E' + elif fieldType == 'b': + return 'F' + elif (fieldType == 'h') or (fieldType == 'j'): + return 'CCV' + else: + raise Exception('Field type must be e, b, h, j') + def _ePrimary(self, eSolution, srcList): """ @@ -67,7 +214,7 @@ class Fields_e(Fields): :return: primary electric field as defined by the sources """ - ePrimary = np.zeros_like(eSolution) + ePrimary = np.zeros([self.prob.mesh.nE,len(srcList)], dtype = complex) for i, src in enumerate(srcList): ep = src.ePrimary(self.prob) ePrimary[:,i] = ePrimary[:,i] + ep @@ -82,25 +229,12 @@ class Fields_e(Fields): :rtype: numpy.ndarray :return: secondary electric field """ - return eSolution - def _e(self, eSolution, srcList): - """ - Total electric field is sum of primary and secondary - - :param numpy.ndarray eSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total electric field - """ - - return self._ePrimary(eSolution,srcList) + self._eSecondary(eSolution,srcList) - def _eDeriv_u(self, src, v, adjoint = False): """ - Derivative of the total electric field with respect to the thing we - solved for + Partial derivative of the total electric field with respect to the thing we + solved for. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -113,7 +247,7 @@ class Fields_e(Fields): def _eDeriv_m(self, src, v, adjoint = False): """ - Derivative of the total electric field with respect to the inversion model. Here, we assume that the primary does not depend on the model. + Partial derivative of the total electric field with respect to the inversion model. Here, we assume that the primary does not depend on the model. Note that this also includes derivative contributions from the sources. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -135,7 +269,7 @@ class Fields_e(Fields): :return: primary magnetic flux density as defined by the sources """ - bPrimary = np.zeros([self._edgeCurl.shape[0],eSolution.shape[1]],dtype = complex) + bPrimary = np.zeros([self._edgeCurl.shape[0],eSolution.shape[1]], dtype = complex) for i, src in enumerate(srcList): bp = src.bPrimary(self.prob) bPrimary[:,i] = bPrimary[:,i] + bp @@ -159,75 +293,137 @@ class Fields_e(Fields): b[:,i] = b[:,i]+ 1./(1j*omega(src.freq)) * S_m return b - def _bSecondaryDeriv_u(self, src, v, adjoint = False): + def _bDeriv_u(self, src, du_dm_v, adjoint = False): """ - Derivative of the secondary magnetic flux density with respect to the thing we solved for + Derivative of the magnetic flux density with respect to the thing we solved for :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the derivative of the secondary magnetic flux density with respect to the field we solved for with a vector - """ - - C = self._edgeCurl - 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): - """ - Derivative of the secondary magnetic flux density with respect to the inversion model. - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the secondary magnetic flux density derivative with respect to the inversion model with a vector - """ - - S_mDeriv, _ = src.evalDeriv(self.prob, v, adjoint) - return 1./(1j * omega(src.freq)) * S_mDeriv - - def _b(self, eSolution, srcList): - """ - Total magnetic flux density is sum of primary and secondary - - :param numpy.ndarray eSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total magnetic flux density - """ - - return self._bPrimary(eSolution, srcList) + self._bSecondary(eSolution, srcList) - - def _bDeriv_u(self, src, v, adjoint=False): - """ - Derivative of the total magnetic flux density with respect to the thing we solved for - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with + :param numpy.ndarray du_dm_v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray :return: product of the derivative of the magnetic flux density with respect to the field we solved for with a vector """ - # Primary does not depend on u - return self._bSecondaryDeriv_u(src, v, adjoint) + C = self._edgeCurl + if adjoint: + return - 1./(1j*omega(src.freq)) * (C.T * du_dm_v) + return - 1./(1j*omega(src.freq)) * (C * du_dm_v) - def _bDeriv_m(self, src, v, adjoint=False): + + def _bDeriv_m(self, src, v, adjoint = False): """ - Derivative of the total magnetic flux density with respect to the inversion model. + Derivative of the magnetic flux density with respect to the inversion model. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with :param bool adjoint: adjoint? - :rtype: SimPEG.Utils.Zero + :rtype: numpy.ndarray :return: product of the magnetic flux density derivative with respect to the inversion model with a vector """ - # Assuming the primary does not depend on the model - return self._bSecondaryDeriv_m(src, v, adjoint) + S_mDeriv, _ = src.evalDeriv(self.prob, v, adjoint) + return 1./(1j * omega(src.freq)) * S_mDeriv + + def _j(self, eSolution, srcList): + """ + Current density from eSolution + + :param numpy.ndarray eSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: current density + """ + aveE2CCV = self._aveE2CCV + n = int(aveE2CCV.shape[0] / self._nC) # number of components (instead of checking if cyl or not) + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + return VI * (aveE2CCV * (self._MeSigma * self._e(eSolution,srcList) ) ) + + def _jDeriv_u(self, src, du_dm_v, adjoint = False): + """ + Derivative of the current density with respect to the thing we solved for + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the current density with respect to the field we solved for with a vector + """ + n = int(self._aveE2CCV.shape[0] / self._nC) # number of components (instead of checking if cyl or not) + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + if adjoint: + return self._eDeriv_u(src, self._MeSigma.T * (self._aveE2CCV.T * (VI.T * du_dm_v) ), adjoint = adjoint) + return VI * (self._aveE2CCV * (self._MeSigma * (self._eDeriv_u(src, du_dm_v, adjoint=adjoint) ) ) ) + + + def _jDeriv_m(self, src, v, adjoint = False): + """ + Derivative of the current density with respect to the inversion model. + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the current density derivative with respect to the inversion model with a vector + """ + e = self[src, 'e'] + n = int(self._aveE2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + if adjoint: + return self._MeSigmaDeriv(e).T * (self._aveE2CCV.T * (VI.T * v)) + self._eDeriv_m(src, self._aveE2CCV.T * (VI.T * v), adjoint=adjoint) + return VI * (self._aveE2CCV * ( self._eDeriv_m(src, v, adjoint=adjoint) + self._MeSigmaDeriv(e) * v)) + + + + def _h(self, eSolution, srcList): + """ + Magnetic field from eSolution + + :param numpy.ndarray eSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: magnetic field + """ + n = int(self._aveF2CCV.shape[0] / self._nC) # Number of Components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + return VI * (self._aveF2CCV * (self._MfMui * self._b(eSolution, srcList))) + + def _hDeriv_u(self, src, du_dm_v, adjoint = False): + """ + Derivative of the magnetic field with respect to the thing we solved for + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the magnetic field with respect to the field we solved for with a vector + """ + n = int(self._aveF2CCV.shape[0] / self._nC) # Number of Components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + v = self._MfMui.T * (self._aveF2CCV.T * (VI.T * du_dm_v)) + return self._bDeriv_u(src, v, adjoint=adjoint) + return VI * (self._aveF2CCV * (self._MfMui * self._bDeriv_u(src, du_dm_v, adjoint = adjoint))) + + def _hDeriv_m(self, src, v, adjoint = False): + """ + Derivative of the magnetic field with respect to the inversion model. + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the magnetic field derivative with respect to the inversion model with a vector + """ + n = int(self._aveF2CCV.shape[0] / self._nC) # Number of Components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + v = self._MfMui.T * (self._aveF2CCV.T * (VI.T * v)) + return self._bDeriv_m(src, v, adjoint=adjoint) + return VI * (self._aveF2CCV * (self._MfMui * self._bDeriv_m(src, v, adjoint = adjoint))) + class Fields_b(Fields): @@ -246,6 +442,8 @@ class Fields_b(Fields): 'e' : ['bSolution','E','_e'], 'ePrimary' : ['bSolution','E','_ePrimary'], 'eSecondary' : ['bSolution','E','_eSecondary'], + 'j' : ['bSolution','CCV','_j'], + 'h' : ['bSolution','CCV','_h'], } def __init__(self,mesh,survey,**kwargs): @@ -254,10 +452,29 @@ class Fields_b(Fields): def startup(self): self.prob = self.survey.prob self._edgeCurl = self.survey.prob.mesh.edgeCurl + self._MeSigma = self.survey.prob.MeSigma self._MeSigmaI = self.survey.prob.MeSigmaI self._MfMui = self.survey.prob.MfMui + self._MeSigmaDeriv = self.survey.prob.MeSigmaDeriv self._MeSigmaIDeriv = self.survey.prob.MeSigmaIDeriv self._Me = self.survey.prob.Me + self._aveF2CCV = self.survey.prob.mesh.aveF2CCV + self._aveE2CCV = self.survey.prob.mesh.aveE2CCV + self._sigma = self.survey.prob.curModel.sigma + self._mui = self.survey.prob.curModel.mui + self._nC = self.survey.prob.mesh.nC + + + + def _GLoc(self,fieldType): + if fieldType == 'e': + return 'E' + elif fieldType == 'b': + return 'F' + elif (fieldType == 'h') or (fieldType == 'j'): + return'CCV' + else: + raise Exception('Field type must be e, b, h, j') def _bPrimary(self, bSolution, srcList): """ @@ -269,7 +486,7 @@ class Fields_b(Fields): :return: primary electric field as defined by the sources """ - bPrimary = np.zeros_like(bSolution) + bPrimary = np.zeros([self.prob.mesh.nF,len(srcList)], dtype = complex) for i, src in enumerate(srcList): bp = src.bPrimary(self.prob) bPrimary[:,i] = bPrimary[:,i] + bp @@ -287,34 +504,23 @@ class Fields_b(Fields): return bSolution - def _b(self, bSolution, srcList): + def _bDeriv_u(self, src, du_dm_v, adjoint=False): """ - Total magnetic flux density is sum of primary and secondary - - :param numpy.ndarray bSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total magnetic flux density - """ - - return self._bPrimary(bSolution, srcList) + self._bSecondary(bSolution, srcList) - - def _bDeriv_u(self, src, v, adjoint=False): - """ - Derivative of the total magnetic flux density with respect to the thing we - solved for + Partial derivative of the total magnetic flux density with respect to the thing we + solved for. :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with + :param numpy.ndarray du_dm_v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray :return: product of the derivative of the magnetic flux density with respect to the field we solved for with a vector """ - return Identity()*v + + return Identity()*du_dm_v def _bDeriv_m(self, src, v, adjoint=False): """ - Derivative of the total magnetic flux density with respect to the inversion model. Here, we assume that the primary does not depend on the model. + Partial derivative of the total magnetic flux density with respect to the inversion model. Here, we assume that the primary does not depend on the model. Note that this also includes derivative contributions from the sources. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -336,7 +542,7 @@ class Fields_b(Fields): :return: primary electric field as defined by the sources """ - ePrimary = np.zeros([self._edgeCurl.shape[1],bSolution.shape[1]],dtype = complex) + ePrimary = np.zeros([self._edgeCurl.shape[1],bSolution.shape[1]], dtype = complex) for i,src in enumerate(srcList): ep = src.ePrimary(self.prob) ePrimary[:,i] = ePrimary[:,i] + ep @@ -352,75 +558,16 @@ class Fields_b(Fields): :return: secondary electric field """ - e = self._MeSigmaI * ( self._edgeCurl.T * ( self._MfMui * bSolution)) + e = ( self._edgeCurl.T * ( self._MfMui * bSolution)) for i,src in enumerate(srcList): _,S_e = src.eval(self.prob) - e[:,i] = e[:,i]+ -self._MeSigmaI * S_e - return e + e[:,i] = e[:,i] + - S_e - def _eSecondaryDeriv_u(self, src, v, adjoint=False): + return self._MeSigmaI * e + + def _eDeriv_u(self, src, du_dm_v, adjoint=False): """ - Derivative of the secondary electric field with respect to the thing we solved for - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the derivative of the secondary electric field with respect to the field we solved for with a vector - """ - - if not adjoint: - return self._MeSigmaI * ( self._edgeCurl.T * ( self._MfMui * v) ) - else: - return self._MfMui.T * (self._edgeCurl * (self._MeSigmaI.T * v)) - - def _eSecondaryDeriv_m(self, src, v, adjoint=False): - """ - Derivative of the secondary electric field with respect to the inversion model - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the derivative of the secondary electric field with respect to the model with a vector - """ - - bSolution = self[[src],'bSolution'] - _,S_e = src.eval(self.prob) - Me = self._Me - - if adjoint: - Me = Me.T - - w = self._edgeCurl.T * (self._MfMui * bSolution) - w = w - Utils.mkvc(Me * S_e,2) - - if not adjoint: - de_dm = self._MeSigmaIDeriv(w) * v - elif adjoint: - de_dm = self._MeSigmaIDeriv(w).T * v - - _, S_eDeriv = src.evalDeriv(self.prob, v, adjoint) - - de_dm = de_dm - self._MeSigmaI * S_eDeriv - - return de_dm - - def _e(self, bSolution, srcList): - """ - Total electric field is sum of primary and secondary - - :param numpy.ndarray eSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total electric field - """ - - return self._ePrimary(bSolution, srcList) + self._eSecondary(bSolution, srcList) - - def _eDeriv_u(self, src, v, adjoint=False): - """ - Derivative of the total electric field with respect to the thing we solved for + Derivative of the electric field with respect to the thing we solved for :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -429,21 +576,121 @@ class Fields_b(Fields): :return: product of the derivative of the electric field with respect to the field we solved for with a vector """ - return self._eSecondaryDeriv_u(src, v, adjoint) + if not adjoint: + return self._MeSigmaI * ( self._edgeCurl.T * ( self._MfMui * du_dm_v) ) + return self._MfMui.T * (self._edgeCurl * (self._MeSigmaI.T * du_dm_v)) + def _eDeriv_m(self, src, v, adjoint=False): """ - Derivative of the total electric field density with respect to the inversion model. + Derivative of the electric field with respect to the inversion model :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray - :return: product of the electric field derivative with respect to the inversion model with a vector + :return: product of the derivative of the electric field with respect to the model with a vector """ - # assuming primary doesn't depend on model - return self._eSecondaryDeriv_m(src, v, adjoint) + bSolution = Utils.mkvc(self[src, 'bSolution']) + _,S_e = src.eval(self.prob) + + w = -S_e + self._edgeCurl.T * (self._MfMui * bSolution) + _, S_eDeriv = src.evalDeriv(self.prob, v, adjoint) + + + if adjoint: + return self._MeSigmaIDeriv(w).T * v - self._MeSigmaI.T * S_eDeriv + return self._MeSigmaIDeriv(w) * v - self._MeSigmaI * S_eDeriv + + def _j(self, bSolution, srcList): + """ + Secondary current density from bSolution + + :param numpy.ndarray bSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: primary current density + """ + + n = int(self._aveE2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + return VI * (self._aveE2CCV * ( self._MeSigma * self._e(bSolution,srcList ) ) ) + + + def _jDeriv_u(self, src, du_dm_v, adjoint=False): + """ + Partial derivative of the current density with respect to the thing we + solved for. + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the current density with respect to the field we solved for with a vector + """ + n = int(self._aveE2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + return self._MfMui.T * ( self._edgeCurl * ( self._aveE2CCV.T * (VI.T * du_dm_v) ) ) + return VI * (self._aveE2CCV * (self._edgeCurl.T * ( self._MfMui * du_dm_v ) ) ) + + + def _jDeriv_m(self, src, v, adjoint=False): + """ + Derivative of the current density with respect to the inversion model + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the current density with respect to the model with a vector + """ + return Zero() + + def _h(self, bSolution, srcList): + """ + Magnetic field from bSolution + + :param numpy.ndarray bSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: magnetic field + """ + n = int(self._aveF2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + return VI * (self._aveF2CCV * (self._MfMui * self._b(bSolution, srcList))) + + def _hDeriv_u(self, src, du_dm_v, adjoint=False): + """ + Partial derivative of the magnetic field with respect to the thing we + solved for. + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the magnetic field with respect to the field we solved for with a vector + """ + n = int(self._aveF2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + if adjoint: + return self._MfMui.T * ( self._aveF2CCV.T * ( VI.T * du_dm_v) ) + return VI * (self._aveF2CCV * (self._MfMui * du_dm_v)) + + def _hDeriv_m(self, src, v, adjoint=False): + """ + Derivative of the magnetic field with respect to the inversion model + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the magnetic field with respect to the model with a vector + """ + return Zero() class Fields_j(Fields): @@ -462,6 +709,8 @@ class Fields_j(Fields): 'h' : ['jSolution','E','_h'], 'hPrimary' : ['jSolution','E','_hPrimary'], 'hSecondary' : ['jSolution','E','_hSecondary'], + 'e' : ['jSolution','CCV','_e'], + 'b' : ['jSolution','CCV','_b'], } def __init__(self,mesh,survey,**kwargs): @@ -470,10 +719,25 @@ class Fields_j(Fields): def startup(self): self.prob = self.survey.prob self._edgeCurl = self.survey.prob.mesh.edgeCurl + self._MeMu = self.survey.prob.MeMu self._MeMuI = self.survey.prob.MeMuI self._MfRho = self.survey.prob.MfRho self._MfRhoDeriv = self.survey.prob.MfRhoDeriv - self._Me = self.survey.prob.Me + self._rho = self.survey.prob.curModel.rho + self._mu = self.survey.prob.curModel.mui + self._aveF2CCV = self.survey.prob.mesh.aveF2CCV + self._aveE2CCV = self.survey.prob.mesh.aveE2CCV + self._nC = self.survey.prob.mesh.nC + + def _GLoc(self,fieldType): + if fieldType == 'h': + return 'E' + elif fieldType == 'j': + return 'F' + elif (fieldType == 'e') or (fieldType == 'b'): + return 'CCV' + else: + raise Exception('Field type must be e, b, h, j') def _jPrimary(self, jSolution, srcList): """ @@ -485,7 +749,7 @@ class Fields_j(Fields): :return: primary current density as defined by the sources """ - jPrimary = np.zeros_like(jSolution,dtype = complex) + jPrimary = np.zeros_like(jSolution, dtype = complex) for i, src in enumerate(srcList): jp = src.jPrimary(self.prob) jPrimary[:,i] = jPrimary[:,i] + jp @@ -515,10 +779,11 @@ class Fields_j(Fields): return self._jPrimary(jSolution, srcList) + self._jSecondary(jSolution, srcList) - def _jDeriv_u(self, src, v, adjoint=False): + + def _jDeriv_u(self, src, du_dm_v, adjoint=False): """ - Derivative of the total current density with respect to the thing we - solved for + Partial derivative of the total current density with respect to the thing we + solved for. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -527,11 +792,12 @@ class Fields_j(Fields): :return: product of the derivative of the current density with respect to the field we solved for with a vector """ - return Identity()*v + return Identity()*du_dm_v + def _jDeriv_m(self, src, v, adjoint=False): """ - Derivative of the total current density with respect to the inversion model. Here, we assume that the primary does not depend on the model. + Partial derivative of the total current density with respect to the inversion model. Here, we assume that the primary does not depend on the model. Note that this also includes derivative contributions from the sources. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -568,101 +834,158 @@ class Fields_j(Fields): :return: secondary magnetic field """ - h = self._MeMuI * (self._edgeCurl.T * (self._MfRho * jSolution) ) + h = (self._edgeCurl.T * (self._MfRho * jSolution) ) for i, src in enumerate(srcList): h[:,i] *= -1./(1j*omega(src.freq)) S_m,_ = src.eval(self.prob) - h[:,i] = h[:,i]+ 1./(1j*omega(src.freq)) * self._MeMuI * (S_m) - return h + h[:,i] = h[:,i] + 1./(1j*omega(src.freq)) * (S_m) + return self._MeMuI * h - def _hSecondaryDeriv_u(self, src, v, adjoint=False): + + def _hDeriv_u(self, src, du_dm_v, adjoint=False): """ - Derivative of the secondary magnetic field with respect to the thing we solved for + Derivative of the magnetic field with respect to the thing we solved for :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the derivative of the secondary magnetic field with respect to the field we solved for with a vector - """ - - if not adjoint: - return -1./(1j*omega(src.freq)) * self._MeMuI * (self._edgeCurl.T * (self._MfRho * v) ) - elif adjoint: - return -1./(1j*omega(src.freq)) * self._MfRho.T * (self._edgeCurl * ( self._MeMuI.T * v)) - - def _hSecondaryDeriv_m(self, src, v, adjoint=False): - """ - Derivative of the secondary magnetic field with respect to the inversion model - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the derivative of the secondary magnetic field with respect to the model with a vector - """ - - jSolution = self[[src],'jSolution'] - MeMuI = self._MeMuI - C = self._edgeCurl - MfRho = self._MfRho - MfRhoDeriv = self._MfRhoDeriv - Me = self._Me - - if not adjoint: - hDeriv_m = -1./(1j*omega(src.freq)) * MeMuI * (C.T * (MfRhoDeriv(jSolution)*v ) ) - elif adjoint: - hDeriv_m = -1./(1j*omega(src.freq)) * MfRhoDeriv(jSolution).T * ( C * (MeMuI.T * v ) ) - - S_mDeriv,_ = src.evalDeriv(self.prob, adjoint = adjoint) - - if not adjoint: - S_mDeriv = S_mDeriv(v) - hDeriv_m = hDeriv_m + 1./(1j*omega(src.freq)) * MeMuI * (Me * S_mDeriv) - elif adjoint: - S_mDeriv = S_mDeriv(Me.T * (MeMuI.T * v)) - hDeriv_m = hDeriv_m + 1./(1j*omega(src.freq)) * S_mDeriv - return hDeriv_m - - - def _h(self, jSolution, srcList): - """ - Total magnetic field is sum of primary and secondary - - :param numpy.ndarray eSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total magnetic field - """ - - return self._hPrimary(jSolution, srcList) + self._hSecondary(jSolution, srcList) - - def _hDeriv_u(self, src, v, adjoint=False): - """ - Derivative of the total magnetic field with respect to the thing we solved for - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with + :param numpy.ndarray du_dm_v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray :return: product of the derivative of the magnetic field with respect to the field we solved for with a vector """ - return self._hSecondaryDeriv_u(src, v, adjoint) + if adjoint: + return -1./(1j*omega(src.freq)) * self._MfRho.T * (self._edgeCurl * ( self._MeMuI.T * du_dm_v)) + return -1./(1j*omega(src.freq)) * self._MeMuI * (self._edgeCurl.T * (self._MfRho * du_dm_v) ) + + def _hDeriv_m(self, src, v, adjoint=False): """ - Derivative of the total magnetic field density with respect to the inversion model. + Derivative of the magnetic field with respect to the inversion model :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray - :return: product of the magnetic field derivative with respect to the inversion model with a vector + :return: product of the derivative of the magnetic field with respect to the model with a vector """ - # assuming the primary doesn't depend on the model - return self._hSecondaryDeriv_m(src, v, adjoint) + jSolution = Utils.mkvc(self[[src],'jSolution']) + MeMuI = self._MeMuI + C = self._edgeCurl + MfRho = self._MfRho + MfRhoDeriv = self._MfRhoDeriv + S_mDeriv,_ = src.evalDeriv(self.prob, adjoint = adjoint) + + if not adjoint: + hDeriv_m = -1./(1j*omega(src.freq)) * MeMuI * (C.T * (MfRhoDeriv(jSolution)*v ) ) + S_mDeriv = S_mDeriv(v) + hDeriv_m = hDeriv_m + 1./(1j*omega(src.freq)) * MeMuI * ( S_mDeriv) + + elif adjoint: + hDeriv_m = -1./(1j*omega(src.freq)) * MfRhoDeriv(jSolution).T * ( C * (MeMuI.T * v ) ) + + S_mDeriv = S_mDeriv(MeMuI.T * v) + hDeriv_m = hDeriv_m + 1./(1j*omega(src.freq)) * S_mDeriv + + return hDeriv_m + + def _e(self, jSolution, srcList): + """ + Electric field from jSolution + + :param numpy.ndarray hSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: electric field + """ + n = int(self._aveF2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + return VI * (self._aveF2CCV * (self._MfRho * self._j(jSolution, srcList))) + + def _eDeriv_u(self, src, du_dm_v, adjoint=False): + """ + Derivative of the electric field with respect to the thing we solved for + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the electric field with respect to the field we solved for with a vector + """ + n = int(self._aveF2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + return self._MfRho.T * ( self._aveF2CCV.T * ( VI.T * du_dm_v ) ) + return VI * (self._aveF2CCV * (self._MfRho * du_dm_v)) + + def _eDeriv_m(self, src, v, adjoint=False): + """ + Derivative of the electric field with respect to the inversion model + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the electric field with respect to the model with a vector + """ + jSolution = Utils.mkvc(self[src,'jSolution']) + n = int(self._aveF2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + return self._MfRhoDeriv(jSolution).T * ( self._aveF2CCV.T * ( VI.T * v ) ) + return VI * (self._aveF2CCV * (self._MfRhoDeriv(jSolution) * v)) + + def _b(self, jSolution, srcList): + """ + Secondary magnetic flux density from jSolution + + :param numpy.ndarray hSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: secondary magnetic flux density + """ + n = int(self._aveE2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + return VI * (self._aveE2CCV * ( self._MeMu * self._h(jSolution,srcList)) ) + + def _bDeriv_u(self, src, du_dm_v, adjoint=False): + """ + Derivative of the magnetic flux density with respect to the thing we solved for + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the magnetic flux density with respect to the field we solved for with a vector + """ + n = int(self._aveF2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + if adjoint: + return -1./(1j*omega(src.freq)) * self._MfRho.T * ( self._edgeCurl * ( self._aveE2CCV.T * (VI.T * du_dm_v) ) ) + return -1./(1j*omega(src.freq)) * VI * (self._aveE2CCV * (self._edgeCurl.T * (self._MfRho * du_dm_v))) + + def _bDeriv_m(self, src, v, adjoint=False): + """ + Derivative of the magnetic flux density with respect to the inversion model + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the magnetic flux density with respect to the model with a vector + """ + jSolution = self[src,'jSolution'] + n = int(self._aveE2CCV.shape[0] / self._nC) # number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + S_mDeriv,_ = src.evalDeriv(self.prob, adjoint = adjoint) + + if adjoint: + v = self._aveE2CCV.T * ( VI.T * v) + return 1./(1j * omega(src.freq)) * ( S_mDeriv(v) - self._MfRhoDeriv(jSolution).T * (self._edgeCurl * v )) + return 1./(1j * omega(src.freq)) * VI * (self._aveE2CCV * ( S_mDeriv(v) - self._edgeCurl.T * ( self._MfRhoDeriv(jSolution) * v ) ) ) class Fields_h(Fields): @@ -680,7 +1003,9 @@ class Fields_h(Fields): 'hSecondary' : ['hSolution','E','_hSecondary'], 'j' : ['hSolution','F','_j'], 'jPrimary' : ['hSolution','F','_jPrimary'], - 'jSecondary' : ['hSolution','F','_jSecondary'] + 'jSecondary' : ['hSolution','F','_jSecondary'], + 'e' : ['hSolution','CCV','_e'], + 'b' : ['hSolution','CCV','_b'], } def __init__(self,mesh,survey,**kwargs): @@ -689,8 +1014,25 @@ class Fields_h(Fields): def startup(self): self.prob = self.survey.prob self._edgeCurl = self.survey.prob.mesh.edgeCurl + self._MeMu = self.survey.prob.MeMu self._MeMuI = self.survey.prob.MeMuI self._MfRho = self.survey.prob.MfRho + self._MfRhoDeriv = self.survey.prob.MfRhoDeriv + self._rho = self.survey.prob.curModel.rho + self._mu = self.survey.prob.curModel.mui + self._aveF2CCV = self.survey.prob.mesh.aveF2CCV + self._aveE2CCV = self.survey.prob.mesh.aveE2CCV + self._nC = self.survey.prob.mesh.nC + + def _GLoc(self,fieldType): + if fieldType == 'h': + return 'E' + elif fieldType == 'j': + return 'F' + elif (fieldType == 'e') or (fieldType == 'b'): + return 'CCV' + else: + raise Exception('Field type must be e, b, h, j') def _hPrimary(self, hSolution, srcList): """ @@ -720,35 +1062,24 @@ class Fields_h(Fields): return hSolution - def _h(self, hSolution, srcList): - """ - Total magnetic field is sum of primary and secondary - - :param numpy.ndarray hSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total magnetic field - """ - return self._hPrimary(hSolution, srcList) + self._hSecondary(hSolution, srcList) - - def _hDeriv_u(self, src, v, adjoint=False): + def _hDeriv_u(self, src, du_dm_v, adjoint=False): """ - Derivative of the total magnetic field with respect to the thing we - solved for + Partial derivative of the total magnetic field with respect to the thing we + solved for. :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with + :param numpy.ndarray du_dm_v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray :return: product of the derivative of the magnetic field with respect to the field we solved for with a vector """ - return Identity()*v + return Identity()*du_dm_v def _hDeriv_m(self, src, v, adjoint=False): """ - Derivative of the total magnetic field with respect to the inversion model. Here, we assume that the primary does not depend on the model. + Partial derivative of the total magnetic field with respect to the inversion model. Here, we assume that the primary does not depend on the model. Note that this also includes derivative contributions from the sources. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with @@ -778,7 +1109,7 @@ class Fields_h(Fields): def _jSecondary(self, hSolution, srcList): """ - Secondary current density from eSolution + Secondary current density from hSolution :param numpy.ndarray hSolution: field we solved for :param list srcList: list of sources @@ -792,70 +1123,124 @@ class Fields_h(Fields): j[:,i] = j[:,i]+ -S_e return j - def _jSecondaryDeriv_u(self, src, v, adjoint=False): + def _jDeriv_u(self, src, du_dm_v, adjoint=False): """ - Derivative of the secondary current density with respect to the thing we solved for + Derivative of the current density with respect to the thing we solved for :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the derivative of the secondary current density with respect to the field we solved for with a vector - """ - - if not adjoint: - return self._edgeCurl*v - elif adjoint: - return self._edgeCurl.T*v - - def _jSecondaryDeriv_m(self, src, v, adjoint=False): - """ - Derivative of the secondary current density with respect to the inversion model. - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with - :param bool adjoint: adjoint? - :rtype: numpy.ndarray - :return: product of the secondary current density derivative with respect to the inversion model with a vector - """ - - _,S_eDeriv = src.evalDeriv(self.prob, v, adjoint) - return -S_eDeriv - - def _j(self, hSolution, srcList): - """ - Total current density is sum of primary and secondary - - :param numpy.ndarray eSolution: field we solved for - :param list srcList: list of sources - :rtype: numpy.ndarray - :return: total current density - """ - - return self._jPrimary(hSolution, srcList) + self._jSecondary(hSolution, srcList) - - def _jDeriv_u(self, src, v, adjoint=False): - """ - Derivative of the total current density with respect to the thing we solved for - - :param SimPEG.EM.FDEM.Src src: source - :param numpy.ndarray v: vector to take product with + :param numpy.ndarray du_dm_v: vector to take product with :param bool adjoint: adjoint? :rtype: numpy.ndarray :return: product of the derivative of the current density with respect to the field we solved for with a vector """ - return self._jSecondaryDeriv_u(src,v,adjoint) + + if not adjoint: + return self._edgeCurl*du_dm_v + elif adjoint: + return self._edgeCurl.T*du_dm_v + def _jDeriv_m(self, src, v, adjoint=False): """ - Derivative of the total current density with respect to the inversion model. + Derivative of the current density with respect to the inversion model. :param SimPEG.EM.FDEM.Src src: source :param numpy.ndarray v: vector to take product with :param bool adjoint: adjoint? - :rtype: SimPEG.Utils.Zero - :return: product of the current density with respect to the inversion model with a vector + :rtype: numpy.ndarray + :return: product of the current density derivative with respect to the inversion model with a vector """ - # assuming the primary does not depend on the model - return self._jSecondaryDeriv_m(src,v,adjoint) + _,S_eDeriv = src.evalDeriv(self.prob, v, adjoint) + return -S_eDeriv + + def _e(self, hSolution, srcList): + """ + Electric field from hSolution + + :param numpy.ndarray hSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: electric field + """ + n = int(self._aveF2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + return VI * (self._aveF2CCV * (self._MfRho * self._j(hSolution, srcList))) + + def _eDeriv_u(self, src, du_dm_v, adjoint=False): + """ + Derivative of the electric field with respect to the thing we solved for + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the electric field with respect to the field we solved for with a vector + """ + n = int(self._aveF2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + return self._edgeCurl.T * ( self._MfRho.T * ( self._aveF2CCV.T * ( VI.T * du_dm_v ) ) ) + return VI * (self._aveF2CCV * (self._MfRho * self._edgeCurl * du_dm_v )) + + def _eDeriv_m(self, src, v, adjoint=False): + """ + Derivative of the electric field with respect to the inversion model. + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the electric field derivative with respect to the inversion model with a vector + """ + hSolution = Utils.mkvc(self[src,'hSolution']) + n = int(self._aveF2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + return ( self._MfRhoDeriv(self._edgeCurl * hSolution).T * ( self._aveF2CCV.T * (VI.T * v) ) ) + return VI * (self._aveF2CCV * (self._MfRhoDeriv(self._edgeCurl * hSolution) * v )) + + def _b(self, hSolution, srcList): + """ + Magnetic flux density from hSolution + + :param numpy.ndarray hSolution: field we solved for + :param list srcList: list of sources + :rtype: numpy.ndarray + :return: magnetic flux density + """ + h = self._h(hSolution, srcList) + n = int(self._aveE2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + + return VI * (self._aveE2CCV * (self._MeMu * h)) + + def _bDeriv_u(self, src, du_dm_v, adjoint=False): + """ + Derivative of the magnetic flux density with respect to the thing we solved for + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray du_dm_v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the derivative of the magnetic flux density with respect to the field we solved for with a vector + """ + n = int(self._aveE2CCV.shape[0] / self._nC) #number of components + VI = sdiag(np.kron(np.ones(n), 1./self.prob.mesh.vol)) + if adjoint: + return self._MeMu.T * (self._aveE2CCV.T * ( VI.T * du_dm_v )) + return VI * (self._aveE2CCV * (self._MeMu * du_dm_v)) + + def _bDeriv_m(self, src, v, adjoint=False): + """ + Derivative of the magnetic flux density with respect to the inversion model. + + :param SimPEG.EM.FDEM.Src src: source + :param numpy.ndarray v: vector to take product with + :param bool adjoint: adjoint? + :rtype: numpy.ndarray + :return: product of the magnetic flux density derivative with respect to the inversion model with a vector + """ + return Zero() + + diff --git a/SimPEG/EM/FDEM/SrcFDEM.py b/SimPEG/EM/FDEM/SrcFDEM.py index 1213cef3..31e4224f 100644 --- a/SimPEG/EM/FDEM/SrcFDEM.py +++ b/SimPEG/EM/FDEM/SrcFDEM.py @@ -1,7 +1,7 @@ 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 SimPEG.Utils import Zero class BaseSrc(Survey.BaseSrc): """ @@ -14,7 +14,7 @@ class BaseSrc(Survey.BaseSrc): def eval(self, prob): """ - Evaluate the source terms. + Evaluate the source terms. - :math:`S_m` : magnetic source term - :math:`S_e` : electric source term @@ -36,12 +36,12 @@ class BaseSrc(Survey.BaseSrc): :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 + :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) + 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) + return lambda v: self.S_mDeriv(prob, v, adjoint), lambda v: self.S_eDeriv(prob, v, adjoint) def bPrimary(self, prob): """ @@ -49,7 +49,7 @@ class BaseSrc(Survey.BaseSrc): :param Problem prob: FDEM Problem :rtype: numpy.ndarray - :return: primary magnetic flux density + :return: primary magnetic flux density """ return Zero() @@ -59,7 +59,7 @@ class BaseSrc(Survey.BaseSrc): :param Problem prob: FDEM Problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ return Zero() @@ -69,7 +69,7 @@ class BaseSrc(Survey.BaseSrc): :param Problem prob: FDEM Problem :rtype: numpy.ndarray - :return: primary electric field + :return: primary electric field """ return Zero() @@ -79,13 +79,13 @@ class BaseSrc(Survey.BaseSrc): :param Problem prob: FDEM Problem :rtype: numpy.ndarray - :return: primary current density + :return: primary current density """ return Zero() def S_m(self, prob): """ - Magnetic source term + Magnetic source term :param Problem prob: FDEM Problem :rtype: numpy.ndarray @@ -95,7 +95,7 @@ class BaseSrc(Survey.BaseSrc): def S_e(self, prob): """ - Electric source term + Electric source term :param Problem prob: FDEM Problem :rtype: numpy.ndarray @@ -136,15 +136,26 @@ class RawVec_e(BaseSrc): :param list rxList: receiver list :param float freq: frequency :param numpy.array S_e: electric source term + :param bool integrate: Integrate the source term (multiply by Me) [True] """ - def __init__(self, rxList, freq, S_e): #, ePrimary=None, bPrimary=None, hPrimary=None, jPrimary=None): - self._S_e = np.array(S_e,dtype=complex) + def __init__(self, rxList, freq, S_e, integrate=True): #, ePrimary=None, bPrimary=None, hPrimary=None, jPrimary=None): + self._S_e = np.array(S_e, dtype=complex) self.freq = float(freq) + self.integrate = integrate + BaseSrc.__init__(self, rxList) 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 @@ -155,10 +166,11 @@ class RawVec_m(BaseSrc): :param float freq: frequency :param rxList: receiver list :param numpy.array S_m: magnetic source term + :param bool integrate: Integrate the source term (multiply by Me) [True] """ - 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) + 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 @@ -166,12 +178,14 @@ class RawVec_m(BaseSrc): def S_m(self, prob): """ - Magnetic source term + 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 @@ -183,36 +197,51 @@ class RawVec(BaseSrc): :param float freq: frequency :param numpy.array S_m: magnetic source term :param numpy.array S_e: electric source term + :param bool integrate: Integrate the source term (multiply by Me) [True] """ - 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) + 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) self.integrate = integrate BaseSrc.__init__(self, rxList) def S_m(self, prob): - if prob._eqLocs is 'EF' and self.integrate is True: + """ + Magnetic source term + + :param Problem prob: FDEM Problem + :rtype: numpy.ndarray + :return: magnetic source term on mesh + """ + if prob._formulation is 'HJ' and self.integrate is True: return prob.Me * self._S_m return self._S_m def S_e(self, prob): - if prob._eqLocs is 'FE' and self.integrate is True: + """ + Electric source term + + :param Problem prob: FDEM Problem + :rtype: numpy.ndarray + :return: electric source term on mesh + """ + if prob._formulation is 'EB' and self.integrate is True: return prob.Me * self._S_e return self._S_e class MagDipole(BaseSrc): - """ + """ Point magnetic dipole source calculated by taking the curl of a magnetic vector potential. By taking the discrete curl, we ensure that the magnetic - flux density is divergence free (no magnetic monopoles!). + 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:: + .. 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}} @@ -225,17 +254,17 @@ class MagDipole(BaseSrc): and define a zero-frequency primary problem, noting that the source is generated by a divergence free electric current - .. math:: + .. 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 + 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:: + .. 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 + Our secondary problem is then .. math:: \mathbf{C} \mathbf{e^S} + i \omega \mathbf{b^S} = - i \omega \mathbf{b^P} \\\\ @@ -245,15 +274,15 @@ class MagDipole(BaseSrc): :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 + :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 - def __init__(self, rxList, freq, loc, orientation='Z', moment=1., mu = mu_0): + def __init__(self, rxList, freq, loc, orientation='Z', moment=1., mu=mu_0): 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 @@ -265,17 +294,17 @@ class MagDipole(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ - eqLocs = prob._eqLocs + formulation = prob._formulation - if eqLocs is 'FE': + if formulation is 'EB': gridX = prob.mesh.gridEx gridY = prob.mesh.gridEy gridZ = prob.mesh.gridEz C = prob.mesh.edgeCurl - elif eqLocs is 'EF': + elif formulation is 'HJ': gridX = prob.mesh.gridFx gridY = prob.mesh.gridFy gridZ = prob.mesh.gridFz @@ -303,10 +332,10 @@ class MagDipole(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ b = self.bPrimary(prob) - return h_from_b(prob,b) + return 1./self.mu * b def S_m(self, prob): """ @@ -314,10 +343,12 @@ class MagDipole(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ b_p = self.bPrimary(prob) + if prob._formulation is 'HJ': + b_p = prob.Me * b_p return -1j*omega(self.freq)*b_p def S_e(self, prob): @@ -326,21 +357,21 @@ class MagDipole(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ if all(np.r_[self.mu] == np.r_[prob.curModel.mu]): return Zero() else: - eqLocs = prob._eqLocs + formulation = prob._formulation - if eqLocs is 'FE': + if formulation is 'EB': mui_s = prob.curModel.mui - 1./self.mu MMui_s = prob.mesh.getFaceInnerProduct(mui_s) C = prob.mesh.edgeCurl - elif eqLocs is 'EF': + elif formulation is 'HJ': 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)) @@ -353,21 +384,20 @@ class MagDipole_Bfield(BaseSrc): 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. + 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 + :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 @@ -379,18 +409,18 @@ class MagDipole_Bfield(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ - eqLocs = prob._eqLocs + formulation = prob._formulation - if eqLocs is 'FE': + if formulation is 'EB': gridX = prob.mesh.gridFx gridY = prob.mesh.gridFy gridZ = prob.mesh.gridFz C = prob.mesh.edgeCurl - elif eqLocs is 'EF': + elif formulation is 'HJ': gridX = prob.mesh.gridEx gridY = prob.mesh.gridEy gridZ = prob.mesh.gridEz @@ -418,10 +448,10 @@ class MagDipole_Bfield(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ b = self.bPrimary(prob) - return h_from_b(prob, b) + return 1/self.mu * b def S_m(self, prob): """ @@ -429,9 +459,11 @@ class MagDipole_Bfield(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ b = self.bPrimary(prob) + if prob._formulation is 'HJ': + b = prob.Me * b return -1j*omega(self.freq)*b def S_e(self, prob): @@ -440,20 +472,20 @@ class MagDipole_Bfield(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ if all(np.r_[self.mu] == np.r_[prob.curModel.mu]): return Zero() else: - eqLocs = prob._eqLocs + formulation = prob._formulation - if eqLocs is 'FE': + if formulation is 'EB': mui_s = prob.curModel.mui - 1./self.mu MMui_s = prob.mesh.getFaceInnerProduct(mui_s) C = prob.mesh.edgeCurl - elif eqLocs is 'EF': + elif formulation is 'HJ': 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)) @@ -463,22 +495,22 @@ 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!). + flux density is divergence free (no magnetic monopoles!). - This approach uses a primary-secondary in frequency in the same fashion as the MagDipole. + 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 + :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 - def __init__(self, rxList, freq, loc, orientation='Z', radius = 1., mu=mu_0): + 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 @@ -491,17 +523,17 @@ class CircularLoop(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ - eqLocs = prob._eqLocs + formulation = prob._formulation - if eqLocs is 'FE': + if formulation is 'EB': gridX = prob.mesh.gridEx gridY = prob.mesh.gridEy gridZ = prob.mesh.gridEz C = prob.mesh.edgeCurl - elif eqLocs is 'EF': + elif formulation is 'HJ': gridX = prob.mesh.gridFx gridY = prob.mesh.gridFy gridZ = prob.mesh.gridFz @@ -528,7 +560,7 @@ class CircularLoop(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ b = self.bPrimary(prob) return 1./self.mu*b @@ -539,9 +571,11 @@ class CircularLoop(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ b = self.bPrimary(prob) + if prob._formulation is 'HJ': + b = prob.Me * b return -1j*omega(self.freq)*b def S_e(self, prob): @@ -550,22 +584,26 @@ class CircularLoop(BaseSrc): :param Problem prob: FDEM problem :rtype: numpy.ndarray - :return: primary magnetic field + :return: primary magnetic field """ if all(np.r_[self.mu] == np.r_[prob.curModel.mu]): return Zero() else: - eqLocs = prob._eqLocs + formulation = prob._formulation - if eqLocs is 'FE': + if formulation is 'EB': mui_s = prob.curModel.mui - 1./self.mu MMui_s = prob.mesh.getFaceInnerProduct(mui_s) C = prob.mesh.edgeCurl - elif eqLocs is 'EF': + + + elif formulation is 'HJ': 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)) + + diff --git a/SimPEG/EM/FDEM/SurveyFDEM.py b/SimPEG/EM/FDEM/SurveyFDEM.py index 444df88d..ce803ed1 100644 --- a/SimPEG/EM/FDEM/SurveyFDEM.py +++ b/SimPEG/EM/FDEM/SurveyFDEM.py @@ -3,6 +3,7 @@ from SimPEG.EM.Utils import * from scipy.constants import mu_0 from SimPEG.Utils import Zero, Identity import SrcFDEM as Src +from SimPEG import sp #################################################### @@ -18,33 +19,33 @@ 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'], + 'exr':['e', 'x', 'real'], + 'eyr':['e', 'y', 'real'], + 'ezr':['e', 'z', 'real'], + 'exi':['e', 'x', 'imag'], + 'eyi':['e', 'y', 'imag'], + 'ezi':['e', 'z', 'imag'], - 'bxr':['b', 'Fx', 'real'], - 'byr':['b', 'Fy', 'real'], - 'bzr':['b', 'Fz', 'real'], - 'bxi':['b', 'Fx', 'imag'], - 'byi':['b', 'Fy', 'imag'], - 'bzi':['b', 'Fz', 'imag'], + 'bxr':['b', 'x', 'real'], + 'byr':['b', 'y', 'real'], + 'bzr':['b', 'z', 'real'], + 'bxi':['b', 'x', 'imag'], + 'byi':['b', 'y', 'imag'], + 'bzi':['b', 'z', 'imag'], - 'jxr':['j', 'Fx', 'real'], - 'jyr':['j', 'Fy', 'real'], - 'jzr':['j', 'Fz', 'real'], - 'jxi':['j', 'Fx', 'imag'], - 'jyi':['j', 'Fy', 'imag'], - 'jzi':['j', 'Fz', 'imag'], + 'jxr':['j', 'x', 'real'], + 'jyr':['j', 'y', 'real'], + 'jzr':['j', 'z', 'real'], + 'jxi':['j', 'x', 'imag'], + 'jyi':['j', 'y', 'imag'], + 'jzi':['j', 'z', 'imag'], - 'hxr':['h', 'Ex', 'real'], - 'hyr':['h', 'Ey', 'real'], - 'hzr':['h', 'Ez', 'real'], - 'hxi':['h', 'Ex', 'imag'], - 'hyi':['h', 'Ey', 'imag'], - 'hzi':['h', 'Ez', 'imag'], + 'hxr':['h', 'x', 'real'], + 'hyr':['h', 'y', 'real'], + 'hzr':['h', 'z', 'real'], + 'hxi':['h', 'x', 'imag'], + 'hyi':['h', 'y', 'imag'], + 'hzi':['h', 'z', 'imag'], } radius = None @@ -56,34 +57,37 @@ class Rx(SimPEG.Survey.BaseRx): """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): + def projGLoc(self, u): + """Grid Location projection (e.g. Ex Fy ...)""" + return u._GLoc(self.rxType[0]) + self.knownRxTypes[self.rxType][1] + + def eval(self, src, mesh, u): """ Project fields to recievers to get data. :param Source src: FDEM source :param Mesh mesh: mesh used - :param Fields u: fields object + :param Fields f: fields object :rtype: numpy.ndarray :return: fields projected to recievers """ - P = self.getP(mesh) + # projGLoc = u._GLoc(self.knownRxTypes[self.rxType][0]) + # projGLoc += self.knownRxTypes[self.rxType][1] + + P = self.getP(mesh, self.projGLoc(u)) 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): + def evalDeriv(self, src, mesh, u, v, adjoint=False): """ Derivative of projected fields with respect to the inversion model times a vector. @@ -94,7 +98,8 @@ class Rx(SimPEG.Survey.BaseRx): :rtype: numpy.ndarray :return: fields projected to recievers """ - P = self.getP(mesh) + + P = self.getP(mesh, self.projGLoc(u)) if not adjoint: Pv_complex = P * v @@ -171,7 +176,7 @@ class Survey(SimPEG.Survey.BaseSurvey): 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 @@ -181,8 +186,9 @@ class Survey(SimPEG.Survey.BaseSurvey): 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): - raise Exception('Use Sources to project fields deriv.') + def evalDeriv(self, u): + raise Exception('Use Receivers to project fields deriv.') + diff --git a/SimPEG/EM/TDEM/BaseTDEM.py b/SimPEG/EM/TDEM/BaseTDEM.py index 2efb10ec..0da22072 100644 --- a/SimPEG/EM/TDEM/BaseTDEM.py +++ b/SimPEG/EM/TDEM/BaseTDEM.py @@ -27,6 +27,7 @@ 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) @@ -128,7 +129,7 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem): 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 +156,7 @@ class BaseTDEMProblem(BaseTimeProblem, BaseEMProblem): 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) diff --git a/SimPEG/EM/TDEM/SurveyTDEM.py b/SimPEG/EM/TDEM/SurveyTDEM.py index 6a65c0fe..4d04f0ae 100644 --- a/SimPEG/EM/TDEM/SurveyTDEM.py +++ b/SimPEG/EM/TDEM/SurveyTDEM.py @@ -51,12 +51,12 @@ class RxTDEM(Survey.BaseTimeRx): 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: @@ -79,12 +79,32 @@ class SrcTDEM(Survey.BaseSrc): class SrcTDEM_VMD_MVP(SrcTDEM): - def __init__(self,rxList,loc): + 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') @@ -93,13 +113,12 @@ class SrcTDEM_VMD_MVP(SrcTDEM): elif mesh._meshType is 'TENSOR': MVP = MagneticDipoleVectorPotential(self.loc, mesh, ['Ex','Ey','Ez']) else: - raise Exception('Unknown mesh for VMD') - - return {"b": mesh.edgeCurl*MVP} + raise Exception('Unknown mesh for VMD') + return mesh.edgeCurl.T*MfMui*mesh.edgeCurl*MVP class SrcTDEM_CircularLoop_MVP(SrcTDEM): - def __init__(self,rxList,loc,radius,waveformType): + def __init__(self,rxList,loc,radius,waveformType="STEPOFF"): self.loc = loc self.radius = radius self.waveformType = waveformType @@ -149,27 +168,27 @@ class SurveyTDEM(Survey.BaseSurvey): 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 diff --git a/SimPEG/EM/Utils/EMUtils.py b/SimPEG/EM/Utils/EMUtils.py index 4a342acb..e7dbf441 100644 --- a/SimPEG/EM/Utils/EMUtils.py +++ b/SimPEG/EM/Utils/EMUtils.py @@ -13,37 +13,4 @@ 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 - diff --git a/SimPEG/EM/Utils/__init__.py b/SimPEG/EM/Utils/__init__.py index 18dddde9..ef779042 100644 --- a/SimPEG/EM/Utils/__init__.py +++ b/SimPEG/EM/Utils/__init__.py @@ -1,5 +1,2 @@ -# import Sources -# import Ana -# import Solver -from EMUtils import omega, e_from_j, j_from_e, b_from_h, h_from_b +from EMUtils import omega, k from AnalyticUtils import MagneticDipoleFields, MagneticDipoleVectorPotential, MagneticLoopVectorPotential \ No newline at end of file diff --git a/SimPEG/EM/Utils/testingUtils.py b/SimPEG/EM/Utils/testingUtils.py index 8c703083..569f8e6d 100644 --- a/SimPEG/EM/Utils/testingUtils.py +++ b/SimPEG/EM/Utils/testingUtils.py @@ -4,19 +4,28 @@ from SimPEG import EM import sys from scipy.constants import mu_0 -def getFDEMProblem(fdemType, comp, SrcList, freq, verbose=False): - cs = 5. - ncx, ncy, ncz = 6, 6, 6 - npad = 3 +FLR = 1e-20 # "zero", so if residual below this --> pass regardless of order +CONDUCTIVITY = 1e1 +MU = mu_0 +freq = 5e-1 + + +def getFDEMProblem(fdemType, comp, SrcList, freq, useMu=False, verbose=False): + cs = 10. + ncx, ncy, ncz = 0, 0, 0 + npad = 8 hx = [(cs,npad,-1.3), (cs,ncx), (cs,npad,1.3)] hy = [(cs,npad,-1.3), (cs,ncy), (cs,npad,1.3)] hz = [(cs,npad,-1.3), (cs,ncz), (cs,npad,1.3)] mesh = Mesh.TensorMesh([hx,hy,hz],['C','C','C']) - mapping = Maps.ExpMap(mesh) + if useMu is True: + mapping = [('sigma', Maps.ExpMap(mesh)), ('mu', Maps.IdentityMap(mesh))] + else: + mapping = Maps.ExpMap(mesh) - 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.]) + x = np.array([np.linspace(-5.*cs,-2.*cs,3),np.linspace(5.*cs,2.*cs,3)]) + cs/4. #don't sample right by the source, slightly off alignment from either staggered grid + XYZ = Utils.ndgrid(x,x,np.linspace(-2.*cs,2.*cs,5)) Rx0 = EM.FDEM.Rx(XYZ, comp) Src = [] @@ -32,15 +41,15 @@ def getFDEMProblem(fdemType, comp, SrcList, freq, verbose=False): 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])] = 1. - S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Ez') + np.sum(mesh.vnE[:1])] = 1. + S_m[Utils.closestPoints(mesh,[0.,0.,0.],'Fz') + np.sum(mesh.vnF[:1])] = 1e-3 + S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Ez') + np.sum(mesh.vnE[:1])] = 1e-3 Src.append(EM.FDEM.Src.RawVec([Rx0], freq, S_m, S_e)) 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])] = 1. - S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Fz') + np.sum(mesh.vnF[:1])] = 1. + S_m[Utils.closestPoints(mesh,[0.,0.,0.],'Ez') + np.sum(mesh.vnE[:1])] = 1e-3 + S_e[Utils.closestPoints(mesh,[0.,0.,0.],'Fz') + np.sum(mesh.vnF[:1])] = 1e-3 Src.append(EM.FDEM.Src.RawVec([Rx0], freq, S_m, S_e)) if verbose: @@ -70,6 +79,48 @@ def getFDEMProblem(fdemType, comp, SrcList, freq, verbose=False): from pymatsolver import MumpsSolver prb.Solver = MumpsSolver except ImportError, e: - pass + prb.Solver = SolverLU - return prb \ No newline at end of file + 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 diff --git a/SimPEG/Examples/DC_Analytic_Dipole.py b/SimPEG/Examples/DC_Analytic_Dipole.py new file mode 100644 index 00000000..aed5eed4 --- /dev/null +++ b/SimPEG/Examples/DC_Analytic_Dipole.py @@ -0,0 +1,68 @@ +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) diff --git a/SimPEG/Examples/DC_Forward_PseudoSection.py b/SimPEG/Examples/DC_Forward_PseudoSection.py new file mode 100644 index 00000000..2f198238 --- /dev/null +++ b/SimPEG/Examples/DC_Forward_PseudoSection.py @@ -0,0 +1,187 @@ +from SimPEG import Mesh, Utils, np, sp +import SimPEG.DCIP as DC +import time + +def run(loc=None, sig=None, radi=None, param=None, stype='dpdp', plotIt=True): + """ + DC Forward Simulation + ===================== + + Forward model conductive spheres in a half-space and plot a pseudo-section + + Created by @fourndo on Mon Feb 01 19:28:06 2016 + + """ + + assert stype in ['pdp', 'dpdp'], "Source type (stype) must be pdp or dpdp (pole dipole or dipole dipole)" + + + 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 = 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, stype, param[0], param[1], param[2]) + survey, 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_x = ( Tx[-1][0,1] - Tx[0][0,0] ) / dl_len + dl_y = ( Tx[-1][1,1] - Tx[0][1,0] ) / dl_len + azm = np.arctan(dl_y/dl_x) + + #Set boundary conditions + mesh.setCellGradBC('neumann') + + # Define the 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() + P = sp.spdiags(1/dA,0,A.shape[0],A.shape[0]) + + # Now we can solve the system for all the transmitters + # We want to store the data + data = [] + + # There is probably a more elegant way to do this, but we can just for-loop through the transmitters + for ii in range(len(Tx)): + + start_time = time.time() # Let's time the calculations + + #print("Transmitter %i / %i\r" % (ii+1,len(Tx))) + + # Select dipole locations for receiver + rxloc_M = np.asarray(Rx[ii][:,0:3]) + rxloc_N = np.asarray(Rx[ii][:,3:]) + + + # For usual cases "dpdp" or "gradient" + if stype == 'pdp': + # Create an "inifinity" pole + tx = np.squeeze(Tx[ii][:,0:1]) + tinf = tx + np.array([dl_x,dl_y,0])*dl_len*2 + inds = Utils.closestPoints(mesh, np.c_[tx,tinf].T) + RHS = mesh.getInterpolationMat(np.asarray(Tx[ii]).T, 'CC').T*( [-1] / mesh.vol[inds] ) + else: + inds = Utils.closestPoints(mesh, np.asarray(Tx[ii]).T ) + RHS = mesh.getInterpolationMat(np.asarray(Tx[ii]).T, 'CC').T*( [-1,1] / mesh.vol[inds] ) + + # Iterative Solve + Ainvb = sp.linalg.bicgstab(P*A,P*RHS, tol=1e-5) + + # We now have the potential everywhere + phi = Utils.mkvc(Ainvb[0]) + + # Solve for phi on pole locations + P1 = mesh.getInterpolationMat(rxloc_M, 'CC') + P2 = mesh.getInterpolationMat(rxloc_N, 'CC') + + # Compute the potential difference + dtemp = (P1*phi - P2*phi)*np.pi + + data.append( dtemp ) + print '\rTransmitter {0} of {1} -> Time:{2} sec'.format(ii,len(Tx),time.time()- start_time), + + print 'Transmitter {0} of {1}'.format(ii,len(Tx)) + print 'Forward completed' + + # Let's just convert the 3D format into 2D (distance along line) and plot + # [Tx2d, Rx2d] = DC.convertObs_DC3D_to_2D(survey, np.ones(survey.nSrc)) + survey2D = DC.convertObs_DC3D_to_2D(survey, np.ones(survey.nSrc)) + survey2D.dobs =np.hstack(data) + # Here is an example for the first tx-rx array + if plotIt: + import matplotlib.pyplot as plt + fig = plt.figure() + ax = plt.subplot(2,1,1, aspect='equal') + 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]) + + + ax = plt.subplot(2,1,2, aspect='equal') + + # Plot the location of the spheres for reference + 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 + DC.plot_pseudoSection(survey2D,ax,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() diff --git a/SimPEG/Examples/EM_FDEM_1D_Inversion.py b/SimPEG/Examples/EM_FDEM_1D_Inversion.py index ff87b6a6..29f51ed4 100644 --- a/SimPEG/Examples/EM_FDEM_1D_Inversion.py +++ b/SimPEG/Examples/EM_FDEM_1D_Inversion.py @@ -21,8 +21,8 @@ def run(plotIt=True): active = mesh.vectorCCz<0. layer = (mesh.vectorCCz<0.) & (mesh.vectorCCz>=layerz) - actMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) - mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * actMap + 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 @@ -48,8 +48,7 @@ def run(plotIt=True): freqs = np.logspace(1,3,10) srcLoc = np.array([0., 0., 10.]) - srcList = [] - [srcList.append(EM.FDEM.Src.MagDipole([bzi],freq, srcLoc,orientation='Z')) for freq in freqs] + srcList = [EM.FDEM.Src.MagDipole([bzi],freq, srcLoc,orientation='Z') for freq in freqs] survey = EM.FDEM.Survey(srcList) prb = EM.FDEM.Problem_b(mesh, mapping=mapping) diff --git a/SimPEG/Examples/EM_TDEM_1D_Inversion.py b/SimPEG/Examples/EM_TDEM_1D_Inversion.py index 65ae6669..629811ca 100644 --- a/SimPEG/Examples/EM_TDEM_1D_Inversion.py +++ b/SimPEG/Examples/EM_TDEM_1D_Inversion.py @@ -19,8 +19,8 @@ def run(plotIt=True): active = mesh.vectorCCz<0. layer = (mesh.vectorCCz<0.) & (mesh.vectorCCz>=-100.) - actMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) - mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * actMap + actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) + mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap sig_half = 2e-3 sig_air = 1e-8 sig_layer = 1e-3 diff --git a/SimPEG/Examples/Inversion_Linear.py b/SimPEG/Examples/Inversion_Linear.py index a8a0eddc..47d49c7f 100644 --- a/SimPEG/Examples/Inversion_Linear.py +++ b/SimPEG/Examples/Inversion_Linear.py @@ -10,28 +10,6 @@ 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]) @@ -53,8 +31,8 @@ def run(N=100, plotIt=True): mtrue[mesh.vectorCCx > 0.45] = -0.5 mtrue[mesh.vectorCCx > 0.6] = 0 - prob = LinearProblem(mesh, G) - survey = LinearSurvey() + prob = Problem.LinearProblem(mesh, G) + survey = Survey.LinearSurvey() survey.pair(prob) survey.makeSyntheticData(mtrue, std=0.01) diff --git a/SimPEG/Examples/MT_1D_ForwardAndInversion.py b/SimPEG/Examples/MT_1D_ForwardAndInversion.py new file mode 100644 index 00000000..cf17e77b --- /dev/null +++ b/SimPEG/Examples/MT_1D_ForwardAndInversion.py @@ -0,0 +1,129 @@ +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.smoothModel = 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() diff --git a/SimPEG/Examples/MT_3D_Foward.py b/SimPEG/Examples/MT_3D_Foward.py new file mode 100644 index 00000000..da16eeee --- /dev/null +++ b/SimPEG/Examples/MT_3D_Foward.py @@ -0,0 +1,64 @@ +# 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() diff --git a/SimPEG/Examples/__init__.py b/SimPEG/Examples/__init__.py index 9c127a68..8cf7dea0 100644 --- a/SimPEG/Examples/__init__.py +++ b/SimPEG/Examples/__init__.py @@ -1,6 +1,8 @@ # 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_TDEM_1D_Inversion @@ -14,10 +16,17 @@ import Mesh_QuadTree_Creation import Mesh_QuadTree_FaceDiv import Mesh_QuadTree_HangingNodes import Mesh_Tensor_Creation +<<<<<<< HEAD import MT_1D_analytic_nlayer_Earth import sphereElectrostatic_example __examples__ = ["EM_FDEM_1D_Inversion", "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", "MT_1D_analytic_nlayer_Earth", "sphereElectrostatic_example"] +======= +import MT_1D_ForwardAndInversion +import MT_3D_Foward + +__examples__ = ["DC_Analytic_Dipole", "DC_Forward_PseudoSection", "EM_FDEM_1D_Inversion", "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", "MT_1D_ForwardAndInversion", "MT_3D_Foward"] +>>>>>>> master ##### AUTOIMPORTS ##### diff --git a/SimPEG/FLOW/Richards/RichardsProblem.py b/SimPEG/FLOW/Richards/RichardsProblem.py index 7c61c221..4dcabe60 100644 --- a/SimPEG/FLOW/Richards/RichardsProblem.py +++ b/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 @@ class RichardsRx(Survey.BaseTimeRx): 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,13 +57,13 @@ class RichardsSurvey(Survey.BaseSurvey): 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) @@ -71,11 +71,11 @@ class RichardsSurvey(Survey.BaseSurvey): 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 @@ class RichardsProblem(Problem.BaseTimeProblem): 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,7 +277,7 @@ class RichardsProblem(Problem.BaseTimeProblem): 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 @@ -285,7 +285,7 @@ class RichardsProblem(Problem.BaseTimeProblem): 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. diff --git a/SimPEG/MT/BaseMT.py b/SimPEG/MT/BaseMT.py new file mode 100644 index 00000000..36389430 --- /dev/null +++ b/SimPEG/MT/BaseMT.py @@ -0,0 +1,132 @@ +from SimPEG import SolverLU as SimpegSolver, PropMaps, Utils, mkvc, sp, np +from SimPEG.EM.FDEM.FDEM 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, u=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 u is None: + u = 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. + u_src = u[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, u_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, 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 + return mkvc(Jv) + + def Jtvec(self, m, v, u=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 u is None: + u = 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 = u[src, :] + + for rx in src.rxList: + # Get the adjoint evalDeriv + # PTv needs to be nE, + 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) + 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 \ No newline at end of file diff --git a/SimPEG/MT/FieldsMT.py b/SimPEG/MT/FieldsMT.py new file mode 100644 index 00000000..86ac7343 --- /dev/null +++ b/SimPEG/MT/FieldsMT.py @@ -0,0 +1,351 @@ +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 \ No newline at end of file diff --git a/SimPEG/MT/Problem1D/Probs.py b/SimPEG/MT/Problem1D/Probs.py new file mode 100644 index 00000000..eb7aa331 --- /dev/null +++ b/SimPEG/MT/Problem1D/Probs.py @@ -0,0 +1,291 @@ +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 diff --git a/SimPEG/MT/Problem1D/__init__.py b/SimPEG/MT/Problem1D/__init__.py new file mode 100644 index 00000000..b0a77250 --- /dev/null +++ b/SimPEG/MT/Problem1D/__init__.py @@ -0,0 +1 @@ +from Probs import eForm_TotalField, eForm_psField \ No newline at end of file diff --git a/SimPEG/MT/Problem2D/Probs.py b/SimPEG/MT/Problem2D/Probs.py new file mode 100644 index 00000000..e69de29b diff --git a/SimPEG/MT/Problem2D/__init__.py b/SimPEG/MT/Problem2D/__init__.py new file mode 100644 index 00000000..fc80254b --- /dev/null +++ b/SimPEG/MT/Problem2D/__init__.py @@ -0,0 +1 @@ +pass \ No newline at end of file diff --git a/SimPEG/MT/Problem3D/Probs.py b/SimPEG/MT/Problem3D/Probs.py new file mode 100644 index 00000000..512362b8 --- /dev/null +++ b/SimPEG/MT/Problem3D/Probs.py @@ -0,0 +1,138 @@ +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 + diff --git a/SimPEG/MT/Problem3D/__init__.py b/SimPEG/MT/Problem3D/__init__.py new file mode 100644 index 00000000..27e761a9 --- /dev/null +++ b/SimPEG/MT/Problem3D/__init__.py @@ -0,0 +1 @@ +from Probs import eForm_ps \ No newline at end of file diff --git a/SimPEG/MT/SrcMT.py b/SimPEG/MT/SrcMT.py new file mode 100644 index 00000000..70698c88 --- /dev/null +++ b/SimPEG/MT/SrcMT.py @@ -0,0 +1,206 @@ +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 diff --git a/SimPEG/MT/SurveyMT.py b/SimPEG/MT/SurveyMT.py new file mode 100644 index 00000000..4e4a8688 --- /dev/null +++ b/SimPEG/MT/SurveyMT.py @@ -0,0 +1,562 @@ +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, u): + data = Data(self) + for src in self.srcList: + sys.stdout.flush() + for rx in src.rxList: + data[src, rx] = rx.eval(src, self.mesh, u) + return data + + def evalDeriv(self, u): + 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) + diff --git a/SimPEG/MT/Utils/MT1Danalytic.py b/SimPEG/MT/Utils/MT1Danalytic.py new file mode 100644 index 00000000..a28777cb --- /dev/null +++ b/SimPEG/MT/Utils/MT1Danalytic.py @@ -0,0 +1,108 @@ +# 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 diff --git a/SimPEG/MT/Utils/MT1Dsolutions.py b/SimPEG/MT/Utils/MT1Dsolutions.py new file mode 100644 index 00000000..aae83162 --- /dev/null +++ b/SimPEG/MT/Utils/MT1Dsolutions.py @@ -0,0 +1,45 @@ +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 diff --git a/SimPEG/MT/Utils/__init__.py b/SimPEG/MT/Utils/__init__.py new file mode 100644 index 00000000..b683f8b4 --- /dev/null +++ b/SimPEG/MT/Utils/__init__.py @@ -0,0 +1,4 @@ +from MT1Dsolutions import * # Add the names of the functions +from MT1Danalytic import * +from dataUtils import * +from ediFilesUtils import * diff --git a/SimPEG/MT/Utils/dataUtils.py b/SimPEG/MT/Utils/dataUtils.py new file mode 100644 index 00000000..b1947cb8 --- /dev/null +++ b/SimPEG/MT/Utils/dataUtils.py @@ -0,0 +1,245 @@ +# 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) diff --git a/SimPEG/MT/Utils/ediFilesUtils.py b/SimPEG/MT/Utils/ediFilesUtils.py new file mode 100644 index 00000000..55818a87 --- /dev/null +++ b/SimPEG/MT/Utils/ediFilesUtils.py @@ -0,0 +1,175 @@ +# 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 +try: + import osr +except ImportError as e: + print 'Could not import osr, missing the gdal package' + pass + +class EDIimporter: + """ + A class to import EDIfiles. + + """ + _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 + _2out = None + + + 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): + # 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) diff --git a/SimPEG/MT/Utils/plotDataTypes.py b/SimPEG/MT/Utils/plotDataTypes.py new file mode 100644 index 00000000..c0180f00 --- /dev/null +++ b/SimPEG/MT/Utils/plotDataTypes.py @@ -0,0 +1,416 @@ +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 diff --git a/SimPEG/MT/Utils/sourceUtils.py b/SimPEG/MT/Utils/sourceUtils.py new file mode 100644 index 00000000..24b36bfe --- /dev/null +++ b/SimPEG/MT/Utils/sourceUtils.py @@ -0,0 +1,178 @@ +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 diff --git a/SimPEG/MT/Utils/srcUtils.py b/SimPEG/MT/Utils/srcUtils.py new file mode 100644 index 00000000..a98cc5b2 --- /dev/null +++ b/SimPEG/MT/Utils/srcUtils.py @@ -0,0 +1,46 @@ +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 diff --git a/SimPEG/MT/__init__.py b/SimPEG/MT/__init__.py new file mode 100644 index 00000000..b9f5536b --- /dev/null +++ b/SimPEG/MT/__init__.py @@ -0,0 +1,5 @@ +import Utils +from SurveyMT import Rx, Survey, Data +from FieldsMT import Fields1D_e, Fields3D_e +import Problem1D, Problem2D, Problem3D +import SrcMT \ No newline at end of file diff --git a/SimPEG/Maps.py b/SimPEG/Maps.py index a3c76e6a..5f71d87c 100644 --- a/SimPEG/Maps.py +++ b/SimPEG/Maps.py @@ -4,6 +4,7 @@ from Tests import checkDerivative from PropMaps import PropMap, Property from numpy.polynomial import polynomial from scipy.interpolate import UnivariateSpline +import warnings class IdentityMap(object): """ @@ -296,11 +297,11 @@ class LogMap(IdentityMap): def inverse(self, m): return np.exp(Utils.mkvc(m)) -class FullMap(IdentityMap): +class SurjectFull(IdentityMap): """ - FullMap + SurjectFull - Given a scalar, the FullMap maps the value to the + Given a scalar, the SurjectFull maps the value to the full model space. """ @@ -327,9 +328,15 @@ class FullMap(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 Vertical1DMap(IdentityMap): - """Vertical1DMap +class SurjectVertical1D(IdentityMap): + """SurjectVertical1DMap Given a 1D vector through the last dimension of the mesh, this will extend to the full @@ -369,8 +376,14 @@ class Vertical1DMap(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 Map2Dto3D(IdentityMap): +class Surject2Dto3D(IdentityMap): """Map2Dto3D Given a 2D vector, this will extend to the full @@ -425,6 +438,13 @@ class Map2Dto3D(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. @@ -458,7 +478,7 @@ class Mesh2Mesh(IdentityMap): return self.P -class ActiveCells(IdentityMap): +class InjectActiveCells(IdentityMap): """ Active model parameters. @@ -506,7 +526,14 @@ class ActiveCells(IdentityMap): def deriv(self, m): return self.P -class ActiveCellsTopo(IdentityMap): +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 InjectActiveCellsTopo(IdentityMap): """ Active model parameters. Extend for cells on topography to air cell (only works for tensor mesh) @@ -577,6 +604,12 @@ class ActiveCellsTopo(IdentityMap): def deriv(self, m): return self.P +class ActiveCellsTopo(InjectActiveCellsTopo): + def __init__(self, mesh, indActive, valInactive, nC=None): + warnings.warn( + "`ActiveCellsTopo` is deprecated and will be removed in future versions. Use `InjectActiveCellsTopo` instead", + FutureWarning) + InjectActiveCellsTopo.__init__(self, mesh, indActive, valInactive, nC) class Weighting(IdentityMap): """ diff --git a/SimPEG/Mesh/DiffOperators.py b/SimPEG/Mesh/DiffOperators.py index 00bf0259..793b2581 100644 --- a/SimPEG/Mesh/DiffOperators.py +++ b/SimPEG/Mesh/DiffOperators.py @@ -746,4 +746,3 @@ 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 - diff --git a/SimPEG/Mesh/TensorMesh.py b/SimPEG/Mesh/TensorMesh.py index 508f015c..1650b5cb 100644 --- a/SimPEG/Mesh/TensorMesh.py +++ b/SimPEG/Mesh/TensorMesh.py @@ -234,6 +234,9 @@ 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) @@ -257,6 +260,16 @@ 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)) diff --git a/SimPEG/Mesh/TreeUtils.c b/SimPEG/Mesh/TreeUtils.c index 26fbafec..6cf68059 100644 --- a/SimPEG/Mesh/TreeUtils.c +++ b/SimPEG/Mesh/TreeUtils.c @@ -1,4 +1,4 @@ -/* Generated by Cython 0.22.1 */ +/* Generated by Cython 0.23.4 */ /* BEGIN: Cython Metadata { @@ -7,25 +7,13 @@ END: Cython Metadata */ #define PY_SSIZE_T_CLEAN -#ifndef CYTHON_USE_PYLONG_INTERNALS -#ifdef PYLONG_BITS_IN_DIGIT -#define CYTHON_USE_PYLONG_INTERNALS 0 -#else -#include "pyconfig.h" -#ifdef PYLONG_BITS_IN_DIGIT -#define CYTHON_USE_PYLONG_INTERNALS 1 -#else -#define CYTHON_USE_PYLONG_INTERNALS 0 -#endif -#endif -#endif #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else -#define CYTHON_ABI "0_22_1" +#define CYTHON_ABI "0_23_4" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) @@ -60,6 +48,9 @@ END: Cython Metadata */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif @@ -67,12 +58,12 @@ END: Cython Metadata */ #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif @@ -90,7 +81,7 @@ END: Cython Metadata */ #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) @@ -109,12 +100,10 @@ END: Cython Metadata */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) - #define __Pyx_PyFrozenSet_Size(s) PyObject_Size(s) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) - #define __Pyx_PyFrozenSet_Size(s) PySet_Size(s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) @@ -182,16 +171,18 @@ END: Cython Metadata */ #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif -#ifndef CYTHON_INLINE - #if defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) @@ -204,35 +195,33 @@ END: Cython Metadata */ #define CYTHON_RESTRICT #endif #endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { - /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and - a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is - a quiet NaN. */ float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif -#define __Pyx_void_to_None(void_result) (void_result, Py_INCREF(Py_None), Py_None) -#ifdef __cplusplus -template -void __Pyx_call_destructor(T* x) { - x->~T(); -} -template -class __Pyx_FakeReference { - public: - __Pyx_FakeReference() : ptr(NULL) { } - __Pyx_FakeReference(T& ref) : ptr(&ref) { } - T *operator->() { return ptr; } - operator T&() { return *ptr; } - private: - T *ptr; -}; -#endif #if PY_MAJOR_VERSION >= 3 @@ -251,10 +240,6 @@ class __Pyx_FakeReference { #endif #endif -#if defined(WIN32) || defined(MS_WINDOWS) -#define _USE_MATH_DEFINES -#endif -#include #define __PYX_HAVE__SimPEG__Mesh__TreeUtils #define __PYX_HAVE_API__SimPEG__Mesh__TreeUtils #ifdef _OPENMP @@ -293,16 +278,34 @@ typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ - (sizeof(type) < sizeof(Py_ssize_t)) || \ - (sizeof(type) > sizeof(Py_ssize_t) && \ - likely(v < (type)PY_SSIZE_T_MAX || \ - v == (type)PY_SSIZE_T_MAX) && \ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ - v == (type)PY_SSIZE_T_MIN))) || \ - (sizeof(type) == sizeof(Py_ssize_t) && \ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) @@ -337,8 +340,9 @@ static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) -#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); @@ -446,7 +450,7 @@ static const char *__pyx_filename; static const char *__pyx_f[] = { - "SimPEG/Mesh/TreeUtils.pyx", + "SimPEG\\Mesh\\TreeUtils.pyx", }; /*--- Type declarations ---*/ @@ -468,19 +472,19 @@ static const char *__pyx_f[] = { static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil) \ - if (acquire_gil) { \ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ - PyGILState_Release(__pyx_gilstate_save); \ - } else { \ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else - #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif - #define __Pyx_RefNannyFinishContext() \ + #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) @@ -503,13 +507,13 @@ static const char *__pyx_f[] = { #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif -#define __Pyx_XDECREF_SET(r, v) do { \ - PyObject *tmp = (PyObject *) r; \ - r = v; __Pyx_XDECREF(tmp); \ +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ } while (0) -#define __Pyx_DECREF_SET(r, v) do { \ - PyObject *tmp = (PyObject *) r; \ - r = v; __Pyx_DECREF(tmp); \ +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) @@ -536,8 +540,8 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, @@ -559,32 +563,29 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif -static CYTHON_INLINE int __Pyx_div_int(int, int); /* proto */ +static CYTHON_INLINE int __Pyx_div_int(int, int); -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) -#define UNARY_NEG_WOULD_OVERFLOW(x) (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) - -static CYTHON_INLINE int __Pyx_mod_int(int, int); /* proto */ +static CYTHON_INLINE int __Pyx_mod_int(int, int); static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); @@ -598,12 +599,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif -static CYTHON_INLINE long __Pyx_div_long(long, long); /* proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) : \ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) : \ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, @@ -630,7 +631,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); -static CYTHON_INLINE long __Pyx_pow_long(long, long); /* proto */ +static CYTHON_INLINE long __Pyx_pow_long(long, long); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -647,9 +648,6 @@ int __pyx_module_is_main_SimPEG__Mesh__TreeUtils = 0; /* Implementation of 'SimPEG.Mesh.TreeUtils' */ static PyObject *__pyx_builtin_range; -static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_bitrange(CYTHON_UNUSED PyObject *__pyx_self, long __pyx_v_x, int __pyx_v_width, int __pyx_v_start, int __pyx_v_end); /* proto */ -static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_dimension, int __pyx_v_bits, int __pyx_v_levelBits, PyObject *__pyx_v_p, int __pyx_v_level); /* proto */ -static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_dimension, int __pyx_v_bits, int __pyx_v_levelBits, long __pyx_v_idx); /* proto */ static char __pyx_k_b[] = "b"; static char __pyx_k_i[] = "i"; static char __pyx_k_n[] = "n"; @@ -675,9 +673,9 @@ static char __pyx_k_dimension[] = "dimension"; static char __pyx_k_levelBits[] = "levelBits"; static char __pyx_k_SimPEG_Mesh_TreeUtils[] = "SimPEG.Mesh.TreeUtils"; static char __pyx_k_The_Z_order_curve_is_generated[] = "\n The Z-order curve is generated by interleaving the bits of an offset.\n\n See also:\n\n https://github.com/cortesi/scurve\n Aldo Cortesi \n\n"; -static char __pyx_k_Users_rowan_git_simpeg_simpeg_S[] = "/Users/rowan/git/simpeg/simpeg/SimPEG/Mesh/TreeUtils.pyx"; +static char __pyx_k_C_Users_tastic_Documents_SimPEG[] = "C:\\Users\\tastic\\Documents\\SimPEG\\SimPEG\\Mesh\\TreeUtils.pyx"; +static PyObject *__pyx_kp_s_C_Users_tastic_Documents_SimPEG; static PyObject *__pyx_n_s_SimPEG_Mesh_TreeUtils; -static PyObject *__pyx_kp_s_Users_rowan_git_simpeg_simpeg_S; static PyObject *__pyx_n_s__3; static PyObject *__pyx_n_s_b; static PyObject *__pyx_n_s_bitoff; @@ -701,6 +699,9 @@ static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_width; static PyObject *__pyx_n_s_x; +static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_bitrange(CYTHON_UNUSED PyObject *__pyx_self, long __pyx_v_x, int __pyx_v_width, int __pyx_v_start, int __pyx_v_end); /* proto */ +static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_dimension, int __pyx_v_bits, int __pyx_v_levelBits, PyObject *__pyx_v_p, int __pyx_v_level); /* proto */ +static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_dimension, int __pyx_v_bits, int __pyx_v_levelBits, long __pyx_v_idx); /* proto */ static PyObject *__pyx_int_0; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__4; @@ -709,7 +710,7 @@ static PyObject *__pyx_codeobj__2; static PyObject *__pyx_codeobj__5; static PyObject *__pyx_codeobj__7; -/* "SimPEG/Mesh/TreeUtils.pyx":17 +/* "SimPEG\Mesh\TreeUtils.pyx":17 * """ * * def bitrange(long x, int width, int start, int end): # <<<<<<<<<<<<<< @@ -807,7 +808,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_bitrange(CYTHON_UNUSED PyObje int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bitrange", 0); - /* "SimPEG/Mesh/TreeUtils.pyx":22 + /* "SimPEG\Mesh\TreeUtils.pyx":22 * (start, end) is inclusive lower bound, exclusive upper bound. * """ * return x >> (width-end) & ((2**(end-start))-1) # <<<<<<<<<<<<<< @@ -821,7 +822,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_bitrange(CYTHON_UNUSED PyObje __pyx_t_1 = 0; goto __pyx_L0; - /* "SimPEG/Mesh/TreeUtils.pyx":17 + /* "SimPEG\Mesh\TreeUtils.pyx":17 * """ * * def bitrange(long x, int width, int start, int end): # <<<<<<<<<<<<<< @@ -840,7 +841,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_bitrange(CYTHON_UNUSED PyObje return __pyx_r; } -/* "SimPEG/Mesh/TreeUtils.pyx":24 +/* "SimPEG\Mesh\TreeUtils.pyx":24 * return x >> (width-end) & ((2**(end-start))-1) * * def index(int dimension, int bits, int levelBits, list p, int level): # <<<<<<<<<<<<<< @@ -971,7 +972,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject __Pyx_RefNannySetupContext("index", 0); __Pyx_INCREF(__pyx_v_p); - /* "SimPEG/Mesh/TreeUtils.pyx":25 + /* "SimPEG\Mesh\TreeUtils.pyx":25 * * def index(int dimension, int bits, int levelBits, list p, int level): * cdef long idx = 0 # <<<<<<<<<<<<<< @@ -980,7 +981,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject */ __pyx_v_idx = 0; - /* "SimPEG/Mesh/TreeUtils.pyx":31 + /* "SimPEG\Mesh\TreeUtils.pyx":31 * cdef int bitoff * * p = [_ for _ in p] # <<<<<<<<<<<<<< @@ -1010,7 +1011,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject __Pyx_DECREF_SET(__pyx_v_p, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; - /* "SimPEG/Mesh/TreeUtils.pyx":33 + /* "SimPEG\Mesh\TreeUtils.pyx":33 * p = [_ for _ in p] * * p.reverse() # <<<<<<<<<<<<<< @@ -1019,7 +1020,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject */ __pyx_t_5 = PyList_Reverse(__pyx_v_p); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Mesh/TreeUtils.pyx":34 + /* "SimPEG\Mesh\TreeUtils.pyx":34 * * p.reverse() * iwidth = bits * dimension # <<<<<<<<<<<<<< @@ -1028,7 +1029,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject */ __pyx_v_iwidth = (__pyx_v_bits * __pyx_v_dimension); - /* "SimPEG/Mesh/TreeUtils.pyx":35 + /* "SimPEG\Mesh\TreeUtils.pyx":35 * p.reverse() * iwidth = bits * dimension * for i in range(iwidth): # <<<<<<<<<<<<<< @@ -1039,7 +1040,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_i = __pyx_t_7; - /* "SimPEG/Mesh/TreeUtils.pyx":36 + /* "SimPEG\Mesh\TreeUtils.pyx":36 * iwidth = bits * dimension * for i in range(iwidth): * bitoff = bits-(i/dimension)-1 # <<<<<<<<<<<<<< @@ -1047,28 +1048,16 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject * b = bitrange(p[poff], bits, bitoff, bitoff+1) << i */ if (unlikely(__pyx_v_dimension == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } else if (sizeof(int) == sizeof(long) && (!(((int)-1) > 0)) && unlikely(__pyx_v_dimension == (int)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_i))) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_v_bitoff = ((__pyx_v_bits - __Pyx_div_int(__pyx_v_i, __pyx_v_dimension)) - 1); - /* "SimPEG/Mesh/TreeUtils.pyx":37 + /* "SimPEG\Mesh\TreeUtils.pyx":37 * for i in range(iwidth): * bitoff = bits-(i/dimension)-1 * poff = dimension-(i%dimension)-1 # <<<<<<<<<<<<<< @@ -1076,18 +1065,12 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject * idx |= b */ if (unlikely(__pyx_v_dimension == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_v_poff = ((__pyx_v_dimension - __Pyx_mod_int(__pyx_v_i, __pyx_v_dimension)) - 1); - /* "SimPEG/Mesh/TreeUtils.pyx":38 + /* "SimPEG\Mesh\TreeUtils.pyx":38 * bitoff = bits-(i/dimension)-1 * poff = dimension-(i%dimension)-1 * b = bitrange(p[poff], bits, bitoff, bitoff+1) << i # <<<<<<<<<<<<<< @@ -1147,7 +1130,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_b = __pyx_t_13; - /* "SimPEG/Mesh/TreeUtils.pyx":39 + /* "SimPEG\Mesh\TreeUtils.pyx":39 * poff = dimension-(i%dimension)-1 * b = bitrange(p[poff], bits, bitoff, bitoff+1) << i * idx |= b # <<<<<<<<<<<<<< @@ -1157,7 +1140,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject __pyx_v_idx = (__pyx_v_idx | __pyx_v_b); } - /* "SimPEG/Mesh/TreeUtils.pyx":41 + /* "SimPEG\Mesh\TreeUtils.pyx":41 * idx |= b * * return (idx << levelBits) + level # <<<<<<<<<<<<<< @@ -1171,7 +1154,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject __pyx_t_12 = 0; goto __pyx_L0; - /* "SimPEG/Mesh/TreeUtils.pyx":24 + /* "SimPEG\Mesh\TreeUtils.pyx":24 * return x >> (width-end) & ((2**(end-start))-1) * * def index(int dimension, int bits, int levelBits, list p, int level): # <<<<<<<<<<<<<< @@ -1199,7 +1182,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_2index(CYTHON_UNUSED PyObject return __pyx_r; } -/* "SimPEG/Mesh/TreeUtils.pyx":43 +/* "SimPEG\Mesh\TreeUtils.pyx":43 * return (idx << levelBits) + level * * def point(int dimension, int bits, int levelBits, long idx): # <<<<<<<<<<<<<< @@ -1314,7 +1297,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject int __pyx_clineno = 0; __Pyx_RefNannySetupContext("point", 0); - /* "SimPEG/Mesh/TreeUtils.pyx":49 + /* "SimPEG\Mesh\TreeUtils.pyx":49 * cdef long b * * n = idx & (2**levelBits-1) # <<<<<<<<<<<<<< @@ -1323,7 +1306,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject */ __pyx_v_n = (__pyx_v_idx & (__Pyx_pow_long(2, ((long)__pyx_v_levelBits)) - 1)); - /* "SimPEG/Mesh/TreeUtils.pyx":50 + /* "SimPEG\Mesh\TreeUtils.pyx":50 * * n = idx & (2**levelBits-1) * idx = idx >> levelBits # <<<<<<<<<<<<<< @@ -1332,7 +1315,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject */ __pyx_v_idx = (__pyx_v_idx >> __pyx_v_levelBits); - /* "SimPEG/Mesh/TreeUtils.pyx":52 + /* "SimPEG\Mesh\TreeUtils.pyx":52 * idx = idx >> levelBits * * p = [0]*dimension # <<<<<<<<<<<<<< @@ -1351,7 +1334,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject __pyx_v_p = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Mesh/TreeUtils.pyx":53 + /* "SimPEG\Mesh\TreeUtils.pyx":53 * * p = [0]*dimension * iwidth = bits * dimension # <<<<<<<<<<<<<< @@ -1360,7 +1343,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject */ __pyx_v_iwidth = (__pyx_v_bits * __pyx_v_dimension); - /* "SimPEG/Mesh/TreeUtils.pyx":54 + /* "SimPEG\Mesh\TreeUtils.pyx":54 * p = [0]*dimension * iwidth = bits * dimension * for i in range(iwidth): # <<<<<<<<<<<<<< @@ -1371,7 +1354,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "SimPEG/Mesh/TreeUtils.pyx":55 + /* "SimPEG\Mesh\TreeUtils.pyx":55 * iwidth = bits * dimension * for i in range(iwidth): * b = bitrange(idx, iwidth, i, i+1) << (iwidth-i-1)/dimension # <<<<<<<<<<<<<< @@ -1423,23 +1406,11 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_12 = ((__pyx_v_iwidth - __pyx_v_i) - 1); if (unlikely(__pyx_v_dimension == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } else if (sizeof(long) == sizeof(long) && (!(((int)-1) > 0)) && unlikely(__pyx_v_dimension == (int)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_t_12))) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_4 = __Pyx_PyInt_From_long(__Pyx_div_long(__pyx_t_12, __pyx_v_dimension)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} @@ -1452,7 +1423,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_b = __pyx_t_12; - /* "SimPEG/Mesh/TreeUtils.pyx":56 + /* "SimPEG\Mesh\TreeUtils.pyx":56 * for i in range(iwidth): * b = bitrange(idx, iwidth, i, i+1) << (iwidth-i-1)/dimension * p[i%dimension] |= b # <<<<<<<<<<<<<< @@ -1460,13 +1431,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject * return p + [n] */ if (unlikely(__pyx_v_dimension == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_13 = __Pyx_mod_int(__pyx_v_i, __pyx_v_dimension); @@ -1482,7 +1447,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "SimPEG/Mesh/TreeUtils.pyx":57 + /* "SimPEG\Mesh\TreeUtils.pyx":57 * b = bitrange(idx, iwidth, i, i+1) << (iwidth-i-1)/dimension * p[i%dimension] |= b * p.reverse() # <<<<<<<<<<<<<< @@ -1491,7 +1456,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject */ __pyx_t_14 = PyList_Reverse(__pyx_v_p); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Mesh/TreeUtils.pyx":58 + /* "SimPEG\Mesh\TreeUtils.pyx":58 * p[i%dimension] |= b * p.reverse() * return p + [n] # <<<<<<<<<<<<<< @@ -1513,7 +1478,7 @@ static PyObject *__pyx_pf_6SimPEG_4Mesh_9TreeUtils_4point(CYTHON_UNUSED PyObject __pyx_t_1 = 0; goto __pyx_L0; - /* "SimPEG/Mesh/TreeUtils.pyx":43 + /* "SimPEG\Mesh\TreeUtils.pyx":43 * return (idx << levelBits) + level * * def point(int dimension, int bits, int levelBits, long idx): # <<<<<<<<<<<<<< @@ -1563,8 +1528,8 @@ static struct PyModuleDef __pyx_moduledef = { #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_k_C_Users_tastic_Documents_SimPEG, sizeof(__pyx_k_C_Users_tastic_Documents_SimPEG), 0, 0, 1, 0}, {&__pyx_n_s_SimPEG_Mesh_TreeUtils, __pyx_k_SimPEG_Mesh_TreeUtils, sizeof(__pyx_k_SimPEG_Mesh_TreeUtils), 0, 0, 1, 1}, - {&__pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_k_Users_rowan_git_simpeg_simpeg_S, sizeof(__pyx_k_Users_rowan_git_simpeg_simpeg_S), 0, 0, 1, 0}, {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1}, {&__pyx_n_s_bitoff, __pyx_k_bitoff, sizeof(__pyx_k_bitoff), 0, 0, 1, 1}, @@ -1601,7 +1566,7 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "SimPEG/Mesh/TreeUtils.pyx":17 + /* "SimPEG\Mesh\TreeUtils.pyx":17 * """ * * def bitrange(long x, int width, int start, int end): # <<<<<<<<<<<<<< @@ -1611,9 +1576,9 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple_ = PyTuple_Pack(4, __pyx_n_s_x, __pyx_n_s_width, __pyx_n_s_start, __pyx_n_s_end); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_bitrange, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_bitrange, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Mesh/TreeUtils.pyx":24 + /* "SimPEG\Mesh\TreeUtils.pyx":24 * return x >> (width-end) & ((2**(end-start))-1) * * def index(int dimension, int bits, int levelBits, list p, int level): # <<<<<<<<<<<<<< @@ -1623,9 +1588,9 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple__4 = PyTuple_Pack(12, __pyx_n_s_dimension, __pyx_n_s_bits, __pyx_n_s_levelBits, __pyx_n_s_p, __pyx_n_s_level, __pyx_n_s_idx, __pyx_n_s_iwidth, __pyx_n_s_i, __pyx_n_s_b, __pyx_n_s_bitoff, __pyx_n_s_poff, __pyx_n_s__3); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); - __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(5, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_index, 24, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(5, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_index, 24, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Mesh/TreeUtils.pyx":43 + /* "SimPEG\Mesh\TreeUtils.pyx":43 * return (idx << levelBits) + level * * def point(int dimension, int bits, int levelBits, long idx): # <<<<<<<<<<<<<< @@ -1635,7 +1600,7 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple__6 = PyTuple_Pack(9, __pyx_n_s_dimension, __pyx_n_s_bits, __pyx_n_s_levelBits, __pyx_n_s_idx, __pyx_n_s_p, __pyx_n_s_iwidth, __pyx_n_s_i, __pyx_n_s_n, __pyx_n_s_b); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); - __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(4, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_point, 43, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(4, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_point, 43, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -1674,18 +1639,24 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_TreeUtils(void)", 0); - if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED - if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS @@ -1708,12 +1679,12 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ - if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main_SimPEG__Mesh__TreeUtils) { - if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if PY_MAJOR_VERSION >= 3 { @@ -1724,9 +1695,9 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) } #endif /*--- Builtin init code ---*/ - if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ - if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ @@ -1735,8 +1706,11 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif - /* "SimPEG/Mesh/TreeUtils.pyx":17 + /* "SimPEG\Mesh\TreeUtils.pyx":17 * """ * * def bitrange(long x, int width, int start, int end): # <<<<<<<<<<<<<< @@ -1748,7 +1722,7 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_bitrange, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Mesh/TreeUtils.pyx":24 + /* "SimPEG\Mesh\TreeUtils.pyx":24 * return x >> (width-end) & ((2**(end-start))-1) * * def index(int dimension, int bits, int levelBits, list p, int level): # <<<<<<<<<<<<<< @@ -1760,7 +1734,7 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_index, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 24; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Mesh/TreeUtils.pyx":43 + /* "SimPEG\Mesh\TreeUtils.pyx":43 * return (idx << levelBits) + level * * def point(int dimension, int bits, int levelBits, long idx): # <<<<<<<<<<<<<< @@ -1772,7 +1746,7 @@ PyMODINIT_FUNC PyInit_TreeUtils(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_point, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Mesh/TreeUtils.pyx":1 + /* "SimPEG\Mesh\TreeUtils.pyx":1 * # from __future__ import division # <<<<<<<<<<<<<< * # import numpy as np * # cimport numpy as np @@ -2190,7 +2164,7 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co return count; } while (start < end) { - mid = (start + end) / 2; + mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { @@ -2343,29 +2317,33 @@ bad: Py_XDECREF(py_frame); } -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ - { \ - func_type value = func_value; \ - if (sizeof(target_type) < sizeof(func_type)) { \ - if (unlikely(value != (func_type) (target_type) value)) { \ - func_type zero = 0; \ - if (is_unsigned && unlikely(value < zero)) \ - goto raise_neg_overflow; \ - else \ - goto raise_overflow; \ - } \ - } \ - return (target_type) value; \ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ } -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" - #endif #endif static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) -1, const_zero = 0; + const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -2382,13 +2360,39 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, ((PyLongObject*)x)->ob_digit[0]); + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; } - #endif #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { @@ -2404,24 +2408,77 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { } #endif if (sizeof(long) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, PyLong_AsUnsignedLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } } else { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +(((PyLongObject*)x)->ob_digit[0])); - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; } - #endif #endif if (sizeof(long) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT(long, long, PyLong_AsLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) } } { @@ -2470,7 +2527,7 @@ raise_neg_overflow: } static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) -1, const_zero = 0; + const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -2487,13 +2544,39 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, ((PyLongObject*)x)->ob_digit[0]); + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; } - #endif #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { @@ -2509,24 +2592,77 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { } #endif if (sizeof(int) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, PyLong_AsUnsignedLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } } else { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +(((PyLongObject*)x)->ob_digit[0])); - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; } - #endif #endif if (sizeof(int) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT(int, long, PyLong_AsLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) } } { @@ -2591,7 +2727,7 @@ static CYTHON_INLINE long __Pyx_pow_long(long b, long e) { #endif t = 1; while (likely(e)) { - t *= (b * (e&1)) | ((~e)&1); /* 1 or b */ + t *= (b * (e&1)) | ((~e)&1); b *= b; e >>= 1; } @@ -2599,7 +2735,7 @@ static CYTHON_INLINE long __Pyx_pow_long(long b, long e) { } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) -1, const_zero = 0; + const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { @@ -2625,7 +2761,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) -1, const_zero = 0; + const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { @@ -2703,7 +2839,7 @@ static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && @@ -2744,7 +2880,7 @@ static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_ #endif } else #endif -#if !CYTHON_COMPILING_IN_PYPY +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -2774,7 +2910,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { #else if (PyLong_Check(x)) #endif - return Py_INCREF(x), x; + return __Pyx_NewRef(x); m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { @@ -2814,18 +2950,55 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) - return PyInt_AS_LONG(b); + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } #endif if (likely(PyLong_CheckExact(b))) { - #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS - switch (Py_SIZE(b)) { - case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; - case 0: return 0; - case 1: return ((PyLongObject*)b)->ob_digit[0]; - } - #endif + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } #endif return PyLong_AsSsize_t(b); } diff --git a/SimPEG/Problem.py b/SimPEG/Problem.py index f24b57de..cd8a4aaa 100644 --- a/SimPEG/Problem.py +++ b/SimPEG/Problem.py @@ -213,5 +213,20 @@ class BaseTimeProblem(BaseProblem): if hasattr(self, '_timeMesh'): del self._timeMesh +class LinearProblem(BaseProblem): + surveyPair = Survey.LinearSurvey + + def __init__(self, mesh, G, **kwargs): + BaseProblem.__init__(self, mesh, **kwargs) + self.G = G + + def fields(self, m): + 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) diff --git a/SimPEG/Regularization.py b/SimPEG/Regularization.py index 677fba5c..5b41b91b 100644 --- a/SimPEG/Regularization.py +++ b/SimPEG/Regularization.py @@ -282,3 +282,243 @@ class Tikhonov(BaseRegularization): out = mD.T * ( self.W.T * r ) return out +# <<<<<<< HEAD + +# class Simple(BaseRegularization): +# """ +# Only for tensor mesh +# """ + +# smoothModel = True #: SMOOTH and SMOOTH_MOD_DIF options +# alpha_s = Utils.dependentProperty('_alpha_s', 1.0, ['_W', '_Ws'], "Smallness weight") +# alpha_x = Utils.dependentProperty('_alpha_x', 1.0, ['_W', '_Wx'], "Weight for the first derivative in the x direction") +# alpha_y = Utils.dependentProperty('_alpha_y', 1.0, ['_W', '_Wy'], "Weight for the first derivative in the y direction") +# alpha_z = Utils.dependentProperty('_alpha_z', 1.0, ['_W', '_Wz'], "Weight for the first derivative in the z direction") +# alpha_xx = Utils.dependentProperty('_alpha_xx', 0.0, ['_W', '_Wxx'], "Weight for the second derivative in the x direction") +# alpha_yy = Utils.dependentProperty('_alpha_yy', 0.0, ['_W', '_Wyy'], "Weight for the second derivative in the y direction") +# alpha_zz = Utils.dependentProperty('_alpha_zz', 0.0, ['_W', '_Wzz'], "Weight for the second derivative in the z direction") + +# def __init__(self, mesh, mapping=None, **kwargs): +# BaseRegularization.__init__(self, mesh, mapping=mapping, **kwargs) + + + +# @property +# def Ws(self): +# """Regularization matrix Ws""" +# if getattr(self,'_Ws', None) is None: +# self._Ws = Utils.sdiag((self.mesh.vol*self.alpha_s)**0.5) +# return self._Ws + +# @property +# def Wx(self): +# """Regularization matrix Wx""" +# if getattr(self, '_Wx', None) is None: +# self._Wx = Utils.sdiag((self.mesh.vol*self.alpha_x)**0.5)*self.mesh.unitCellGradx +# return self._Wx + +# @property +# def Wy(self): +# """Regularization matrix Wy""" +# if getattr(self, '_Wy', None) is None: +# self._Wy = Utils.sdiag((self.mesh.vol*self.alpha_y)**0.5)*self.mesh.unitCellGrady +# return self._Wy + +# @property +# def Wz(self): +# """Regularization matrix Wz""" +# if getattr(self, '_Wz', None) is None: +# self._Wz = Utils.sdiag((self.mesh.vol*self.alpha_z)**0.5)*self.mesh.unitCellGradz +# return self._Wz + +# @property +# def Wxx(self): +# """Regularization matrix Wxx""" +# if getattr(self, '_Wxx', None) is None: +# self._Wxx = Utils.sdiag((self.mesh.vol*self.alpha_xx)**0.5)*self.mesh.faceDivx*self.mesh.cellGradx +# return self._Wxx + +# @property +# def Wyy(self): +# """Regularization matrix Wyy""" +# if getattr(self, '_Wyy', None) is None: +# self._Wyy = Utils.sdiag((self.mesh.vol*self.alpha_yy)**0.5)*self.mesh.faceDivy*self.mesh.cellGrady +# return self._Wyy + +# @property +# def Wzz(self): +# """Regularization matrix Wzz""" +# if getattr(self, '_Wzz', None) is None: +# self._Wzz = Utils.sdiag((self.mesh.vol*self.alpha_zz)**0.5)*self.mesh.faceDivz*self.mesh.cellGradz +# return self._Wzz + +# @property +# def Wsmooth(self): +# """Full smoothness regularization matrix W""" +# if getattr(self, '_Wsmooth', None) is None: +# wlist = (self.Wx, self.Wxx) +# if self.mesh.dim > 1: +# wlist += (self.Wy, self.Wyy) +# if self.mesh.dim > 2: +# wlist += (self.Wz, self.Wzz) +# self._Wsmooth = sp.vstack(wlist) +# return self._Wsmooth + +# @property +# def W(self): +# """Full regularization matrix W""" +# if getattr(self, '_W', None) is None: +# wlist = (self.Ws, self.Wsmooth) +# self._W = sp.vstack(wlist) +# return self._W + +# @Utils.timeIt +# def eval(self, m): +# if self.smoothModel == True: +# r1 = self.Wsmooth * ( self.mapping * (m) ) +# r2 = self.Ws * ( self.mapping * (m - self.mref) ) +# return 0.5*(r1.dot(r1)+r2.dot(r2)) +# elif self.smoothModel == False: +# r = self.W * ( self.mapping * (m - self.mref) ) +# 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})} + +# """ +# if self.smoothModel == True: +# mD1 = self.mapping.deriv(m) +# mD2 = self.mapping.deriv(m - self.mref) +# r1 = self.Wsmooth * ( self.mapping * (m)) +# r2 = self.Ws * ( self.mapping * (m - self.mref) ) +# out1 = mD1.T * ( self.Wsmooth.T * r1 ) +# out2 = mD2.T * ( self.Ws.T * r2 ) +# out = out1+out2 +# elif self.smoothModel == False: +# mD = self.mapping.deriv(m - self.mref) +# r = self.W * ( self.mapping * (m - self.mref) ) +# out = mD.T * ( self.W.T * r ) +# return out + +# class SparseRegularization(Simple): + +# eps = 1e-1 + +# m = None +# gamma = 1. +# p = 0. +# qx = 2. +# qy = 2. +# qz = 2. + +# def __init__(self, mesh, mapping=None, **kwargs): +# Simple.__init__(self, mesh, mapping=mapping, **kwargs) + + +# @property +# def Wsmooth(self): +# """Full smoothness regularization matrix W""" +# if getattr(self, '_Wsmooth', None) is None: +# wlist = (self.Wx, self.Wxx) +# if self.mesh.dim > 1: +# wlist += (self.Wy, self.Wyy) +# if self.mesh.dim > 2: +# wlist += (self.Wz, self.Wzz) +# self._Wsmooth = sp.vstack(wlist) +# return self._Wsmooth + +# @property +# def W(self): +# """Full regularization matrix W""" +# if getattr(self, '_W', None) is None: +# wlist = (self.Ws, self.Wsmooth) +# self._W = sp.vstack(wlist) +# return self._W + +# @property +# def Ws(self): +# """Regularization matrix Ws""" +# if getattr(self, 'm', None) is None: +# self.Rs = Utils.speye(self.mesh.nC) + +# else: +# f_m = self.m +# self.rs = self.R(f_m , self.p, self.eps) +# #print "Min rs: " + str(np.max(self.rs)) + "Max rs: " + str(np.min(self.rs)) +# self.Rs = Utils.sdiag( self.rs ) + +# self._Ws = Utils.sdiag((self.mesh.vol*self.alpha_s*self.gamma)**0.5)*self.Rs + +# return self._Ws + +# @property +# def Wx(self): +# """Regularization matrix Wx""" + +# if getattr(self, 'm', None) is None: +# self.Rx = Utils.speye(self.mesh.unitCellGradx.shape[0]) + +# else: +# f_m = self.mesh.unitCellGradx * self.m +# self.rx = self.R( f_m , self.qx, self.eps) +# self.Rx = Utils.sdiag( self.rx ) + +# if getattr(self, '_Wx', None) is None: +# self._Wx = Utils.sdiag((self.mesh.vol*self.alpha_x*self.gamma)**0.5)*self.Rx*self.mesh.unitCellGradx +# return self._Wx + +# @property +# def Wy(self): +# """Regularization matrix Wy""" + +# if getattr(self, 'm', None) is None: +# self.Ry = Utils.speye(self.mesh.unitCellGrady.shape[0]) + +# else: +# f_m = self.mesh.unitCellGrady * self.m +# self.ry = self.R( f_m , self.qy, self.eps) +# self.Ry = Utils.sdiag( self.ry ) + +# if getattr(self, '_Wy', None) is None: +# self._Wy = Utils.sdiag((self.mesh.vol*self.alpha_y*self.gamma)**0.5)*self.Ry*self.mesh.unitCellGrady +# return self._Wy + +# @property +# def Wz(self): +# """Regularization matrix Wz""" + +# if getattr(self, 'm', None) is None: +# self.Rz = Utils.speye(self.mesh.unitCellGradz.shape[0]) + +# else: +# f_m = self.mesh.unitCellGradz * self.m +# self.rz = self.R( f_m , self.qz, self.eps) +# self.Rz = Utils.sdiag( self.rz ) + +# if getattr(self, '_Wz', None) is None: +# self._Wz = Utils.sdiag((self.mesh.vol*self.alpha_z*self.gamma)**0.5)*self.Rz*self.mesh.unitCellGradz +# return self._Wz + + +# def R(self, f_m , p, dec): + +# eta = (self.eps**(1-p/2.))**0.5 +# r = eta / (f_m**2.+self.eps**2.)**((1-p/2.)/2.) + +# return r +# ======= +# >>>>>>> 834de582844e8e1eac95819fbe03eed55dbeb001 diff --git a/SimPEG/Survey.py b/SimPEG/Survey.py index 47a88ae2..37024028 100644 --- a/SimPEG/Survey.py +++ b/SimPEG/Survey.py @@ -1,6 +1,5 @@ import Utils, numpy as np, scipy.sparse as sp, uuid - class BaseRx(object): """SimPEG Receiver Object""" @@ -35,7 +34,7 @@ class BaseRx(object): """Number of data in the receiver.""" return self.locs.shape[0] - def getP(self, mesh): + def getP(self, mesh, projGLoc=None): """ Returns the projection matrices as a list for all components collected by @@ -48,7 +47,10 @@ class BaseRx(object): if mesh in self._Ps: return self._Ps[mesh] - P = mesh.getInterpolationMat(self.locs, self.projGLoc) + if projGLoc is None: + projGLoc = self.projGLoc + + P = mesh.getInterpolationMat(self.locs, projGLoc) if self.storeProjections: self._Ps[mesh] = P return P @@ -307,12 +309,12 @@ class BaseSurvey(object): 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. @@ -320,11 +322,11 @@ class BaseSurvey(object): 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. @@ -332,7 +334,7 @@ class BaseSurvey(object): \\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): @@ -375,3 +377,11 @@ class BaseSurvey(object): self.dobs = self.dtrue+noise self.std = self.dobs*0 + std return self.dobs + +class LinearSurvey(BaseSurvey): + def eval(self, u): + return u + + @property + def nD(self): + return self.prob.G.shape[0] diff --git a/SimPEG/Utils/ModelBuilder.py b/SimPEG/Utils/ModelBuilder.py index 52d13820..435856f7 100644 --- a/SimPEG/Utils/ModelBuilder.py +++ b/SimPEG/Utils/ModelBuilder.py @@ -118,6 +118,44 @@ def defineElipse(ccMesh, center=[0,0,0], anisotropy=[1,1,1], slope=10., theta=0. D = np.sqrt(np.sum(G**2,axis=1)) return -np.arctan((D-1)*slope)*(2./np.pi)/2.+0.5 +def getIndicesSphere(center,radius,ccMesh): + """ + Creates a vector containing the sphere indices in the cell centers mesh. + Returns a tuple + + The sphere is defined by the points + + p0, describe the position of the center of the cell + + r, describe the radius of the sphere. + + ccMesh represents the cell-centered mesh + + The points p0 must live in the the same dimensional space as the mesh. + + """ + + # Validation: mesh and point (p0) live in the same dimensional space + dimMesh = np.size(ccMesh[0,:]) + assert len(center) == dimMesh, "Dimension mismatch. len(p0) != dimMesh" + + if dimMesh == 1: + # Define the reference points + + ind = np.abs(center[0] - ccMesh[:,0]) < radius + + elif dimMesh == 2: + # Define the reference points + + ind = np.sqrt( ( center[0] - ccMesh[:,0] )**2 + ( center[1] - ccMesh[:,1] )**2 ) < radius + + elif dimMesh == 3: + # Define the points + ind = np.sqrt( ( center[0] - ccMesh[:,0] )**2 + ( center[1] - ccMesh[:,1] )**2 + ( center[2] - ccMesh[:,2] )**2 ) < radius + + # Return a tuple + return ind + def defineTwoLayers(ccMesh,depth,vals=[0,1]): """ Define a two layered model. Depth of the first layer must be specified. diff --git a/SimPEG/Utils/interputils_cython.c b/SimPEG/Utils/interputils_cython.c index d03d682c..dea33581 100644 --- a/SimPEG/Utils/interputils_cython.c +++ b/SimPEG/Utils/interputils_cython.c @@ -1,4 +1,4 @@ -/* Generated by Cython 0.22.1 */ +/* Generated by Cython 0.23.4 */ /* BEGIN: Cython Metadata { @@ -9,25 +9,13 @@ END: Cython Metadata */ #define PY_SSIZE_T_CLEAN -#ifndef CYTHON_USE_PYLONG_INTERNALS -#ifdef PYLONG_BITS_IN_DIGIT -#define CYTHON_USE_PYLONG_INTERNALS 0 -#else -#include "pyconfig.h" -#ifdef PYLONG_BITS_IN_DIGIT -#define CYTHON_USE_PYLONG_INTERNALS 1 -#else -#define CYTHON_USE_PYLONG_INTERNALS 0 -#endif -#endif -#endif #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else -#define CYTHON_ABI "0_22_1" +#define CYTHON_ABI "0_23_4" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) @@ -62,6 +50,9 @@ END: Cython Metadata */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif @@ -69,12 +60,12 @@ END: Cython Metadata */ #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif @@ -92,7 +83,7 @@ END: Cython Metadata */ #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) @@ -111,12 +102,10 @@ END: Cython Metadata */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) - #define __Pyx_PyFrozenSet_Size(s) PyObject_Size(s) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) - #define __Pyx_PyFrozenSet_Size(s) PySet_Size(s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) @@ -184,16 +173,18 @@ END: Cython Metadata */ #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif -#ifndef CYTHON_INLINE - #if defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) @@ -206,35 +197,33 @@ END: Cython Metadata */ #define CYTHON_RESTRICT #endif #endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { - /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and - a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is - a quiet NaN. */ float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif -#define __Pyx_void_to_None(void_result) (void_result, Py_INCREF(Py_None), Py_None) -#ifdef __cplusplus -template -void __Pyx_call_destructor(T* x) { - x->~T(); -} -template -class __Pyx_FakeReference { - public: - __Pyx_FakeReference() : ptr(NULL) { } - __Pyx_FakeReference(T& ref) : ptr(&ref) { } - T *operator->() { return ptr; } - operator T&() { return *ptr; } - private: - T *ptr; -}; -#endif #if PY_MAJOR_VERSION >= 3 @@ -253,10 +242,6 @@ class __Pyx_FakeReference { #endif #endif -#if defined(WIN32) || defined(MS_WINDOWS) -#define _USE_MATH_DEFINES -#endif -#include #define __PYX_HAVE__SimPEG__Utils__interputils_cython #define __PYX_HAVE_API__SimPEG__Utils__interputils_cython #include "string.h" @@ -300,16 +285,34 @@ typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ - (sizeof(type) < sizeof(Py_ssize_t)) || \ - (sizeof(type) > sizeof(Py_ssize_t) && \ - likely(v < (type)PY_SSIZE_T_MAX || \ - v == (type)PY_SSIZE_T_MAX) && \ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ - v == (type)PY_SSIZE_T_MIN))) || \ - (sizeof(type) == sizeof(Py_ssize_t) && \ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) @@ -344,8 +347,9 @@ static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) -#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); @@ -474,7 +478,7 @@ static const char *__pyx_filename; static const char *__pyx_f[] = { - "SimPEG/Utils/interputils_cython.pyx", + "SimPEG\\Utils\\interputils_cython.pyx", "__init__.pxd", "type.pxd", }; @@ -514,7 +518,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":725 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -523,7 +527,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":726 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -532,7 +536,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":727 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -541,7 +545,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":729 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":728 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -550,7 +554,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":732 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -559,7 +563,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":733 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -568,7 +572,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":734 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -577,7 +581,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":736 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":735 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -586,7 +590,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":739 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -595,7 +599,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":741 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":740 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -604,7 +608,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":749 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -613,7 +617,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":750 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -622,7 +626,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":752 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":751 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -631,7 +635,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":753 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -640,7 +644,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":754 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -649,7 +653,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":756 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":755 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -658,7 +662,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":757 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -667,7 +671,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":759 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":758 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -676,7 +680,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":760 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -685,7 +689,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":761 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -694,7 +698,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":763 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":762 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -725,7 +729,7 @@ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /*--- Type declarations ---*/ -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":764 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -734,7 +738,7 @@ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":765 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -743,7 +747,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":767 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":766 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -752,7 +756,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":769 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":768 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -778,19 +782,19 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil) \ - if (acquire_gil) { \ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ - PyGILState_Release(__pyx_gilstate_save); \ - } else { \ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else - #define __Pyx_RefNannySetupContext(name, acquire_gil) \ + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif - #define __Pyx_RefNannyFinishContext() \ + #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) @@ -813,13 +817,13 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif -#define __Pyx_XDECREF_SET(r, v) do { \ - PyObject *tmp = (PyObject *) r; \ - r = v; __Pyx_XDECREF(tmp); \ +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ } while (0) -#define __Pyx_DECREF_SET(r, v) do { \ - PyObject *tmp = (PyObject *) r; \ - r = v; __Pyx_DECREF(tmp); \ +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) @@ -846,8 +850,8 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, @@ -874,10 +878,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); @@ -916,6 +916,8 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + typedef struct { int code_line; PyCodeObject* code_object; @@ -958,8 +960,6 @@ typedef struct { static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); @@ -1062,6 +1062,8 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do #endif #endif +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); @@ -1085,19 +1087,21 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ -/* Module declarations from 'cpython.ref' */ - /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ -/* Module declarations from 'cpython.object' */ - /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + /* Module declarations from 'libc.stdlib' */ /* Module declarations from 'numpy' */ @@ -1119,12 +1123,6 @@ int __pyx_module_is_main_SimPEG__Utils__interputils_cython = 0; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; -static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_x, float __pyx_v_xr_i); /* proto */ -static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_locs, PyArrayObject *__pyx_v_x); /* proto */ -static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_locs, PyArrayObject *__pyx_v_x, PyArrayObject *__pyx_v_y); /* proto */ -static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_locs, PyArrayObject *__pyx_v_x, PyArrayObject *__pyx_v_y, PyArrayObject *__pyx_v_z); /* proto */ -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static char __pyx_k_B[] = "B"; static char __pyx_k_H[] = "H"; static char __pyx_k_I[] = "I"; @@ -1183,19 +1181,19 @@ static char __pyx_k_interpmat3D[] = "_interpmat3D"; static char __pyx_k_RuntimeError[] = "RuntimeError"; static char __pyx_k_interp_point_1D[] = "_interp_point_1D"; static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_C_Users_tastic_Documents_SimPEG[] = "C:\\Users\\tastic\\Documents\\SimPEG\\SimPEG\\Utils\\interputils_cython.pyx"; static char __pyx_k_SimPEG_Utils_interputils_cython[] = "SimPEG.Utils.interputils_cython"; -static char __pyx_k_Users_rowan_git_simpeg_simpeg_S[] = "/Users/rowan/git/simpeg/simpeg/SimPEG/Utils/interputils_cython.pyx"; static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_s_C_Users_tastic_Documents_SimPEG; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_SimPEG_Utils_interputils_cython; -static PyObject *__pyx_kp_s_Users_rowan_git_simpeg_simpeg_S; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_argmin; static PyObject *__pyx_n_s_hx; @@ -1239,6 +1237,12 @@ static PyObject *__pyx_n_s_xSize; static PyObject *__pyx_n_s_xr_i; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_z; +static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_x, float __pyx_v_xr_i); /* proto */ +static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_locs, PyArrayObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_locs, PyArrayObject *__pyx_v_x, PyArrayObject *__pyx_v_y); /* proto */ +static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_locs, PyArrayObject *__pyx_v_x, PyArrayObject *__pyx_v_y, PyArrayObject *__pyx_v_z); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_float_0_5; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; @@ -1255,7 +1259,7 @@ static PyObject *__pyx_codeobj__10; static PyObject *__pyx_codeobj__12; static PyObject *__pyx_codeobj__14; -/* "SimPEG/Utils/interputils_cython.pyx":6 +/* "SimPEG\Utils\interputils_cython.pyx":6 * # from libcpp.vector cimport vector * * def _interp_point_1D(np.ndarray[np.float64_t, ndim=1] x, float xr_i): # <<<<<<<<<<<<<< @@ -1349,16 +1353,18 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; - int __pyx_t_7; + Py_ssize_t __pyx_t_7; int __pyx_t_8; - int __pyx_t_9; + Py_ssize_t __pyx_t_9; long __pyx_t_10; int __pyx_t_11; int __pyx_t_12; long __pyx_t_13; - int __pyx_t_14; - __pyx_t_5numpy_float64_t __pyx_t_15; - int __pyx_t_16; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + __pyx_t_5numpy_float64_t __pyx_t_17; + Py_ssize_t __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -1373,7 +1379,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "SimPEG/Utils/interputils_cython.pyx":17 + /* "SimPEG\Utils\interputils_cython.pyx":17 * # TODO: This fails if the point is on the outside of the mesh. * # We may want to replace this by extrapolation? * cdef int im = np.argmin(abs(x-xr_i)) # <<<<<<<<<<<<<< @@ -1423,7 +1429,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_im = __pyx_t_6; - /* "SimPEG/Utils/interputils_cython.pyx":18 + /* "SimPEG\Utils\interputils_cython.pyx":18 * # We may want to replace this by extrapolation? * cdef int im = np.argmin(abs(x-xr_i)) * cdef int ind_x1 = 0 # <<<<<<<<<<<<<< @@ -1432,7 +1438,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_ind_x1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":19 + /* "SimPEG\Utils\interputils_cython.pyx":19 * cdef int im = np.argmin(abs(x-xr_i)) * cdef int ind_x1 = 0 * cdef int ind_x2 = 0 # <<<<<<<<<<<<<< @@ -1441,7 +1447,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_ind_x2 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":20 + /* "SimPEG\Utils\interputils_cython.pyx":20 * cdef int ind_x1 = 0 * cdef int ind_x2 = 0 * cdef int xSize = x.shape[0]-1 # <<<<<<<<<<<<<< @@ -1450,7 +1456,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_xSize = ((__pyx_v_x->dimensions[0]) - 1); - /* "SimPEG/Utils/interputils_cython.pyx":21 + /* "SimPEG\Utils\interputils_cython.pyx":21 * cdef int ind_x2 = 0 * cdef int xSize = x.shape[0]-1 * cdef float wx1 = 0.0 # <<<<<<<<<<<<<< @@ -1459,7 +1465,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_wx1 = 0.0; - /* "SimPEG/Utils/interputils_cython.pyx":22 + /* "SimPEG\Utils\interputils_cython.pyx":22 * cdef int xSize = x.shape[0]-1 * cdef float wx1 = 0.0 * cdef float wx2 = 0.0 # <<<<<<<<<<<<<< @@ -1468,7 +1474,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_wx2 = 0.0; - /* "SimPEG/Utils/interputils_cython.pyx":23 + /* "SimPEG\Utils\interputils_cython.pyx":23 * cdef float wx1 = 0.0 * cdef float wx2 = 0.0 * cdef float hx = 0.0 # <<<<<<<<<<<<<< @@ -1477,27 +1483,27 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_hx = 0.0; - /* "SimPEG/Utils/interputils_cython.pyx":25 + /* "SimPEG\Utils\interputils_cython.pyx":25 * cdef float hx = 0.0 * * if xr_i - x[im] >= 0: # Point on the left # <<<<<<<<<<<<<< * ind_x1 = im * ind_x2 = im+1 */ - __pyx_t_6 = __pyx_v_im; - __pyx_t_7 = -1; - if (__pyx_t_6 < 0) { - __pyx_t_6 += __pyx_pybuffernd_x.diminfo[0].shape; - if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0; - } else if (unlikely(__pyx_t_6 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_7 = 0; - if (unlikely(__pyx_t_7 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_7); + __pyx_t_7 = __pyx_v_im; + __pyx_t_6 = -1; + if (__pyx_t_7 < 0) { + __pyx_t_7 += __pyx_pybuffernd_x.diminfo[0].shape; + if (unlikely(__pyx_t_7 < 0)) __pyx_t_6 = 0; + } else if (unlikely(__pyx_t_7 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_6 = 0; + if (unlikely(__pyx_t_6 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_6); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 25; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_8 = (((__pyx_v_xr_i - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_6, __pyx_pybuffernd_x.diminfo[0].strides))) >= 0.0) != 0); + __pyx_t_8 = (((__pyx_v_xr_i - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_x.diminfo[0].strides))) >= 0.0) != 0); if (__pyx_t_8) { - /* "SimPEG/Utils/interputils_cython.pyx":26 + /* "SimPEG\Utils\interputils_cython.pyx":26 * * if xr_i - x[im] >= 0: # Point on the left * ind_x1 = im # <<<<<<<<<<<<<< @@ -1506,7 +1512,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_ind_x1 = __pyx_v_im; - /* "SimPEG/Utils/interputils_cython.pyx":27 + /* "SimPEG\Utils\interputils_cython.pyx":27 * if xr_i - x[im] >= 0: # Point on the left * ind_x1 = im * ind_x2 = im+1 # <<<<<<<<<<<<<< @@ -1514,30 +1520,38 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C * ind_x1 = im-1 */ __pyx_v_ind_x2 = (__pyx_v_im + 1); + + /* "SimPEG\Utils\interputils_cython.pyx":25 + * cdef float hx = 0.0 + * + * if xr_i - x[im] >= 0: # Point on the left # <<<<<<<<<<<<<< + * ind_x1 = im + * ind_x2 = im+1 + */ goto __pyx_L3; } - /* "SimPEG/Utils/interputils_cython.pyx":28 + /* "SimPEG\Utils\interputils_cython.pyx":28 * ind_x1 = im * ind_x2 = im+1 * elif xr_i - x[im] < 0: # Point on the right # <<<<<<<<<<<<<< * ind_x1 = im-1 * ind_x2 = im */ - __pyx_t_7 = __pyx_v_im; - __pyx_t_9 = -1; - if (__pyx_t_7 < 0) { - __pyx_t_7 += __pyx_pybuffernd_x.diminfo[0].shape; - if (unlikely(__pyx_t_7 < 0)) __pyx_t_9 = 0; - } else if (unlikely(__pyx_t_7 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_9 = 0; - if (unlikely(__pyx_t_9 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_9); + __pyx_t_9 = __pyx_v_im; + __pyx_t_6 = -1; + if (__pyx_t_9 < 0) { + __pyx_t_9 += __pyx_pybuffernd_x.diminfo[0].shape; + if (unlikely(__pyx_t_9 < 0)) __pyx_t_6 = 0; + } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_6 = 0; + if (unlikely(__pyx_t_6 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_6); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_8 = (((__pyx_v_xr_i - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_x.diminfo[0].strides))) < 0.0) != 0); + __pyx_t_8 = (((__pyx_v_xr_i - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_x.diminfo[0].strides))) < 0.0) != 0); if (__pyx_t_8) { - /* "SimPEG/Utils/interputils_cython.pyx":29 + /* "SimPEG\Utils\interputils_cython.pyx":29 * ind_x2 = im+1 * elif xr_i - x[im] < 0: # Point on the right * ind_x1 = im-1 # <<<<<<<<<<<<<< @@ -1546,7 +1560,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C */ __pyx_v_ind_x1 = (__pyx_v_im - 1); - /* "SimPEG/Utils/interputils_cython.pyx":30 + /* "SimPEG\Utils\interputils_cython.pyx":30 * elif xr_i - x[im] < 0: # Point on the right * ind_x1 = im-1 * ind_x2 = im # <<<<<<<<<<<<<< @@ -1554,11 +1568,18 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C * ind_x2 = max(min(ind_x2, xSize), 0) */ __pyx_v_ind_x2 = __pyx_v_im; - goto __pyx_L3; + + /* "SimPEG\Utils\interputils_cython.pyx":28 + * ind_x1 = im + * ind_x2 = im+1 + * elif xr_i - x[im] < 0: # Point on the right # <<<<<<<<<<<<<< + * ind_x1 = im-1 + * ind_x2 = im + */ } __pyx_L3:; - /* "SimPEG/Utils/interputils_cython.pyx":31 + /* "SimPEG\Utils\interputils_cython.pyx":31 * ind_x1 = im-1 * ind_x2 = im * ind_x1 = max(min(ind_x1, xSize), 0) # <<<<<<<<<<<<<< @@ -1566,22 +1587,22 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C * */ __pyx_t_10 = 0; - __pyx_t_9 = __pyx_v_xSize; + __pyx_t_6 = __pyx_v_xSize; __pyx_t_11 = __pyx_v_ind_x1; - if (((__pyx_t_9 < __pyx_t_11) != 0)) { - __pyx_t_12 = __pyx_t_9; + if (((__pyx_t_6 < __pyx_t_11) != 0)) { + __pyx_t_12 = __pyx_t_6; } else { __pyx_t_12 = __pyx_t_11; } - __pyx_t_9 = __pyx_t_12; - if (((__pyx_t_10 > __pyx_t_9) != 0)) { + __pyx_t_6 = __pyx_t_12; + if (((__pyx_t_10 > __pyx_t_6) != 0)) { __pyx_t_13 = __pyx_t_10; } else { - __pyx_t_13 = __pyx_t_9; + __pyx_t_13 = __pyx_t_6; } __pyx_v_ind_x1 = __pyx_t_13; - /* "SimPEG/Utils/interputils_cython.pyx":32 + /* "SimPEG\Utils\interputils_cython.pyx":32 * ind_x2 = im * ind_x1 = max(min(ind_x1, xSize), 0) * ind_x2 = max(min(ind_x2, xSize), 0) # <<<<<<<<<<<<<< @@ -1589,22 +1610,22 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C * if ind_x1 == ind_x2: */ __pyx_t_13 = 0; - __pyx_t_9 = __pyx_v_xSize; + __pyx_t_6 = __pyx_v_xSize; __pyx_t_12 = __pyx_v_ind_x2; - if (((__pyx_t_9 < __pyx_t_12) != 0)) { - __pyx_t_11 = __pyx_t_9; + if (((__pyx_t_6 < __pyx_t_12) != 0)) { + __pyx_t_11 = __pyx_t_6; } else { __pyx_t_11 = __pyx_t_12; } - __pyx_t_9 = __pyx_t_11; - if (((__pyx_t_13 > __pyx_t_9) != 0)) { + __pyx_t_6 = __pyx_t_11; + if (((__pyx_t_13 > __pyx_t_6) != 0)) { __pyx_t_10 = __pyx_t_13; } else { - __pyx_t_10 = __pyx_t_9; + __pyx_t_10 = __pyx_t_6; } __pyx_v_ind_x2 = __pyx_t_10; - /* "SimPEG/Utils/interputils_cython.pyx":34 + /* "SimPEG\Utils\interputils_cython.pyx":34 * ind_x2 = max(min(ind_x2, xSize), 0) * * if ind_x1 == ind_x2: # <<<<<<<<<<<<<< @@ -1614,7 +1635,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C __pyx_t_8 = ((__pyx_v_ind_x1 == __pyx_v_ind_x2) != 0); if (__pyx_t_8) { - /* "SimPEG/Utils/interputils_cython.pyx":35 + /* "SimPEG\Utils\interputils_cython.pyx":35 * * if ind_x1 == ind_x2: * return ind_x1, ind_x1, 0.5, 0.5 # <<<<<<<<<<<<<< @@ -1643,98 +1664,94 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; + + /* "SimPEG\Utils\interputils_cython.pyx":34 + * ind_x2 = max(min(ind_x2, xSize), 0) + * + * if ind_x1 == ind_x2: # <<<<<<<<<<<<<< + * return ind_x1, ind_x1, 0.5, 0.5 + * + */ } - /* "SimPEG/Utils/interputils_cython.pyx":37 + /* "SimPEG\Utils\interputils_cython.pyx":37 * return ind_x1, ind_x1, 0.5, 0.5 * * hx = x[ind_x2] - x[ind_x1] # <<<<<<<<<<<<<< * wx1 = 1 - (xr_i - x[ind_x1])/hx * wx2 = 1 - (x[ind_x2] - xr_i)/hx */ - __pyx_t_9 = __pyx_v_ind_x2; - __pyx_t_11 = -1; - if (__pyx_t_9 < 0) { - __pyx_t_9 += __pyx_pybuffernd_x.diminfo[0].shape; - if (unlikely(__pyx_t_9 < 0)) __pyx_t_11 = 0; - } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_11 = 0; - if (unlikely(__pyx_t_11 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_11); + __pyx_t_14 = __pyx_v_ind_x2; + __pyx_t_6 = -1; + if (__pyx_t_14 < 0) { + __pyx_t_14 += __pyx_pybuffernd_x.diminfo[0].shape; + if (unlikely(__pyx_t_14 < 0)) __pyx_t_6 = 0; + } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_6 = 0; + if (unlikely(__pyx_t_6 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_6); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_11 = __pyx_v_ind_x1; - __pyx_t_12 = -1; - if (__pyx_t_11 < 0) { - __pyx_t_11 += __pyx_pybuffernd_x.diminfo[0].shape; - if (unlikely(__pyx_t_11 < 0)) __pyx_t_12 = 0; - } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_12 = 0; - if (unlikely(__pyx_t_12 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_12); + __pyx_t_15 = __pyx_v_ind_x1; + __pyx_t_6 = -1; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_x.diminfo[0].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_6 = 0; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_6 = 0; + if (unlikely(__pyx_t_6 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_6); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_v_hx = ((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_x.diminfo[0].strides))); + __pyx_v_hx = ((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_x.diminfo[0].strides))); - /* "SimPEG/Utils/interputils_cython.pyx":38 + /* "SimPEG\Utils\interputils_cython.pyx":38 * * hx = x[ind_x2] - x[ind_x1] * wx1 = 1 - (xr_i - x[ind_x1])/hx # <<<<<<<<<<<<<< * wx2 = 1 - (x[ind_x2] - xr_i)/hx * */ - __pyx_t_12 = __pyx_v_ind_x1; - __pyx_t_14 = -1; - if (__pyx_t_12 < 0) { - __pyx_t_12 += __pyx_pybuffernd_x.diminfo[0].shape; - if (unlikely(__pyx_t_12 < 0)) __pyx_t_14 = 0; - } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_14 = 0; - if (unlikely(__pyx_t_14 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_14); + __pyx_t_16 = __pyx_v_ind_x1; + __pyx_t_6 = -1; + if (__pyx_t_16 < 0) { + __pyx_t_16 += __pyx_pybuffernd_x.diminfo[0].shape; + if (unlikely(__pyx_t_16 < 0)) __pyx_t_6 = 0; + } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_6 = 0; + if (unlikely(__pyx_t_6 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_6); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_15 = (__pyx_v_xr_i - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_x.diminfo[0].strides))); + __pyx_t_17 = (__pyx_v_xr_i - (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_x.diminfo[0].strides))); if (unlikely(__pyx_v_hx == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_v_wx1 = (1.0 - (__pyx_t_15 / __pyx_v_hx)); + __pyx_v_wx1 = (1.0 - (__pyx_t_17 / __pyx_v_hx)); - /* "SimPEG/Utils/interputils_cython.pyx":39 + /* "SimPEG\Utils\interputils_cython.pyx":39 * hx = x[ind_x2] - x[ind_x1] * wx1 = 1 - (xr_i - x[ind_x1])/hx * wx2 = 1 - (x[ind_x2] - xr_i)/hx # <<<<<<<<<<<<<< * * return ind_x1, ind_x2, wx1, wx2 */ - __pyx_t_14 = __pyx_v_ind_x2; - __pyx_t_16 = -1; - if (__pyx_t_14 < 0) { - __pyx_t_14 += __pyx_pybuffernd_x.diminfo[0].shape; - if (unlikely(__pyx_t_14 < 0)) __pyx_t_16 = 0; - } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_16 = 0; - if (unlikely(__pyx_t_16 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_16); + __pyx_t_18 = __pyx_v_ind_x2; + __pyx_t_6 = -1; + if (__pyx_t_18 < 0) { + __pyx_t_18 += __pyx_pybuffernd_x.diminfo[0].shape; + if (unlikely(__pyx_t_18 < 0)) __pyx_t_6 = 0; + } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_6 = 0; + if (unlikely(__pyx_t_6 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_6); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_15 = ((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_x.diminfo[0].strides)) - __pyx_v_xr_i); + __pyx_t_17 = ((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_x.diminfo[0].strides)) - __pyx_v_xr_i); if (unlikely(__pyx_v_hx == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); - #endif PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - #ifdef WITH_THREAD - PyGILState_Release(__pyx_gilstate_save); - #endif {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_v_wx2 = (1.0 - (__pyx_t_15 / __pyx_v_hx)); + __pyx_v_wx2 = (1.0 - (__pyx_t_17 / __pyx_v_hx)); - /* "SimPEG/Utils/interputils_cython.pyx":41 + /* "SimPEG\Utils\interputils_cython.pyx":41 * wx2 = 1 - (x[ind_x2] - xr_i)/hx * * return ind_x1, ind_x2, wx1, wx2 # <<<<<<<<<<<<<< @@ -1768,7 +1785,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C __pyx_t_4 = 0; goto __pyx_L0; - /* "SimPEG/Utils/interputils_cython.pyx":6 + /* "SimPEG\Utils\interputils_cython.pyx":6 * # from libcpp.vector cimport vector * * def _interp_point_1D(np.ndarray[np.float64_t, ndim=1] x, float xr_i): # <<<<<<<<<<<<<< @@ -1798,7 +1815,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython__interp_point_1D(C return __pyx_r; } -/* "SimPEG/Utils/interputils_cython.pyx":44 +/* "SimPEG\Utils\interputils_cython.pyx":44 * * * def _interpmat1D(np.ndarray[np.float64_t, ndim=1] locs, # <<<<<<<<<<<<<< @@ -1895,7 +1912,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; - int __pyx_t_5; + Py_ssize_t __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; @@ -1926,7 +1943,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "SimPEG/Utils/interputils_cython.pyx":47 + /* "SimPEG\Utils\interputils_cython.pyx":47 * np.ndarray[np.float64_t, ndim=1] x): * """Use interpmat with only x component provided.""" * cdef int nx = x.size # <<<<<<<<<<<<<< @@ -1939,7 +1956,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_nx = __pyx_t_2; - /* "SimPEG/Utils/interputils_cython.pyx":48 + /* "SimPEG\Utils\interputils_cython.pyx":48 * """Use interpmat with only x component provided.""" * cdef int nx = x.size * cdef int npts = locs.shape[0] # <<<<<<<<<<<<<< @@ -1948,7 +1965,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH */ __pyx_v_npts = (__pyx_v_locs->dimensions[0]); - /* "SimPEG/Utils/interputils_cython.pyx":50 + /* "SimPEG\Utils\interputils_cython.pyx":50 * cdef int npts = locs.shape[0] * * inds, vals = [], [] # <<<<<<<<<<<<<< @@ -1964,7 +1981,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH __pyx_v_vals = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":52 + /* "SimPEG\Utils\interputils_cython.pyx":52 * inds, vals = [], [] * * for i in range(npts): # <<<<<<<<<<<<<< @@ -1975,7 +1992,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_2; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "SimPEG/Utils/interputils_cython.pyx":53 + /* "SimPEG\Utils\interputils_cython.pyx":53 * * for i in range(npts): * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i]) # <<<<<<<<<<<<<< @@ -2095,7 +2112,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH __Pyx_XDECREF_SET(__pyx_v_wx2, __pyx_t_8); __pyx_t_8 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":54 + /* "SimPEG\Utils\interputils_cython.pyx":54 * for i in range(npts): * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i]) * inds += [ind_x1, ind_x2] # <<<<<<<<<<<<<< @@ -2116,7 +2133,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH __Pyx_DECREF_SET(__pyx_v_inds, ((PyObject*)__pyx_t_8)); __pyx_t_8 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":55 + /* "SimPEG\Utils\interputils_cython.pyx":55 * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i]) * inds += [ind_x1, ind_x2] * vals += [wx1,wx2] # <<<<<<<<<<<<<< @@ -2138,7 +2155,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH __pyx_t_3 = 0; } - /* "SimPEG/Utils/interputils_cython.pyx":57 + /* "SimPEG\Utils\interputils_cython.pyx":57 * vals += [wx1,wx2] * * return inds, vals # <<<<<<<<<<<<<< @@ -2158,7 +2175,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH __pyx_t_3 = 0; goto __pyx_L0; - /* "SimPEG/Utils/interputils_cython.pyx":44 + /* "SimPEG\Utils\interputils_cython.pyx":44 * * * def _interpmat1D(np.ndarray[np.float64_t, ndim=1] locs, # <<<<<<<<<<<<<< @@ -2197,7 +2214,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_2_interpmat1D(CYTH return __pyx_r; } -/* "SimPEG/Utils/interputils_cython.pyx":60 +/* "SimPEG\Utils\interputils_cython.pyx":60 * * * def _interpmat2D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -2311,8 +2328,8 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; - int __pyx_t_5; - long __pyx_t_6; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; @@ -2320,8 +2337,8 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *(*__pyx_t_13)(PyObject *); - long __pyx_t_14; - int __pyx_t_15; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -2354,7 +2371,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH } __pyx_pybuffernd_y.diminfo[0].strides = __pyx_pybuffernd_y.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y.diminfo[0].shape = __pyx_pybuffernd_y.rcbuffer->pybuffer.shape[0]; - /* "SimPEG/Utils/interputils_cython.pyx":64 + /* "SimPEG\Utils\interputils_cython.pyx":64 * np.ndarray[np.float64_t, ndim=1] y): * """Use interpmat with only x and y components provided.""" * cdef int nx = x.size # <<<<<<<<<<<<<< @@ -2367,7 +2384,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_nx = __pyx_t_2; - /* "SimPEG/Utils/interputils_cython.pyx":65 + /* "SimPEG\Utils\interputils_cython.pyx":65 * """Use interpmat with only x and y components provided.""" * cdef int nx = x.size * cdef int ny = y.size # <<<<<<<<<<<<<< @@ -2380,7 +2397,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ny = __pyx_t_2; - /* "SimPEG/Utils/interputils_cython.pyx":66 + /* "SimPEG\Utils\interputils_cython.pyx":66 * cdef int nx = x.size * cdef int ny = y.size * cdef int npts = locs.shape[0] # <<<<<<<<<<<<<< @@ -2389,7 +2406,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH */ __pyx_v_npts = (__pyx_v_locs->dimensions[0]); - /* "SimPEG/Utils/interputils_cython.pyx":68 + /* "SimPEG\Utils\interputils_cython.pyx":68 * cdef int npts = locs.shape[0] * * inds, vals = [], [] # <<<<<<<<<<<<<< @@ -2405,7 +2422,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __pyx_v_vals = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":70 + /* "SimPEG\Utils\interputils_cython.pyx":70 * inds, vals = [], [] * * for i in range(npts): # <<<<<<<<<<<<<< @@ -2416,7 +2433,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_2; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "SimPEG/Utils/interputils_cython.pyx":71 + /* "SimPEG\Utils\interputils_cython.pyx":71 * * for i in range(npts): * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i, 0]) # <<<<<<<<<<<<<< @@ -2541,7 +2558,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_XDECREF_SET(__pyx_v_wx2, __pyx_t_9); __pyx_t_9 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":72 + /* "SimPEG\Utils\interputils_cython.pyx":72 * for i in range(npts): * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i, 0]) * ind_y1, ind_y2, wy1, wy2 = _interp_point_1D(y, locs[i, 1]) # <<<<<<<<<<<<<< @@ -2550,22 +2567,22 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH */ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_interp_point_1D); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __pyx_v_i; - __pyx_t_14 = 1; - __pyx_t_15 = -1; - if (__pyx_t_7 < 0) { - __pyx_t_7 += __pyx_pybuffernd_locs.diminfo[0].shape; - if (unlikely(__pyx_t_7 < 0)) __pyx_t_15 = 0; - } else if (unlikely(__pyx_t_7 >= __pyx_pybuffernd_locs.diminfo[0].shape)) __pyx_t_15 = 0; + __pyx_t_14 = __pyx_v_i; + __pyx_t_15 = 1; + __pyx_t_7 = -1; if (__pyx_t_14 < 0) { - __pyx_t_14 += __pyx_pybuffernd_locs.diminfo[1].shape; - if (unlikely(__pyx_t_14 < 0)) __pyx_t_15 = 1; - } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_locs.diminfo[1].shape)) __pyx_t_15 = 1; - if (unlikely(__pyx_t_15 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_15); + __pyx_t_14 += __pyx_pybuffernd_locs.diminfo[0].shape; + if (unlikely(__pyx_t_14 < 0)) __pyx_t_7 = 0; + } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_locs.diminfo[0].shape)) __pyx_t_7 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_locs.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_7 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_locs.diminfo[1].shape)) __pyx_t_7 = 1; + if (unlikely(__pyx_t_7 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_7); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_8 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_locs.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_locs.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_locs.diminfo[1].strides))); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_8 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_locs.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_locs.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_locs.diminfo[1].strides))); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = NULL; __pyx_t_10 = 0; @@ -2666,7 +2683,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_XDECREF_SET(__pyx_v_wy2, __pyx_t_11); __pyx_t_11 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":74 + /* "SimPEG\Utils\interputils_cython.pyx":74 * ind_y1, ind_y2, wy1, wy2 = _interp_point_1D(y, locs[i, 1]) * * inds += [( ind_x1, ind_y1), # <<<<<<<<<<<<<< @@ -2682,7 +2699,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_GIVEREF(__pyx_v_ind_y1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_ind_y1); - /* "SimPEG/Utils/interputils_cython.pyx":75 + /* "SimPEG\Utils\interputils_cython.pyx":75 * * inds += [( ind_x1, ind_y1), * ( ind_x1, ind_y2), # <<<<<<<<<<<<<< @@ -2698,7 +2715,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_GIVEREF(__pyx_v_ind_y2); PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_v_ind_y2); - /* "SimPEG/Utils/interputils_cython.pyx":76 + /* "SimPEG\Utils\interputils_cython.pyx":76 * inds += [( ind_x1, ind_y1), * ( ind_x1, ind_y2), * ( ind_x2, ind_y1), # <<<<<<<<<<<<<< @@ -2714,7 +2731,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_GIVEREF(__pyx_v_ind_y1); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_ind_y1); - /* "SimPEG/Utils/interputils_cython.pyx":77 + /* "SimPEG\Utils\interputils_cython.pyx":77 * ( ind_x1, ind_y2), * ( ind_x2, ind_y1), * ( ind_x2, ind_y2)] # <<<<<<<<<<<<<< @@ -2730,7 +2747,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_GIVEREF(__pyx_v_ind_y2); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ind_y2); - /* "SimPEG/Utils/interputils_cython.pyx":74 + /* "SimPEG\Utils\interputils_cython.pyx":74 * ind_y1, ind_y2, wy1, wy2 = _interp_point_1D(y, locs[i, 1]) * * inds += [( ind_x1, ind_y1), # <<<<<<<<<<<<<< @@ -2757,7 +2774,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __Pyx_DECREF_SET(__pyx_v_inds, ((PyObject*)__pyx_t_1)); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":79 + /* "SimPEG\Utils\interputils_cython.pyx":79 * ( ind_x2, ind_y2)] * * vals += [wx1*wy1, wx1*wy2, wx2*wy1, wx2*wy2] # <<<<<<<<<<<<<< @@ -2793,7 +2810,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __pyx_t_11 = 0; } - /* "SimPEG/Utils/interputils_cython.pyx":81 + /* "SimPEG\Utils\interputils_cython.pyx":81 * vals += [wx1*wy1, wx1*wy2, wx2*wy1, wx2*wy2] * * return inds, vals # <<<<<<<<<<<<<< @@ -2813,7 +2830,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH __pyx_t_11 = 0; goto __pyx_L0; - /* "SimPEG/Utils/interputils_cython.pyx":60 + /* "SimPEG\Utils\interputils_cython.pyx":60 * * * def _interpmat2D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -2858,7 +2875,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_4_interpmat2D(CYTH return __pyx_r; } -/* "SimPEG/Utils/interputils_cython.pyx":84 +/* "SimPEG\Utils\interputils_cython.pyx":84 * * * def _interpmat3D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -2989,8 +3006,8 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; - int __pyx_t_5; - long __pyx_t_6; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; @@ -2998,10 +3015,10 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *(*__pyx_t_13)(PyObject *); - long __pyx_t_14; - int __pyx_t_15; - long __pyx_t_16; - int __pyx_t_17; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; @@ -3046,7 +3063,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH } __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; - /* "SimPEG/Utils/interputils_cython.pyx":89 + /* "SimPEG\Utils\interputils_cython.pyx":89 * np.ndarray[np.float64_t, ndim=1] z): * """Use interpmat.""" * cdef int nx = x.size # <<<<<<<<<<<<<< @@ -3059,7 +3076,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_nx = __pyx_t_2; - /* "SimPEG/Utils/interputils_cython.pyx":90 + /* "SimPEG\Utils\interputils_cython.pyx":90 * """Use interpmat.""" * cdef int nx = x.size * cdef int ny = y.size # <<<<<<<<<<<<<< @@ -3072,7 +3089,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ny = __pyx_t_2; - /* "SimPEG/Utils/interputils_cython.pyx":91 + /* "SimPEG\Utils\interputils_cython.pyx":91 * cdef int nx = x.size * cdef int ny = y.size * cdef int nz = z.size # <<<<<<<<<<<<<< @@ -3085,7 +3102,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_nz = __pyx_t_2; - /* "SimPEG/Utils/interputils_cython.pyx":92 + /* "SimPEG\Utils\interputils_cython.pyx":92 * cdef int ny = y.size * cdef int nz = z.size * cdef int npts = locs.shape[0] # <<<<<<<<<<<<<< @@ -3094,7 +3111,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH */ __pyx_v_npts = (__pyx_v_locs->dimensions[0]); - /* "SimPEG/Utils/interputils_cython.pyx":94 + /* "SimPEG\Utils\interputils_cython.pyx":94 * cdef int npts = locs.shape[0] * * inds, vals = [], [] # <<<<<<<<<<<<<< @@ -3110,7 +3127,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __pyx_v_vals = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":96 + /* "SimPEG\Utils\interputils_cython.pyx":96 * inds, vals = [], [] * * for i in range(npts): # <<<<<<<<<<<<<< @@ -3121,7 +3138,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_2; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "SimPEG/Utils/interputils_cython.pyx":97 + /* "SimPEG\Utils\interputils_cython.pyx":97 * * for i in range(npts): * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i, 0]) # <<<<<<<<<<<<<< @@ -3246,7 +3263,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_XDECREF_SET(__pyx_v_wx2, __pyx_t_9); __pyx_t_9 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":98 + /* "SimPEG\Utils\interputils_cython.pyx":98 * for i in range(npts): * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i, 0]) * ind_y1, ind_y2, wy1, wy2 = _interp_point_1D(y, locs[i, 1]) # <<<<<<<<<<<<<< @@ -3255,22 +3272,22 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH */ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_interp_point_1D); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); - __pyx_t_7 = __pyx_v_i; - __pyx_t_14 = 1; - __pyx_t_15 = -1; - if (__pyx_t_7 < 0) { - __pyx_t_7 += __pyx_pybuffernd_locs.diminfo[0].shape; - if (unlikely(__pyx_t_7 < 0)) __pyx_t_15 = 0; - } else if (unlikely(__pyx_t_7 >= __pyx_pybuffernd_locs.diminfo[0].shape)) __pyx_t_15 = 0; + __pyx_t_14 = __pyx_v_i; + __pyx_t_15 = 1; + __pyx_t_7 = -1; if (__pyx_t_14 < 0) { - __pyx_t_14 += __pyx_pybuffernd_locs.diminfo[1].shape; - if (unlikely(__pyx_t_14 < 0)) __pyx_t_15 = 1; - } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_locs.diminfo[1].shape)) __pyx_t_15 = 1; - if (unlikely(__pyx_t_15 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_15); + __pyx_t_14 += __pyx_pybuffernd_locs.diminfo[0].shape; + if (unlikely(__pyx_t_14 < 0)) __pyx_t_7 = 0; + } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_locs.diminfo[0].shape)) __pyx_t_7 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_locs.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_7 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_locs.diminfo[1].shape)) __pyx_t_7 = 1; + if (unlikely(__pyx_t_7 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_7); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_8 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_locs.rcbuffer->pybuffer.buf, __pyx_t_7, __pyx_pybuffernd_locs.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_locs.diminfo[1].strides))); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_8 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_locs.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_locs.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_locs.diminfo[1].strides))); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = NULL; __pyx_t_10 = 0; @@ -3371,7 +3388,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_XDECREF_SET(__pyx_v_wy2, __pyx_t_11); __pyx_t_11 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":99 + /* "SimPEG\Utils\interputils_cython.pyx":99 * ind_x1, ind_x2, wx1, wx2 = _interp_point_1D(x, locs[i, 0]) * ind_y1, ind_y2, wy1, wy2 = _interp_point_1D(y, locs[i, 1]) * ind_z1, ind_z2, wz1, wz2 = _interp_point_1D(z, locs[i, 2]) # <<<<<<<<<<<<<< @@ -3380,22 +3397,22 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH */ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_interp_point_1D); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_11); - __pyx_t_15 = __pyx_v_i; - __pyx_t_16 = 2; - __pyx_t_17 = -1; - if (__pyx_t_15 < 0) { - __pyx_t_15 += __pyx_pybuffernd_locs.diminfo[0].shape; - if (unlikely(__pyx_t_15 < 0)) __pyx_t_17 = 0; - } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_locs.diminfo[0].shape)) __pyx_t_17 = 0; + __pyx_t_16 = __pyx_v_i; + __pyx_t_17 = 2; + __pyx_t_7 = -1; if (__pyx_t_16 < 0) { - __pyx_t_16 += __pyx_pybuffernd_locs.diminfo[1].shape; - if (unlikely(__pyx_t_16 < 0)) __pyx_t_17 = 1; - } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_locs.diminfo[1].shape)) __pyx_t_17 = 1; - if (unlikely(__pyx_t_17 != -1)) { - __Pyx_RaiseBufferIndexError(__pyx_t_17); + __pyx_t_16 += __pyx_pybuffernd_locs.diminfo[0].shape; + if (unlikely(__pyx_t_16 < 0)) __pyx_t_7 = 0; + } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_locs.diminfo[0].shape)) __pyx_t_7 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_locs.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_7 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_locs.diminfo[1].shape)) __pyx_t_7 = 1; + if (unlikely(__pyx_t_7 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_7); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_8 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_locs.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_locs.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_locs.diminfo[1].strides))); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_8 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_locs.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_locs.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_locs.diminfo[1].strides))); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = NULL; __pyx_t_10 = 0; @@ -3496,7 +3513,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_XDECREF_SET(__pyx_v_wz2, __pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":101 + /* "SimPEG\Utils\interputils_cython.pyx":101 * ind_z1, ind_z2, wz1, wz2 = _interp_point_1D(z, locs[i, 2]) * * inds += [( ind_x1, ind_y1, ind_z1), # <<<<<<<<<<<<<< @@ -3515,7 +3532,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z1); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_ind_z1); - /* "SimPEG/Utils/interputils_cython.pyx":102 + /* "SimPEG\Utils\interputils_cython.pyx":102 * * inds += [( ind_x1, ind_y1, ind_z1), * ( ind_x1, ind_y2, ind_z1), # <<<<<<<<<<<<<< @@ -3534,7 +3551,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z1); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_ind_z1); - /* "SimPEG/Utils/interputils_cython.pyx":103 + /* "SimPEG\Utils\interputils_cython.pyx":103 * inds += [( ind_x1, ind_y1, ind_z1), * ( ind_x1, ind_y2, ind_z1), * ( ind_x2, ind_y1, ind_z1), # <<<<<<<<<<<<<< @@ -3553,7 +3570,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z1); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_v_ind_z1); - /* "SimPEG/Utils/interputils_cython.pyx":104 + /* "SimPEG\Utils\interputils_cython.pyx":104 * ( ind_x1, ind_y2, ind_z1), * ( ind_x2, ind_y1, ind_z1), * ( ind_x2, ind_y2, ind_z1), # <<<<<<<<<<<<<< @@ -3572,7 +3589,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z1); PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_v_ind_z1); - /* "SimPEG/Utils/interputils_cython.pyx":105 + /* "SimPEG\Utils\interputils_cython.pyx":105 * ( ind_x2, ind_y1, ind_z1), * ( ind_x2, ind_y2, ind_z1), * ( ind_x1, ind_y1, ind_z2), # <<<<<<<<<<<<<< @@ -3591,7 +3608,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z2); PyTuple_SET_ITEM(__pyx_t_11, 2, __pyx_v_ind_z2); - /* "SimPEG/Utils/interputils_cython.pyx":106 + /* "SimPEG\Utils\interputils_cython.pyx":106 * ( ind_x2, ind_y2, ind_z1), * ( ind_x1, ind_y1, ind_z2), * ( ind_x1, ind_y2, ind_z2), # <<<<<<<<<<<<<< @@ -3610,7 +3627,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z2); PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_v_ind_z2); - /* "SimPEG/Utils/interputils_cython.pyx":107 + /* "SimPEG\Utils\interputils_cython.pyx":107 * ( ind_x1, ind_y1, ind_z2), * ( ind_x1, ind_y2, ind_z2), * ( ind_x2, ind_y1, ind_z2), # <<<<<<<<<<<<<< @@ -3629,7 +3646,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z2); PyTuple_SET_ITEM(__pyx_t_18, 2, __pyx_v_ind_z2); - /* "SimPEG/Utils/interputils_cython.pyx":108 + /* "SimPEG\Utils\interputils_cython.pyx":108 * ( ind_x1, ind_y2, ind_z2), * ( ind_x2, ind_y1, ind_z2), * ( ind_x2, ind_y2, ind_z2)] # <<<<<<<<<<<<<< @@ -3648,7 +3665,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GIVEREF(__pyx_v_ind_z2); PyTuple_SET_ITEM(__pyx_t_19, 2, __pyx_v_ind_z2); - /* "SimPEG/Utils/interputils_cython.pyx":101 + /* "SimPEG\Utils\interputils_cython.pyx":101 * ind_z1, ind_z2, wz1, wz2 = _interp_point_1D(z, locs[i, 2]) * * inds += [( ind_x1, ind_y1, ind_z1), # <<<<<<<<<<<<<< @@ -3687,7 +3704,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_DECREF_SET(__pyx_v_inds, ((PyObject*)__pyx_t_19)); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":110 + /* "SimPEG\Utils\interputils_cython.pyx":110 * ( ind_x2, ind_y2, ind_z2)] * * vals += [wx1*wy1*wz1, # <<<<<<<<<<<<<< @@ -3700,7 +3717,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_20); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":111 + /* "SimPEG\Utils\interputils_cython.pyx":111 * * vals += [wx1*wy1*wz1, * wx1*wy2*wz1, # <<<<<<<<<<<<<< @@ -3713,7 +3730,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_18); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":112 + /* "SimPEG\Utils\interputils_cython.pyx":112 * vals += [wx1*wy1*wz1, * wx1*wy2*wz1, * wx2*wy1*wz1, # <<<<<<<<<<<<<< @@ -3726,7 +3743,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":113 + /* "SimPEG\Utils\interputils_cython.pyx":113 * wx1*wy2*wz1, * wx2*wy1*wz1, * wx2*wy2*wz1, # <<<<<<<<<<<<<< @@ -3739,7 +3756,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":114 + /* "SimPEG\Utils\interputils_cython.pyx":114 * wx2*wy1*wz1, * wx2*wy2*wz1, * wx1*wy1*wz2, # <<<<<<<<<<<<<< @@ -3752,7 +3769,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":115 + /* "SimPEG\Utils\interputils_cython.pyx":115 * wx2*wy2*wz1, * wx1*wy1*wz2, * wx1*wy2*wz2, # <<<<<<<<<<<<<< @@ -3765,7 +3782,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":116 + /* "SimPEG\Utils\interputils_cython.pyx":116 * wx1*wy1*wz2, * wx1*wy2*wz2, * wx2*wy1*wz2, # <<<<<<<<<<<<<< @@ -3778,7 +3795,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":117 + /* "SimPEG\Utils\interputils_cython.pyx":117 * wx1*wy2*wz2, * wx2*wy1*wz2, * wx2*wy2*wz2] # <<<<<<<<<<<<<< @@ -3791,7 +3808,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":110 + /* "SimPEG\Utils\interputils_cython.pyx":110 * ( ind_x2, ind_y2, ind_z2)] * * vals += [wx1*wy1*wz1, # <<<<<<<<<<<<<< @@ -3831,7 +3848,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __pyx_t_3 = 0; } - /* "SimPEG/Utils/interputils_cython.pyx":119 + /* "SimPEG\Utils\interputils_cython.pyx":119 * wx2*wy2*wz2] * * return inds, vals # <<<<<<<<<<<<<< @@ -3849,7 +3866,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH __pyx_t_3 = 0; goto __pyx_L0; - /* "SimPEG/Utils/interputils_cython.pyx":84 + /* "SimPEG\Utils\interputils_cython.pyx":84 * * * def _interpmat3D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -3903,7 +3920,7 @@ static PyObject *__pyx_pf_6SimPEG_5Utils_18interputils_cython_6_interpmat3D(CYTH return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":197 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< @@ -3953,7 +3970,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __Pyx_GIVEREF(__pyx_v_info->obj); } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":203 * # of flags * * if info == NULL: return # <<<<<<<<<<<<<< @@ -3966,7 +3983,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L0; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":206 * * cdef int copy_shape, i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< @@ -3975,7 +3992,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_endian_detector = 1; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":207 * cdef int copy_shape, i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< @@ -3984,7 +4001,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":209 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< @@ -3993,7 +4010,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":211 * ndim = PyArray_NDIM(self) * * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< @@ -4003,7 +4020,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":212 * * if sizeof(npy_intp) != sizeof(Py_ssize_t): * copy_shape = 1 # <<<<<<<<<<<<<< @@ -4011,22 +4028,30 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P * copy_shape = 0 */ __pyx_v_copy_shape = 1; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ goto __pyx_L4; } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":214 * copy_shape = 1 * else: * copy_shape = 0 # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ + /*else*/ { __pyx_v_copy_shape = 0; } __pyx_L4:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":216 * copy_shape = 0 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -4040,7 +4065,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L6_bool_binop_done; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":217 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< @@ -4050,9 +4075,17 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L6_bool_binop_done:; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":218 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< @@ -4064,9 +4097,17 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":220 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< @@ -4080,7 +4121,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P goto __pyx_L9_bool_binop_done; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":221 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< @@ -4090,9 +4131,17 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L9_bool_binop_done:; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":222 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< @@ -4104,9 +4153,17 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":224 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< @@ -4115,7 +4172,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":225 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< @@ -4124,7 +4181,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->ndim = __pyx_v_ndim; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":226 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if copy_shape: # <<<<<<<<<<<<<< @@ -4134,7 +4191,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = (__pyx_v_copy_shape != 0); if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":229 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< @@ -4143,7 +4200,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":230 * # This is allocated as one block, strides first. * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< @@ -4152,7 +4209,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":231 * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< @@ -4163,7 +4220,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":232 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< @@ -4172,7 +4229,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":233 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< @@ -4181,20 +4238,28 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ goto __pyx_L11; } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":235 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ + /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":236 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< @@ -4205,7 +4270,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P } __pyx_L11:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":237 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< @@ -4214,7 +4279,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->suboffsets = NULL; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":238 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< @@ -4223,7 +4288,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":239 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< @@ -4232,28 +4297,28 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":242 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = self.descr - * cdef list stack + * cdef int offset */ __pyx_v_f = NULL; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":243 * cdef int t * cdef char* f = NULL * cdef dtype descr = self.descr # <<<<<<<<<<<<<< - * cdef list stack * cdef int offset + * */ __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":247 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":246 * cdef int offset * * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< @@ -4262,7 +4327,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":249 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":248 * cdef bint hasfields = PyDataType_HASFIELDS(descr) * * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< @@ -4280,7 +4345,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_L15_bool_binop_done:; if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":251 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":250 * if not hasfields and not copy_shape: * # do not call releasebuffer * info.obj = None # <<<<<<<<<<<<<< @@ -4292,17 +4357,25 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = Py_None; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ goto __pyx_L14; } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":254 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":253 * else: * # need to call releasebuffer * info.obj = self # <<<<<<<<<<<<<< * * if not hasfields: */ + /*else*/ { __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); @@ -4311,7 +4384,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P } __pyx_L14:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":255 * info.obj = self * * if not hasfields: # <<<<<<<<<<<<<< @@ -4321,7 +4394,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":256 * * if not hasfields: * t = descr.type_num # <<<<<<<<<<<<<< @@ -4331,7 +4404,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":257 * if not hasfields: * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -4351,7 +4424,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P } __pyx_L20_next_or:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":258 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< @@ -4367,43 +4440,51 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L19_bool_binop_done:; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":259 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":277 - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - switch (__pyx_v_t) { - - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":260 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ + switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = __pyx_k_b; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":261 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< @@ -4414,7 +4495,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_B; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":262 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< @@ -4425,7 +4506,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_h; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":263 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< @@ -4436,7 +4517,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_H; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":264 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< @@ -4447,7 +4528,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_i; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":265 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< @@ -4458,7 +4539,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_I; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":266 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< @@ -4469,7 +4550,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_l; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":267 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< @@ -4480,7 +4561,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_L; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":268 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< @@ -4491,7 +4572,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_q; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":269 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< @@ -4502,7 +4583,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_Q; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":270 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< @@ -4513,7 +4594,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_f; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":271 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< @@ -4524,7 +4605,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_d; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":272 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< @@ -4535,7 +4616,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_g; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":273 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< @@ -4546,7 +4627,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_Zf; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":274 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< @@ -4557,7 +4638,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_Zd; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":275 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< @@ -4568,7 +4649,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P __pyx_v_f = __pyx_k_Zg; break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":277 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":276 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< @@ -4580,33 +4661,33 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P break; default: - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":278 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 279; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 279; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 279; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 279; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 279; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} break; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":279 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< @@ -4615,7 +4696,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_info->format = __pyx_v_f; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":281 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":280 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< @@ -4624,19 +4705,27 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_r = 0; goto __pyx_L0; - } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":282 * return * else: * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ - __pyx_v_info->format = ((char *)malloc(255)); + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":283 * else: * info.format = stdlib.malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< @@ -4645,7 +4734,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ (__pyx_v_info->format[0]) = '^'; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":284 * info.format = stdlib.malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< @@ -4654,17 +4743,17 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P */ __pyx_v_offset = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":285 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ - __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 255), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_f = __pyx_t_7; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":288 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< @@ -4674,7 +4763,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P (__pyx_v_f[0]) = '\x00'; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":197 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< @@ -4706,7 +4795,7 @@ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, P return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":290 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< @@ -4730,7 +4819,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":291 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< @@ -4740,7 +4829,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":292 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * stdlib.free(info.format) # <<<<<<<<<<<<<< @@ -4748,11 +4837,17 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s * stdlib.free(info.strides) */ free(__pyx_v_info->format); - goto __pyx_L3; - } - __pyx_L3:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":293 * if PyArray_HASFIELDS(self): * stdlib.free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< @@ -4762,7 +4857,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":295 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":294 * stdlib.free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * stdlib.free(info.strides) # <<<<<<<<<<<<<< @@ -4770,11 +4865,17 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s * */ free(__pyx_v_info->strides); - goto __pyx_L4; - } - __pyx_L4:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":290 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< @@ -4786,7 +4887,7 @@ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_s __Pyx_RefNannyFinishContext(); } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":770 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -4803,7 +4904,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":772 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":771 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< @@ -4811,13 +4912,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 772; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":770 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -4836,7 +4937,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":773 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -4853,7 +4954,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":775 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":774 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -4861,13 +4962,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 775; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":773 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -4886,7 +4987,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":776 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -4903,7 +5004,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":777 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -4911,13 +5012,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":776 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -4936,7 +5037,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":779 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -4953,7 +5054,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":781 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":780 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -4961,13 +5062,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 781; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":779 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -4986,7 +5087,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":782 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -5003,7 +5104,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":783 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< @@ -5011,13 +5112,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 784; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":782 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -5036,7 +5137,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":785 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< @@ -5068,17 +5169,17 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_util_dtypestring", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":793 - * cdef int delta_offset - * cdef tuple i + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":790 + * + * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 - * cdef tuple i + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":791 + * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields @@ -5086,7 +5187,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":797 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":794 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< @@ -5095,21 +5196,21 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 797; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 797; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 797; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":795 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< @@ -5118,15 +5219,15 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":796 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< @@ -5143,7 +5244,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); @@ -5151,52 +5252,60 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); #endif } else { - __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":798 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 801; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (__pyx_t_6) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":799 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 802; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 802; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":801 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -5216,7 +5325,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __pyx_L8_next_or:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":802 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< @@ -5232,23 +5341,39 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ if (__pyx_t_6) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":803 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 806; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 806; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":813 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< @@ -5256,24 +5381,24 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx * f += 1 */ while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 816; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 816; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 816; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":814 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ - (__pyx_v_f[0]) = 120; + (__pyx_v_f[0]) = 0x78; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":815 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< @@ -5282,7 +5407,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_f = (__pyx_v_f + 1); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":816 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< @@ -5293,7 +5418,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":818 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< @@ -5303,7 +5428,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":820 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< @@ -5313,19 +5438,19 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":821 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 824; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":822 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< @@ -5335,357 +5460,365 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (__pyx_t_6) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":823 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":826 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ - __pyx_t_4 = PyInt_FromLong(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":827 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ - __pyx_t_3 = PyInt_FromLong(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":828 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ - __pyx_t_4 = PyInt_FromLong(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 104; + (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":829 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ - __pyx_t_3 = PyInt_FromLong(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":830 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ - __pyx_t_4 = PyInt_FromLong(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 105; + (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":831 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ - __pyx_t_3 = PyInt_FromLong(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":832 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ - __pyx_t_4 = PyInt_FromLong(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 108; + (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":833 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ - __pyx_t_3 = PyInt_FromLong(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":834 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ - __pyx_t_4 = PyInt_FromLong(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 113; + (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":835 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ - __pyx_t_3 = PyInt_FromLong(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":836 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ - __pyx_t_4 = PyInt_FromLong(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 102; + (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":837 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ - __pyx_t_3 = PyInt_FromLong(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 100; + (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":838 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ - __pyx_t_4 = PyInt_FromLong(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { - (__pyx_v_f[0]) = 103; + (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":839 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ - __pyx_t_3 = PyInt_FromLong(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 102; + (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":843 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":840 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ - __pyx_t_4 = PyInt_FromLong(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 100; + (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":841 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ - __pyx_t_3 = PyInt_FromLong(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 103; + (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":842 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ - __pyx_t_4 = PyInt_FromLong(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 845; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 845; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 845; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":844 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ - __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - {__pyx_filename = __pyx_f[1]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L15:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":845 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< @@ -5693,23 +5826,31 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ goto __pyx_L13; } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":849 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_f = __pyx_t_9; } __pyx_L13:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":797 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":794 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< @@ -5719,7 +5860,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":850 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< @@ -5729,7 +5870,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":785 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< @@ -5754,7 +5895,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx return __pyx_r; } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":966 * * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -5769,7 +5910,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a int __pyx_t_2; __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":968 * cdef inline void set_array_base(ndarray arr, object base): * cdef PyObject* baseptr * if base is None: # <<<<<<<<<<<<<< @@ -5780,7 +5921,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":969 * cdef PyObject* baseptr * if base is None: * baseptr = NULL # <<<<<<<<<<<<<< @@ -5788,20 +5929,28 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * Py_INCREF(base) # important to do this before decref below! */ __pyx_v_baseptr = NULL; + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ goto __pyx_L3; } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":971 * baseptr = NULL * else: * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< * baseptr = base * Py_XDECREF(arr.base) */ + /*else*/ { Py_INCREF(__pyx_v_base); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":975 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":972 * else: * Py_INCREF(base) # important to do this before decref below! * baseptr = base # <<<<<<<<<<<<<< @@ -5812,7 +5961,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a } __pyx_L3:; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":973 * Py_INCREF(base) # important to do this before decref below! * baseptr = base * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< @@ -5821,7 +5970,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ Py_XDECREF(__pyx_v_arr->base); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":974 * baseptr = base * Py_XDECREF(arr.base) * arr.base = baseptr # <<<<<<<<<<<<<< @@ -5830,7 +5979,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ __pyx_v_arr->base = __pyx_v_baseptr; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":966 * * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -5842,7 +5991,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyFinishContext(); } -/* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":979 +/* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":976 * arr.base = baseptr * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -5856,7 +6005,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":977 * * cdef inline object get_array_base(ndarray arr): * if arr.base is NULL: # <<<<<<<<<<<<<< @@ -5866,7 +6015,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); if (__pyx_t_1) { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":981 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":978 * cdef inline object get_array_base(ndarray arr): * if arr.base is NULL: * return None # <<<<<<<<<<<<<< @@ -5877,21 +6026,29 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; - } - /*else*/ { - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":983 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":980 * return None * else: * return arr.base # <<<<<<<<<<<<<< */ + /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); __pyx_r = ((PyObject *)__pyx_v_arr->base); goto __pyx_L0; } - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":979 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":976 * arr.base = baseptr * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -5929,12 +6086,12 @@ static struct PyModuleDef __pyx_moduledef = { #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_k_C_Users_tastic_Documents_SimPEG, sizeof(__pyx_k_C_Users_tastic_Documents_SimPEG), 0, 0, 1, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_SimPEG_Utils_interputils_cython, __pyx_k_SimPEG_Utils_interputils_cython, sizeof(__pyx_k_SimPEG_Utils_interputils_cython), 0, 0, 1, 1}, - {&__pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_k_Users_rowan_git_simpeg_simpeg_S, sizeof(__pyx_k_Users_rowan_git_simpeg_simpeg_S), 0, 0, 1, 0}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_argmin, __pyx_k_argmin, sizeof(__pyx_k_argmin), 0, 0, 1, 1}, {&__pyx_n_s_hx, __pyx_k_hx, sizeof(__pyx_k_hx), 0, 0, 1, 1}, @@ -5983,7 +6140,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 802; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; @@ -5993,7 +6150,7 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":218 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< @@ -6004,7 +6161,7 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":222 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< @@ -6015,51 +6172,51 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":259 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":799 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 802; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":803 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 806; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":823 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); - /* "SimPEG/Utils/interputils_cython.pyx":6 + /* "SimPEG\Utils\interputils_cython.pyx":6 * # from libcpp.vector cimport vector * * def _interp_point_1D(np.ndarray[np.float64_t, ndim=1] x, float xr_i): # <<<<<<<<<<<<<< @@ -6069,9 +6226,9 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple__7 = PyTuple_Pack(9, __pyx_n_s_x, __pyx_n_s_xr_i, __pyx_n_s_im, __pyx_n_s_ind_x1, __pyx_n_s_ind_x2, __pyx_n_s_xSize, __pyx_n_s_wx1, __pyx_n_s_wx2, __pyx_n_s_hx); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_interp_point_1D, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_interp_point_1D, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Utils/interputils_cython.pyx":44 + /* "SimPEG\Utils\interputils_cython.pyx":44 * * * def _interpmat1D(np.ndarray[np.float64_t, ndim=1] locs, # <<<<<<<<<<<<<< @@ -6081,9 +6238,9 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple__9 = PyTuple_Pack(11, __pyx_n_s_locs, __pyx_n_s_x, __pyx_n_s_nx, __pyx_n_s_npts, __pyx_n_s_inds, __pyx_n_s_vals, __pyx_n_s_i, __pyx_n_s_ind_x1, __pyx_n_s_ind_x2, __pyx_n_s_wx1, __pyx_n_s_wx2); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); - __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_interpmat1D, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_interpmat1D, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Utils/interputils_cython.pyx":60 + /* "SimPEG\Utils\interputils_cython.pyx":60 * * * def _interpmat2D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -6093,9 +6250,9 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple__11 = PyTuple_Pack(17, __pyx_n_s_locs, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_npts, __pyx_n_s_inds, __pyx_n_s_vals, __pyx_n_s_i, __pyx_n_s_ind_x1, __pyx_n_s_ind_x2, __pyx_n_s_wx1, __pyx_n_s_wx2, __pyx_n_s_ind_y1, __pyx_n_s_ind_y2, __pyx_n_s_wy1, __pyx_n_s_wy2); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); - __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 17, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_interpmat2D, 60, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 17, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_interpmat2D, 60, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "SimPEG/Utils/interputils_cython.pyx":84 + /* "SimPEG\Utils\interputils_cython.pyx":84 * * * def _interpmat3D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -6105,7 +6262,7 @@ static int __Pyx_InitCachedConstants(void) { __pyx_tuple__13 = PyTuple_Pack(23, __pyx_n_s_locs, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_z, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_nz, __pyx_n_s_npts, __pyx_n_s_inds, __pyx_n_s_vals, __pyx_n_s_i, __pyx_n_s_ind_x1, __pyx_n_s_ind_x2, __pyx_n_s_wx1, __pyx_n_s_wx2, __pyx_n_s_ind_y1, __pyx_n_s_ind_y2, __pyx_n_s_wy1, __pyx_n_s_wy2, __pyx_n_s_ind_z1, __pyx_n_s_ind_z2, __pyx_n_s_wz1, __pyx_n_s_wz2); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(4, 0, 23, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_rowan_git_simpeg_simpeg_S, __pyx_n_s_interpmat3D, 84, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(4, 0, 23, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_C_Users_tastic_Documents_SimPEG, __pyx_n_s_interpmat3D, 84, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -6144,18 +6301,24 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_interputils_cython(void)", 0); - if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED - if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS @@ -6178,12 +6341,12 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ - if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main_SimPEG__Utils__interputils_cython) { - if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if PY_MAJOR_VERSION >= 3 { @@ -6194,9 +6357,9 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) } #endif /*--- Builtin init code ---*/ - if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ - if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ @@ -6213,12 +6376,15 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif - /* "SimPEG/Utils/interputils_cython.pyx":2 + /* "SimPEG\Utils\interputils_cython.pyx":2 * # from __future__ import division * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np @@ -6229,7 +6395,7 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":6 + /* "SimPEG\Utils\interputils_cython.pyx":6 * # from libcpp.vector cimport vector * * def _interp_point_1D(np.ndarray[np.float64_t, ndim=1] x, float xr_i): # <<<<<<<<<<<<<< @@ -6241,7 +6407,7 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_interp_point_1D, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 6; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":44 + /* "SimPEG\Utils\interputils_cython.pyx":44 * * * def _interpmat1D(np.ndarray[np.float64_t, ndim=1] locs, # <<<<<<<<<<<<<< @@ -6253,7 +6419,7 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_interpmat1D, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":60 + /* "SimPEG\Utils\interputils_cython.pyx":60 * * * def _interpmat2D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -6265,7 +6431,7 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_interpmat2D, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 60; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":84 + /* "SimPEG\Utils\interputils_cython.pyx":84 * * * def _interpmat3D(np.ndarray[np.float64_t, ndim=2] locs, # <<<<<<<<<<<<<< @@ -6277,7 +6443,7 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_interpmat3D, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "SimPEG/Utils/interputils_cython.pyx":1 + /* "SimPEG\Utils\interputils_cython.pyx":1 * # from __future__ import division # <<<<<<<<<<<<<< * import numpy as np * cimport numpy as np @@ -6287,7 +6453,7 @@ PyMODINIT_FUNC PyInit_interputils_cython(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../anaconda/lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":979 + /* "..\..\..\..\Anaconda2\lib\site-packages\Cython\Includes\numpy\__init__.pxd":976 * arr.base = baseptr * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -7141,8 +7307,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject* args = PyTuple_Pack(1, arg); - return (likely(args)) ? __Pyx_PyObject_Call(func, args, NULL) : NULL; + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; } #endif @@ -7414,13 +7584,86 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { return 0; } +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { - mid = (start + end) / 2; + mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { @@ -7594,102 +7837,33 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif - static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *empty_list = 0; - PyObject *module = 0; - PyObject *global_dict = 0; - PyObject *empty_dict = 0; - PyObject *list; - #if PY_VERSION_HEX < 0x03030000 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) - goto bad; - #endif - if (from_list) - list = from_list; - else { - empty_list = PyList_New(0); - if (!empty_list) - goto bad; - list = empty_list; - } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; - empty_dict = PyDict_New(); - if (!empty_dict) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.')) { - #if PY_VERSION_HEX < 0x03030000 - PyObject *py_level = PyInt_FromLong(1); - if (!py_level) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - #endif - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_VERSION_HEX < 0x03030000 - PyObject *py_level = PyInt_FromLong(level); - if (!py_level) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); - #endif - } - } -bad: - #if PY_VERSION_HEX < 0x03030000 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; -} - -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ - { \ - func_type value = func_value; \ - if (sizeof(target_type) < sizeof(func_type)) { \ - if (unlikely(value != (func_type) (target_type) value)) { \ - func_type zero = 0; \ - if (is_unsigned && unlikely(value < zero)) \ - goto raise_neg_overflow; \ - else \ - goto raise_overflow; \ - } \ - } \ - return (target_type) value; \ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ } -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" - #endif #endif static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) -1, const_zero = 0; + const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -7706,13 +7880,39 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, ((PyLongObject*)x)->ob_digit[0]); + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; } - #endif #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { @@ -7728,24 +7928,77 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { } #endif if (sizeof(int) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, PyLong_AsUnsignedLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } } else { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +(((PyLongObject*)x)->ob_digit[0])); - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; } - #endif #endif if (sizeof(int) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT(int, long, PyLong_AsLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) } } { @@ -7794,7 +8047,7 @@ raise_neg_overflow: } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) -1, const_zero = 0; + const int neg_one = (int) -1, const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { @@ -8059,8 +8312,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #endif #endif +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) -1, const_zero = 0; + const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { @@ -8086,7 +8365,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { } static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) -1, const_zero = 0; + const long neg_one = (long) -1, const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -8103,13 +8382,39 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, ((PyLongObject*)x)->ob_digit[0]); + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; } - #endif #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { @@ -8125,24 +8430,77 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { } #endif if (sizeof(long) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, PyLong_AsUnsignedLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) } } else { -#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +(((PyLongObject*)x)->ob_digit[0])); - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; } - #endif #endif if (sizeof(long) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT(long, long, PyLong_AsLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) } } { @@ -8324,7 +8682,7 @@ static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && @@ -8365,7 +8723,7 @@ static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_ #endif } else #endif -#if !CYTHON_COMPILING_IN_PYPY +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -8395,7 +8753,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { #else if (PyLong_Check(x)) #endif - return Py_INCREF(x), x; + return __Pyx_NewRef(x); m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { @@ -8435,18 +8793,55 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) - return PyInt_AS_LONG(b); + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } #endif if (likely(PyLong_CheckExact(b))) { - #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 - #if CYTHON_USE_PYLONG_INTERNALS - switch (Py_SIZE(b)) { - case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; - case 0: return 0; - case 1: return ((PyLongObject*)b)->ob_digit[0]; - } - #endif + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } #endif return PyLong_AsSsize_t(b); } diff --git a/SimPEG/__init__.py b/SimPEG/__init__.py index cc51fd1f..a1e989b6 100644 --- a/SimPEG/__init__.py +++ b/SimPEG/__init__.py @@ -15,7 +15,7 @@ import Directives import Inversion import Tests -__version__ = '0.1.9' +__version__ = '0.1.10' __author__ = 'Rowan Cockett' __license__ = 'MIT' __copyright__ = 'Copyright 2014 Rowan Cockett' diff --git a/docs/api_DC.rst b/docs/api_DC.rst new file mode 100644 index 00000000..f6c98d09 --- /dev/null +++ b/docs/api_DC.rst @@ -0,0 +1,150 @@ +.. _api_DC: + +.. math:: + + \renewcommand{\div}{\nabla\cdot\,} + \newcommand{\grad}{\vec \nabla} + \newcommand{\curl}{{\vec \nabla}\times\,} + \newcommand{\dcurl}{{\mathbf C}} + \newcommand{\dgrad}{{\mathbf G}} + \newcommand{\Acf}{{\mathbf A_c^f}} + \newcommand{\Ace}{{\mathbf A_c^e}} + \renewcommand{\S}{{\mathbf \Sigma}} + \renewcommand{\Div}{{\mathbf {Div}}} + \renewcommand{\Grad}{{\mathbf {Grad}}} + \newcommand{\St}{{\mathbf \Sigma_\tau}} + \newcommand{\diag}{\mathbf{diag}} + \newcommand{\M}{{\mathbf M}} + \newcommand{\Me}{{\M^e}} + \newcommand{\Mes}[1]{{\M^e_{#1}}} + \newcommand{\be}{\mathbf{e}} + \newcommand{\bj}{\mathbf{j}} + \newcommand{\bphi}{\mathbf{\phi}} + \newcommand{\bq}{\mathbf{q}} + \newcommand{\bJ}{\mathbf{J}} + \newcommand{\bG}{\mathbf{G}} + \newcommand{\bP}{\mathbf{P}} + \newcommand{\bA}{\mathbf{A}} + \newcommand{\bm}{\mathbf{m}} + \newcommand{\B}{\vec{B}} + \newcommand{\D}{\vec{D}} + \renewcommand{\H}{\vec{H}} + \renewcommand {\j} { {\vec j} } + \newcommand {\h} { {\vec h} } + \renewcommand {\b} { {\vec b} } + \newcommand {\e} { {\vec e} } + \newcommand {\c} { {\vec c} } + \renewcommand {\d} { {\vec d} } + \renewcommand {\u} { {\vec u} } + \newcommand{\I}{\vec{I}} + +DC resistivity survey +********************* + +Electrical resistivity of subsurface materials is measured by causing an electrical current to flow in the earth between one pair of electrodes while the voltage across a second pair of electrodes is measured. The result is an "apparent" resistivity which is a value representing the weighted average resistivity over a volume of the earth. Variations in this measurement are caused by variations in the soil, rock, and pore fluid electrical resistivity. Surveys require contact with the ground, so they can be labour intensive. Results are sometimes interpreted directly, but more commonly, 1D, 2D or 3D models are estimated using inversion procedures (`GPG `_). + + +Background +========== + +As direct current (DC) implies, in DC resistivity survey, we assume steady-state. We consider Maxwell's equations in steady state as + +.. math:: + + \curl \frac{1}{\mu} \vec{b} - \j = \j_s \\ + + \curl \e = 0 + +Then by taking \\(\\curl\\) for the first equation, we have + +.. math:: + + - \div\j = q \\ + + +where + +.. math:: + + \div \j_s = q = I(\delta(\vec{r}-\vec{r}_{s+})-\delta(\vec{r}-\vec{r}_{s-})) + +Since \\(\\curl \\e = 0\\), we have + +.. math:: + + \e = \grad \phi + +And by Ohm's law, we have + +.. math:: + + \j = \sigma \grad \phi + +Finally, we can compute the solution of the system: + +.. math:: + + - \div\j = q + + \j = \sigma \grad \phi + + \frac{\partial \phi}{\partial r}\Big|_{\partial \Omega_{BC}} = 0 + + +Discretization +============== + +By using finite volume method (FVM), we discretize our system as + +.. math:: + + -\Div \bj = \bq + + \diag(\Acf^{T}\sigma^{-1}) \bj = \Grad \bphi + +Here boundary condtions are embedded in the discrete differential operators. With some linear algebra we have + +.. math:: + + \bA\bphi = -\bq + +where + +.. math:: + + \bA = \Div (\diag(\Acf^{T}\sigma^{-1}))^{-1} \Grad + +By solving this linear equation, we can compute the solution of \\(\\phi\\). Based on this discretization, we derive sensitivity in discretized space. Sensitivity matrix can be in general can be written as + +.. math :: + + \bJ = -\bP\bA^{-1}\bG + +where + +.. math :: + + \bP: \text{Projection} + + \bJ = \bP\frac{\partial \phi}{\partial \bm} + +Here \\(\\bm\\) indicates model parameters in discretized space. + +Verification +============ + +Comparing to the analytic function: + +.. plot:: + + import simpegDC as DC + DC.Examples.Verification.run(plotIt=True) + +API +=== + +.. automodule:: simpegDC.BaseDC + :show-inheritance: + :members: + :undoc-members: + :inherited-members: diff --git a/docs/conf.py b/docs/conf.py index fee262de..45407435 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -51,9 +51,9 @@ copyright = u'2013, SimPEG Developers' # built documents. # # The short X.Y version. -version = '0.1.9' +version = '0.1.10' # The full version, including alpha/beta/rc tags. -release = '0.1.9' +release = '0.1.10' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/docs/examples/DC_Analytic_Dipole.rst b/docs/examples/DC_Analytic_Dipole.rst new file mode 100644 index 00000000..f3d06058 --- /dev/null +++ b/docs/examples/DC_Analytic_Dipole.rst @@ -0,0 +1,21 @@ +.. _examples_DC_Analytic_Dipole: + +.. --------------------------------- .. +.. .. +.. THIS FILE IS AUTO GENEREATED .. +.. .. +.. SimPEG/Examples/__init__.py .. +.. .. +.. --------------------------------- .. + +DC Analytic Dipole +================== + +.. plot:: + + from SimPEG import Examples + Examples.DC_Analytic_Dipole.run() + +.. literalinclude:: ../../SimPEG/Examples/DC_Analytic_Dipole.py + :language: python + :linenos: diff --git a/docs/examples/DC_Forward_PseudoSection.rst b/docs/examples/DC_Forward_PseudoSection.rst new file mode 100644 index 00000000..1a500cae --- /dev/null +++ b/docs/examples/DC_Forward_PseudoSection.rst @@ -0,0 +1,28 @@ +.. _examples_DC_Forward_PseudoSection: + +.. --------------------------------- .. +.. .. +.. THIS FILE IS AUTO GENEREATED .. +.. .. +.. SimPEG/Examples/__init__.py .. +.. .. +.. --------------------------------- .. + + +DC Forward Simulation +===================== + +Forward model conductive spheres in a half-space and plot a pseudo-section + +Created by @fourndo on Mon Feb 01 19:28:06 2016 + + + +.. plot:: + + from SimPEG import Examples + Examples.DC_Forward_PseudoSection.run() + +.. literalinclude:: ../../SimPEG/Examples/DC_Forward_PseudoSection.py + :language: python + :linenos: diff --git a/docs/examples/MT_1D_ForwardAndInversion.rst b/docs/examples/MT_1D_ForwardAndInversion.rst new file mode 100644 index 00000000..9646a7eb --- /dev/null +++ b/docs/examples/MT_1D_ForwardAndInversion.rst @@ -0,0 +1,27 @@ +.. _examples_MT_1D_ForwardAndInversion: + +.. --------------------------------- .. +.. .. +.. THIS FILE IS AUTO GENEREATED .. +.. .. +.. SimPEG/Examples/__init__.py .. +.. .. +.. --------------------------------- .. + + +MT: 1D: Inversion +======================= + +Forward model 1D MT data. +Setup and run a MT 1D inversion. + + + +.. plot:: + + from SimPEG import Examples + Examples.MT_1D_ForwardAndInversion.run() + +.. literalinclude:: ../../SimPEG/Examples/MT_1D_ForwardAndInversion.py + :language: python + :linenos: diff --git a/docs/examples/MT_3D_Foward.rst b/docs/examples/MT_3D_Foward.rst new file mode 100644 index 00000000..eaeead7a --- /dev/null +++ b/docs/examples/MT_3D_Foward.rst @@ -0,0 +1,26 @@ +.. _examples_MT_3D_Foward: + +.. --------------------------------- .. +.. .. +.. THIS FILE IS AUTO GENEREATED .. +.. .. +.. SimPEG/Examples/__init__.py .. +.. .. +.. --------------------------------- .. + + +MT: 3D: Forward +======================= + +Forward model 3D MT data. + + + +.. plot:: + + from SimPEG import Examples + Examples.MT_3D_Foward.run() + +.. literalinclude:: ../../SimPEG/Examples/MT_3D_Foward.py + :language: python + :linenos: diff --git a/docs/index.rst b/docs/index.rst index 485abf64..0a812ea6 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -49,9 +49,7 @@ Examples .. toctree:: :maxdepth: 2 - api_Examples - Packages ******** @@ -60,9 +58,9 @@ Packages :maxdepth: 3 em/index + mt/index flow/index - Finite Volume ************* diff --git a/docs/mt/index.rst b/docs/mt/index.rst new file mode 100644 index 00000000..692cba5d --- /dev/null +++ b/docs/mt/index.rst @@ -0,0 +1,19 @@ +Magnetotellurics +**************** + +SimPEG (Simulation and Parameter Estimation in Geophysics) is a python +package for simulation and gradient based parameter estimation in the +context of geoscience applications. + +simpegMT uses SimPEG as the framework for the forward and inverse +magnetotellurics geophysical problems. + + + +Problem +======= + +.. autoclass:: SimPEG.MT.BaseMT.BaseMTProblem + :show-inheritance: + :members: + :undoc-members: diff --git a/setup.py b/setup.py index bcb5b8e3..3383c7f7 100644 --- a/setup.py +++ b/setup.py @@ -77,7 +77,7 @@ with open("README.rst") as f: setup( name = "SimPEG", - version = "0.1.9", + version = "0.1.10", packages = find_packages(), install_requires = ['numpy>=1.7', 'scipy>=0.13', diff --git a/tests/base/test_maps.py b/tests/base/test_maps.py index 623f8715..19cd4e77 100644 --- a/tests/base/test_maps.py +++ b/tests/base/test_maps.py @@ -5,8 +5,8 @@ from scipy.sparse.linalg import dsolve TOL = 1e-14 -MAPS_TO_TEST_2D = ["CircleMap", "ComplexMap", "ExpMap", "IdentityMap", "Vertical1DMap", "Weighting", "FullMap"] -MAPS_TO_TEST_3D = [ "ComplexMap", "ExpMap", "IdentityMap", "Vertical1DMap", "Weighting", "FullMap"] +MAPS_TO_TEST_2D = ["CircleMap", "ComplexMap", "ExpMap", "IdentityMap", "SurjectVertical1D", "Weighting", "SurjectFull","FullMap","Vertical1DMap"] +MAPS_TO_TEST_3D = [ "ComplexMap", "ExpMap", "IdentityMap", "SurjectVertical1D", "Weighting", "SurjectFull","FullMap","Vertical1DMap"] class MapTests(unittest.TestCase): @@ -52,7 +52,7 @@ class MapTests(unittest.TestCase): def test_mapMultiplication(self): M = Mesh.TensorMesh([2,3]) expMap = Maps.ExpMap(M) - vertMap = Maps.Vertical1DMap(M) + vertMap = Maps.SurjectVertical1D(M) combo = expMap*vertMap m = np.arange(3.0) t_true = np.exp(np.r_[0,0,1,1,2,2.]) @@ -83,22 +83,23 @@ class MapTests(unittest.TestCase): def test_activeCells(self): M = Mesh.TensorMesh([2,4],'0C') expMap = Maps.ExpMap(M) - actMap = Maps.ActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy) - vertMap = Maps.Vertical1DMap(M) - combo = vertMap * actMap - m = np.r_[1,2.] - mod = Models.Model(m,combo) - # import matplotlib.pyplot as plt - # plt.colorbar(M.plotImage(mod.transform)[0]) - # plt.show() - self.assertLess(np.linalg.norm(mod.transform - np.r_[1,1,2,2,10,10,10,10.]), TOL) - self.assertLess((mod.transformDeriv - combo.deriv(m)).toarray().sum(), TOL) + for actMap in [Maps.InjectActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy), Maps.ActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy)]: + # actMap = Maps.InjectActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy) + vertMap = Maps.SurjectVertical1D(M) + combo = vertMap * actMap + m = np.r_[1,2.] + mod = Models.Model(m,combo) + # import matplotlib.pyplot as plt + # plt.colorbar(M.plotImage(mod.transform)[0]) + # plt.show() + self.assertLess(np.linalg.norm(mod.transform - np.r_[1,1,2,2,10,10,10,10.]), TOL) + self.assertLess((mod.transformDeriv - combo.deriv(m)).toarray().sum(), TOL) def test_tripleMultiply(self): M = Mesh.TensorMesh([2,4],'0C') expMap = Maps.ExpMap(M) - vertMap = Maps.Vertical1DMap(M) - actMap = Maps.ActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy) + vertMap = Maps.SurjectVertical1D(M) + actMap = Maps.InjectActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy) m = np.r_[1,2.] t_true = np.exp(np.r_[1,1,2,2,10,10,10,10.]) self.assertLess(np.linalg.norm((expMap * vertMap * actMap * m)-t_true,np.inf),TOL) @@ -115,29 +116,33 @@ class MapTests(unittest.TestCase): M2 = Mesh.TensorMesh([2,4]) M3 = Mesh.TensorMesh([3,2,4]) m = np.random.rand(M2.nC) - m2to3 = Maps.Map2Dto3D(M3, normal='X') - m = np.arange(m2to3.nP) - self.assertTrue(m2to3.test()) - self.assertTrue(np.all(Utils.mkvc( (m2to3 * m).reshape(M3.vnC,order='F')[0,:,:] ) == m)) + + for m2to3 in [Maps.Surject2Dto3D(M3, normal='X'), Maps.Map2Dto3D(M3, normal='X')]: + # m2to3 = Maps.Surject2Dto3D(M3, normal='X') + m = np.arange(m2to3.nP) + self.assertTrue(m2to3.test()) + self.assertTrue(np.all(Utils.mkvc( (m2to3 * m).reshape(M3.vnC,order='F')[0,:,:] ) == m)) def test_map2Dto3D_y(self): M2 = Mesh.TensorMesh([3,4]) M3 = Mesh.TensorMesh([3,2,4]) m = np.random.rand(M2.nC) - m2to3 = Maps.Map2Dto3D(M3, normal='Y') - m = np.arange(m2to3.nP) - self.assertTrue(m2to3.test()) - self.assertTrue(np.all(Utils.mkvc( (m2to3 * m).reshape(M3.vnC,order='F')[:,0,:] ) == m)) + for m2to3 in [Maps.Surject2Dto3D(M3, normal='Y'),Maps.Map2Dto3D(M3, normal='Y')]: + # m2to3 = Maps.Surject2Dto3D(M3, normal='Y') + m = np.arange(m2to3.nP) + self.assertTrue(m2to3.test()) + self.assertTrue(np.all(Utils.mkvc( (m2to3 * m).reshape(M3.vnC,order='F')[:,0,:] ) == m)) def test_map2Dto3D_z(self): M2 = Mesh.TensorMesh([3,2]) M3 = Mesh.TensorMesh([3,2,4]) m = np.random.rand(M2.nC) - m2to3 = Maps.Map2Dto3D(M3, normal='Z') - m = np.arange(m2to3.nP) - self.assertTrue(m2to3.test()) - self.assertTrue(np.all(Utils.mkvc( (m2to3 * m).reshape(M3.vnC,order='F')[:,:,0] ) == m)) + for m2to3 in [Maps.Surject2Dto3D(M3, normal='Z'),Maps.Map2Dto3D(M3, normal='Z')]: + # m2to3 = Maps.Surject2Dto3D(M3, normal='Z') + m = np.arange(m2to3.nP) + self.assertTrue(m2to3.test()) + self.assertTrue(np.all(Utils.mkvc( (m2to3 * m).reshape(M3.vnC,order='F')[:,:,0] ) == m)) if __name__ == '__main__': diff --git a/tests/dcip/__init__.py b/tests/dcip/__init__.py new file mode 100644 index 00000000..420388ef --- /dev/null +++ b/tests/dcip/__init__.py @@ -0,0 +1,12 @@ +import os +import glob +import unittest + +if __name__ == '__main__': + test_file_strings = glob.glob('test_*.py') + module_strings = [str[0:len(str)-3] for str in test_file_strings] + suites = [unittest.defaultTestLoader.loadTestsFromName(str) for str + in module_strings] + testSuite = unittest.TestSuite(suites) + + unittest.TextTestRunner(verbosity=2).run(testSuite) diff --git a/tests/dcip/test_forward_DCproblem.py b/tests/dcip/test_forward_DCproblem.py new file mode 100644 index 00000000..a2708936 --- /dev/null +++ b/tests/dcip/test_forward_DCproblem.py @@ -0,0 +1,77 @@ +import unittest +from SimPEG import * +import SimPEG.DCIP as DC + + +class DCProblemTests(unittest.TestCase): + + def setUp(self): + + aSpacing=2.5 + nElecs=10 + + surveySize = nElecs*aSpacing - aSpacing + cs = surveySize/nElecs/4 + + mesh = Mesh.TensorMesh([ + [(cs,10, -1.3),(cs,surveySize/cs),(cs,10, 1.3)], + [(cs,3, -1.3),(cs,3,1.3)], + # [(cs,5, -1.3),(cs,10)] + ],'CN') + + srcList = DC.Utils.WennerSrcList(nElecs, aSpacing, in2D=True) + survey = DC.SurveyDC(srcList) + problem = DC.ProblemDC_CC(mesh) + problem.pair(survey) + + mSynth = np.ones(mesh.nC) + survey.makeSyntheticData(mSynth) + + # Now set up the problem to do some minimization + dmis = DataMisfit.l2_DataMisfit(survey) + reg = Regularization.Tikhonov(mesh) + opt = Optimization.InexactGaussNewton(maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6) + invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=1e4) + inv = Inversion.BaseInversion(invProb) + + self.inv = inv + self.reg = reg + self.p = problem + self.mesh = mesh + self.m0 = mSynth + self.survey = survey + self.dmis = dmis + + def test_misfit(self): + derChk = lambda m: [self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)] + passed = Tests.checkDerivative(derChk, self.m0, plotIt=False) + self.assertTrue(passed) + + def test_adjoint(self): + # Adjoint Test + u = np.random.rand(self.mesh.nC*self.survey.nSrc) + v = np.random.rand(self.mesh.nC) + w = np.random.rand(self.survey.dobs.shape[0]) + wtJv = w.dot(self.p.Jvec(self.m0, v)) + vtJtw = v.dot(self.p.Jtvec(self.m0, w)) + passed = np.abs(wtJv - vtJtw) < 1e-10 + print 'Adjoint Test', np.abs(wtJv - vtJtw), passed + self.assertTrue(passed) + + def test_dataObj(self): + derChk = lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)] + passed = Tests.checkDerivative(derChk, self.m0, plotIt=False) + self.assertTrue(passed) + + + def test_massMatrices(self): + Gu = np.random.rand(self.mesh.nF) + def derChk(m): + self.p.curModel = m + return [self.p.Msig * Gu, self.p.dMdsig(Gu)] + passed = Tests.checkDerivative(derChk, self.m0, plotIt=False) + self.assertTrue(passed) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/dcip/test_forward_IPproblem.py b/tests/dcip/test_forward_IPproblem.py new file mode 100644 index 00000000..ff7b1ab6 --- /dev/null +++ b/tests/dcip/test_forward_IPproblem.py @@ -0,0 +1,65 @@ +import unittest +import SimPEG.DCIP as DC +from SimPEG import * + +class IPforwardTests(unittest.TestCase): + + def test_IPforward(self): + + cs = 12.5 + nc = 200/cs+1 + hx = [(cs,7, -1.3),(cs,nc),(cs,7, 1.3)] + hy = [(cs,7, -1.3),(cs,int(nc/2+1)),(cs,7, 1.3)] + hz = [(cs,7, -1.3),(cs,int(nc/2+1))] + mesh = Mesh.TensorMesh([hx, hy, hz], 'CCN') + sighalf = 1e-2 + sigma = np.ones(mesh.nC)*sighalf + p0 = np.r_[-50., 50., -50.] + p1 = np.r_[ 50.,-50., -150.] + blk_ind = Utils.ModelBuilder.getIndicesBlock(p0, p1, mesh.gridCC) + sigma[blk_ind] = 1e-3 + eta = np.zeros_like(sigma) + eta[blk_ind] = 0.1 + sigmaInf = sigma.copy() + sigma0 = sigma*(1-eta) + + nElecs = 11 + x_temp = np.linspace(-100, 100, nElecs) + aSpacing = x_temp[1]-x_temp[0] + y_temp = 0. + xyz = Utils.ndgrid(x_temp, np.r_[y_temp], np.r_[0.]) + srcList = DC.Utils.WennerSrcList(nElecs,aSpacing) + survey = DC.SurveyDC(srcList) + + imap = Maps.IdentityMap(mesh) + problem = DC.ProblemDC_CC(mesh, mapping=imap) + + try: + from pymatsolver import MumpsSolver + solver = MumpsSolver + except ImportError, e: + solver = SolverLU + + problem.Solver = solver + problem.pair(survey) + + phi0 = survey.dpred(sigma0) + phiInf = survey.dpred(sigmaInf) + + phiIP_true = phi0-phiInf + + surveyIP = DC.SurveyIP(srcList) + problemIP = DC.ProblemIP(mesh, sigma=sigma) + problemIP.pair(surveyIP) + + problemIP.Solver = solver + + phiIP_approx = surveyIP.dpred(eta) + + err = np.linalg.norm(phiIP_true-phiIP_approx) / np.linalg.norm(phiIP_true) + + self.assertTrue(err < 0.02) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/dcip/test_sens_IPproblem.py b/tests/dcip/test_sens_IPproblem.py new file mode 100644 index 00000000..9ba18031 --- /dev/null +++ b/tests/dcip/test_sens_IPproblem.py @@ -0,0 +1,82 @@ +import unittest +from SimPEG import * +import SimPEG.DCIP as DC + +class IPProblemTests(unittest.TestCase): + + def setUp(self): + + cs = 12.5 + nc = 500/cs+1 + hx = [(cs,0, -1.3),(cs,nc),(cs,0, 1.3)] + hy = [(cs,0, -1.3),(cs,int(nc/2+1)),(cs,0, 1.3)] + hz = [(cs,0, -1.3),(cs,int(nc/2+1))] + mesh = Mesh.TensorMesh([hx, hy, hz], 'CCN') + sighalf = 1e-2 + sigma = np.ones(mesh.nC)*sighalf + p0 = np.r_[-50., 50., -50.] + p1 = np.r_[ 50.,-50., -150.] + blk_ind = Utils.ModelBuilder.getIndicesBlock(p0, p1, mesh.gridCC) + sigma[blk_ind] = 1e-3 + eta = np.zeros_like(sigma) + eta[blk_ind] = 0.1 + + nElecs = 5 + x_temp = np.linspace(-250, 250, nElecs) + aSpacing = x_temp[1]-x_temp[0] + y_temp = 0. + xyz = Utils.ndgrid(x_temp, np.r_[y_temp], np.r_[0.]) + srcList = DC.Utils.WennerSrcList(nElecs,aSpacing) + survey = DC.SurveyIP(srcList) + imap = Maps.IdentityMap(mesh) + problem = DC.ProblemIP(mesh, sigma=sigma, mapping= imap) + problem.pair(survey) + + try: + from pymatsolver import MumpsSolver + problem.Solver = MumpsSolver + except ImportError, e: + problem.Solver = SolverLU + + mSynth = eta + survey.makeSyntheticData(mSynth) + + # Now set up the problem to do some minimization + dmis = DataMisfit.l2_DataMisfit(survey) + reg = Regularization.Tikhonov(mesh) + opt = Optimization.InexactGaussNewton(maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6) + invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=1e4) + inv = Inversion.BaseInversion(invProb) + + self.inv = inv + self.reg = reg + self.p = problem + self.mesh = mesh + self.m0 = mSynth + self.survey = survey + self.dmis = dmis + + def test_misfit(self): + derChk = lambda m: [self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)] + passed = Tests.checkDerivative(derChk, self.m0*0, plotIt=False) + self.assertTrue(passed) + + def test_adjoint(self): + # Adjoint Test + u = np.random.rand(self.mesh.nC*self.survey.nSrc) + v = np.random.rand(self.mesh.nC) + w = np.random.rand(self.survey.dobs.shape[0]) + wtJv = w.dot(self.p.Jvec(self.m0, v)) + vtJtw = v.dot(self.p.Jtvec(self.m0, w)) + passed = np.abs(wtJv - vtJtw) < 1e-10 + print 'Adjoint Test', np.abs(wtJv - vtJtw), passed + self.assertTrue(passed) + + def test_dataObj(self): + derChk = lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)] + passed = Tests.checkDerivative(derChk, self.m0, plotIt=False) + self.assertTrue(passed) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/em/fdem/forward/test_FDEM_forward.py b/tests/em/fdem/forward/test_FDEM_forward.py index 437f3708..da446675 100644 --- a/tests/em/fdem/forward/test_FDEM_forward.py +++ b/tests/em/fdem/forward/test_FDEM_forward.py @@ -3,125 +3,75 @@ from SimPEG import * from SimPEG import EM import sys from scipy.constants import mu_0 -from SimPEG.EM.Utils.testingUtils import getFDEMProblem +from SimPEG.EM.Utils.testingUtils import getFDEMProblem, crossCheckTest testEB = True testHJ = True - +testEJ = True +testBH = True verbose = False -TOL = 1e-5 -FLR = 1e-20 # "zero", so if residual below this --> pass regardless of order -CONDUCTIVITY = 1e1 -MU = mu_0 -freq = 1e-1 -addrandoms = True +TOLEBHJ = 1e-5 +TOLEJHB = 1 # averaging and more sensitive to boundary condition violations (ie. the impact of violating the boundary conditions in each case is different.) +#TODO: choose better testing parameters to lower this SrcList = ['RawVec', 'MagDipole_Bfield', 'MagDipole', 'CircularLoop'] -def crossCheckTest(fdemType, comp): - - l2norm = lambda r: np.sqrt(r.dot(r)) - - prb1 = getFDEMProblem(fdemType, comp, SrcList, freq, verbose) - mesh = prb1.mesh - print 'Cross Checking Forward: %s formulation - %s' % (fdemType, comp) - m = np.log(np.ones(mesh.nC)*CONDUCTIVITY) - mu = np.log(np.ones(mesh.nC)*MU) - - if addrandoms is True: - m = m + np.random.randn(mesh.nC)*np.log(CONDUCTIVITY)*1e-1 - mu = mu + np.random.randn(mesh.nC)*MU*1e-1 - - # prb1.PropMap.PropModel.mu = mu - # prb1.PropMap.PropModel.mui = 1./mu - survey1 = prb1.survey - d1 = survey1.dpred(m) - - if verbose: - print ' Problem 1 solved' - - if fdemType == 'e': - prb2 = getFDEMProblem('b', comp, SrcList, freq, verbose) - elif fdemType == 'b': - prb2 = getFDEMProblem('e', comp, SrcList, freq, verbose) - elif fdemType == 'j': - prb2 = getFDEMProblem('h', comp, SrcList, freq, verbose) - elif fdemType == 'h': - prb2 = getFDEMProblem('j', comp, SrcList, freq, verbose) - else: - raise NotImplementedError() - - # prb2.mu = mu - 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(l2norm(d1)))),FLR]) - print l2norm(d1), l2norm(d2), l2r , tol, l2r < tol - return l2r < tol - - class FDEM_CrossCheck(unittest.TestCase): if testEB: def test_EB_CrossCheck_exr_Eform(self): - self.assertTrue(crossCheckTest('e', 'exr')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'exr', verbose=verbose)) def test_EB_CrossCheck_eyr_Eform(self): - self.assertTrue(crossCheckTest('e', 'eyr')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'eyr', verbose=verbose)) def test_EB_CrossCheck_ezr_Eform(self): - self.assertTrue(crossCheckTest('e', 'ezr')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'ezr', verbose=verbose)) def test_EB_CrossCheck_exi_Eform(self): - self.assertTrue(crossCheckTest('e', 'exi')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'exi', verbose=verbose)) def test_EB_CrossCheck_eyi_Eform(self): - self.assertTrue(crossCheckTest('e', 'eyi')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'eyi', verbose=verbose)) def test_EB_CrossCheck_ezi_Eform(self): - self.assertTrue(crossCheckTest('e', 'ezi')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'ezi', verbose=verbose)) def test_EB_CrossCheck_bxr_Eform(self): - self.assertTrue(crossCheckTest('e', 'bxr')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'bxr', verbose=verbose)) def test_EB_CrossCheck_byr_Eform(self): - self.assertTrue(crossCheckTest('e', 'byr')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'byr', verbose=verbose)) def test_EB_CrossCheck_bzr_Eform(self): - self.assertTrue(crossCheckTest('e', 'bzr')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'bzr', verbose=verbose)) def test_EB_CrossCheck_bxi_Eform(self): - self.assertTrue(crossCheckTest('e', 'bxi')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'bxi', verbose=verbose)) def test_EB_CrossCheck_byi_Eform(self): - self.assertTrue(crossCheckTest('e', 'byi')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'byi', verbose=verbose)) def test_EB_CrossCheck_bzi_Eform(self): - self.assertTrue(crossCheckTest('e', 'bzi')) + self.assertTrue(crossCheckTest(SrcList, 'e', 'b', 'bzi', verbose=verbose)) if testHJ: def test_HJ_CrossCheck_jxr_Jform(self): - self.assertTrue(crossCheckTest('j', 'jxr')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'jxr', verbose=verbose)) def test_HJ_CrossCheck_jyr_Jform(self): - self.assertTrue(crossCheckTest('j', 'jyr')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'jyr', verbose=verbose)) def test_HJ_CrossCheck_jzr_Jform(self): - self.assertTrue(crossCheckTest('j', 'jzr')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'jzr', verbose=verbose)) def test_HJ_CrossCheck_jxi_Jform(self): - self.assertTrue(crossCheckTest('j', 'jxi')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'jxi', verbose=verbose)) def test_HJ_CrossCheck_jyi_Jform(self): - self.assertTrue(crossCheckTest('j', 'jyi')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'jyi', verbose=verbose)) def test_HJ_CrossCheck_jzi_Jform(self): - self.assertTrue(crossCheckTest('j', 'jzi')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'jzi', verbose=verbose)) def test_HJ_CrossCheck_hxr_Jform(self): - self.assertTrue(crossCheckTest('j', 'hxr')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'hxr', verbose=verbose)) def test_HJ_CrossCheck_hyr_Jform(self): - self.assertTrue(crossCheckTest('j', 'hyr')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'hyr', verbose=verbose)) def test_HJ_CrossCheck_hzr_Jform(self): - self.assertTrue(crossCheckTest('j', 'hzr')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'hzr', verbose=verbose)) def test_HJ_CrossCheck_hxi_Jform(self): - self.assertTrue(crossCheckTest('j', 'hxi')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'hxi', verbose=verbose)) def test_HJ_CrossCheck_hyi_Jform(self): - self.assertTrue(crossCheckTest('j', 'hyi')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'hyi', verbose=verbose)) def test_HJ_CrossCheck_hzi_Jform(self): - self.assertTrue(crossCheckTest('j', 'hzi')) + self.assertTrue(crossCheckTest(SrcList, 'j', 'h', 'hzi', verbose=verbose)) if __name__ == '__main__': unittest.main() \ No newline at end of file diff --git a/tests/em/fdem/forward/test_FDEM_forwardEJHB.py b/tests/em/fdem/forward/test_FDEM_forwardEJHB.py new file mode 100644 index 00000000..e6319dfc --- /dev/null +++ b/tests/em/fdem/forward/test_FDEM_forwardEJHB.py @@ -0,0 +1,125 @@ +import unittest +from SimPEG import * +from SimPEG import EM +import sys +from scipy.constants import mu_0 +from SimPEG.EM.Utils.testingUtils import getFDEMProblem, crossCheckTest + +testEJ = True +testBH = True + +TOLEJHB = 1 # averaging and more sensitive to boundary condition violations (ie. the impact of violating the boundary conditions in each case is different.) +#TODO: choose better testing parameters to lower this + +SrcList = ['RawVec', 'MagDipole', 'MagDipole_Bfield', 'MagDipole', 'CircularLoop'] + + +class FDEM_CrossCheck(unittest.TestCase): + if testEJ: + def test_EJ_CrossCheck_jxr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'jxr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_jyr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'jyr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_jzr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'jzr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_jxi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'jxi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_jyi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'jyi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_jzi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'jzi', TOL=TOLEJHB)) + + def test_EJ_CrossCheck_exr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'exr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_eyr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'eyr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_ezr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'ezr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_exi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'exi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_eyi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'eyi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_ezi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'ezi', TOL=TOLEJHB)) + + def test_EJ_CrossCheck_bxr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'bxr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_byr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'byr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_bzr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'bzr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_bxi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'bxi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_byi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'byi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_bzi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'bzi', TOL=TOLEJHB)) + + def test_EJ_CrossCheck_hxr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'hxr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_hyr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'hyr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_hzr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'hzr', TOL=TOLEJHB)) + def test_EJ_CrossCheck_hxi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'hxi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_hyi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'hyi', TOL=TOLEJHB)) + def test_EJ_CrossCheck_hzi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'e', 'j', 'hzi', TOL=TOLEJHB)) + + if testBH: + def test_HB_CrossCheck_jxr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'jxr', TOL=TOLEJHB)) + def test_HB_CrossCheck_jyr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'jyr', TOL=TOLEJHB)) + def test_HB_CrossCheck_jzr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'jzr', TOL=TOLEJHB)) + def test_HB_CrossCheck_jxi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'jxi', TOL=TOLEJHB)) + def test_HB_CrossCheck_jyi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'jyi', TOL=TOLEJHB)) + def test_HB_CrossCheck_jzi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'jzi', TOL=TOLEJHB)) + + def test_HB_CrossCheck_exr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'exr', TOL=TOLEJHB)) + def test_HB_CrossCheck_eyr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'eyr', TOL=TOLEJHB)) + def test_HB_CrossCheck_ezr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'ezr', TOL=TOLEJHB)) + def test_HB_CrossCheck_exi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'exi', TOL=TOLEJHB)) + def test_HB_CrossCheck_eyi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'eyi', TOL=TOLEJHB)) + def test_HB_CrossCheck_ezi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'ezi', TOL=TOLEJHB)) + + def test_HB_CrossCheck_bxr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'bxr', TOL=TOLEJHB)) + def test_HB_CrossCheck_byr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'byr', TOL=TOLEJHB)) + def test_HB_CrossCheck_bzr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'bzr', TOL=TOLEJHB)) + def test_HB_CrossCheck_bxi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'bxi', TOL=TOLEJHB)) + def test_HB_CrossCheck_byi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'byi', TOL=TOLEJHB)) + def test_HB_CrossCheck_bzi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'bzi', TOL=TOLEJHB)) + + def test_HB_CrossCheck_hxr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'hxr', TOL=TOLEJHB)) + def test_HB_CrossCheck_hyr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'hyr', TOL=TOLEJHB)) + def test_HB_CrossCheck_hzr_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'hzr', TOL=TOLEJHB)) + def test_HB_CrossCheck_hxi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'hxi', TOL=TOLEJHB)) + def test_HB_CrossCheck_hyi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'hyi', TOL=TOLEJHB)) + def test_HB_CrossCheck_hzi_Jform(self): + self.assertTrue(crossCheckTest(SrcList, 'h', 'b', 'hzi', TOL=TOLEJHB)) + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/tests/em/fdem/forward/test_FDEM_forwardHB.py b/tests/em/fdem/forward/test_FDEM_forwardHB.py new file mode 100644 index 00000000..545a5014 --- /dev/null +++ b/tests/em/fdem/forward/test_FDEM_forwardHB.py @@ -0,0 +1,128 @@ +import unittest +from SimPEG import * +from SimPEG import EM +import sys +from scipy.constants import mu_0 +from SimPEG.EM.Utils.testingUtils import getFDEMProblem, crossCheckTest + +testEB = True +testHJ = True +testEJ = True +testBH = True +verbose = False + +TOLEJHB = 1 # averaging and more sensitive to boundary condition violations (ie. the impact of violating the boundary conditions in each case is different.) +#TODO: choose better testing parameters to lower this + +SrcList = ['RawVec', 'MagDipole_Bfield', 'MagDipole', 'CircularLoop'] + + +class FDEM_CrossCheck(unittest.TestCase): + if testBH: + def test_BH_CrossCheck_jxr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jxr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jyr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jyr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jzr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jzr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jxi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jxi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jyi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jyi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jzi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jzi', verbose=verbose, TOL=TOLEJHB)) + + def test_BH_CrossCheck_exr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'exr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_eyr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'eyr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_ezr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'ezr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_exi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'exi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_eyi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'eyi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_ezi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'ezi', verbose=verbose, TOL=TOLEJHB)) + + def test_BH_CrossCheck_bxr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bxr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_byr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'byr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_bzr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bzr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_bxi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bxi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_byi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'byi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_bzi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bzi', verbose=verbose, TOL=TOLEJHB)) + + def test_BH_CrossCheck_hxr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hxr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hyr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hyr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hzr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hzr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hxi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hxi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hyi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hyi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hzi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hzi', verbose=verbose, TOL=TOLEJHB)) + + if testBH: + def test_BH_CrossCheck_jxr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jxr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jyr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jyr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jzr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jzr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jxi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jxi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jyi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jyi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_jzi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'jzi', verbose=verbose, TOL=TOLEJHB)) + + def test_BH_CrossCheck_exr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'exr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_eyr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'eyr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_ezr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'ezr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_exi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'exi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_eyi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'eyi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_ezi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'ezi', verbose=verbose, TOL=TOLEJHB)) + + def test_BH_CrossCheck_bxr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bxr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_byr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'byr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_bzr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bzr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_bxi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bxi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_byi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'byi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_bzi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'bzi', verbose=verbose, TOL=TOLEJHB)) + + def test_BH_CrossCheck_hxr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hxr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hyr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hyr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hzr(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hzr', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hxi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hxi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hyi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hyi', verbose=verbose, TOL=TOLEJHB)) + def test_BH_CrossCheck_hzi(self): + self.assertTrue(crossCheckTest(SrcList, 'b', 'h', 'hzi', verbose=verbose, TOL=TOLEJHB)) + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/tests/em/fdem/inverse/adjoint/test_FDEM_adjoint.py b/tests/em/fdem/inverse/adjoint/test_FDEM_adjointEB.py similarity index 57% rename from tests/em/fdem/inverse/adjoint/test_FDEM_adjoint.py rename to tests/em/fdem/inverse/adjoint/test_FDEM_adjointEB.py index f77f2131..25762368 100644 --- a/tests/em/fdem/inverse/adjoint/test_FDEM_adjoint.py +++ b/tests/em/fdem/inverse/adjoint/test_FDEM_adjointEB.py @@ -5,8 +5,8 @@ import sys from scipy.constants import mu_0 from SimPEG.EM.Utils.testingUtils import getFDEMProblem -testEB = True -testHJ = True +testE = True +testB = True verbose = False @@ -17,10 +17,10 @@ MU = mu_0 freq = 1e-1 addrandoms = True -SrcType = 'RawVec' #or 'MAgDipole_Bfield', 'CircularLoop', 'RawVec' +SrcList = ['RawVec', 'MagDipole'] #or 'MAgDipole_Bfield', 'CircularLoop', 'RawVec' def adjointTest(fdemType, comp): - prb = getFDEMProblem(fdemType, comp, [SrcType], freq) + prb = getFDEMProblem(fdemType, comp, SrcList, freq) print 'Adjoint %s formulation - %s' % (fdemType, comp) m = np.log(np.ones(prb.mapping.nP)*CONDUCTIVITY) @@ -45,7 +45,7 @@ def adjointTest(fdemType, comp): return np.abs(vJw - wJtv) < tol class FDEM_AdjointTests(unittest.TestCase): - if testEB: + if testE: def test_Jtvec_adjointTest_exr_Eform(self): self.assertTrue(adjointTest('e', 'exr')) def test_Jtvec_adjointTest_eyr_Eform(self): @@ -72,6 +72,33 @@ class FDEM_AdjointTests(unittest.TestCase): def test_Jtvec_adjointTest_bzi_Eform(self): self.assertTrue(adjointTest('e', 'bzi')) + def test_Jtvec_adjointTest_jxr_Eform(self): + self.assertTrue(adjointTest('e', 'jxr')) + def test_Jtvec_adjointTest_jyr_Eform(self): + self.assertTrue(adjointTest('e', 'jyr')) + def test_Jtvec_adjointTest_jzr_Eform(self): + self.assertTrue(adjointTest('e', 'jzr')) + def test_Jtvec_adjointTest_jxi_Eform(self): + self.assertTrue(adjointTest('e', 'jxi')) + def test_Jtvec_adjointTest_jyi_Eform(self): + self.assertTrue(adjointTest('e', 'jyi')) + def test_Jtvec_adjointTest_jzi_Eform(self): + self.assertTrue(adjointTest('e', 'jzi')) + + def test_Jtvec_adjointTest_hxr_Eform(self): + self.assertTrue(adjointTest('e', 'hxr')) + def test_Jtvec_adjointTest_hyr_Eform(self): + self.assertTrue(adjointTest('e', 'hyr')) + def test_Jtvec_adjointTest_hzr_Eform(self): + self.assertTrue(adjointTest('e', 'hzr')) + def test_Jtvec_adjointTest_hxi_Eform(self): + self.assertTrue(adjointTest('e', 'hxi')) + def test_Jtvec_adjointTest_hyi_Eform(self): + self.assertTrue(adjointTest('e', 'hyi')) + def test_Jtvec_adjointTest_hzi_Eform(self): + self.assertTrue(adjointTest('e', 'hzi')) + + if testB: def test_Jtvec_adjointTest_exr_Bform(self): self.assertTrue(adjointTest('b', 'exr')) def test_Jtvec_adjointTest_eyr_Bform(self): @@ -84,6 +111,7 @@ class FDEM_AdjointTests(unittest.TestCase): self.assertTrue(adjointTest('b', 'eyi')) def test_Jtvec_adjointTest_ezi_Bform(self): self.assertTrue(adjointTest('b', 'ezi')) + def test_Jtvec_adjointTest_bxr_Bform(self): self.assertTrue(adjointTest('b', 'bxr')) def test_Jtvec_adjointTest_byr_Bform(self): @@ -97,59 +125,31 @@ class FDEM_AdjointTests(unittest.TestCase): def test_Jtvec_adjointTest_bzi_Bform(self): self.assertTrue(adjointTest('b', 'bzi')) + def test_Jtvec_adjointTest_jxr_Bform(self): + self.assertTrue(adjointTest('b', 'jxr')) + def test_Jtvec_adjointTest_jyr_Bform(self): + self.assertTrue(adjointTest('b', 'jyr')) + def test_Jtvec_adjointTest_jzr_Bform(self): + self.assertTrue(adjointTest('b', 'jzr')) + def test_Jtvec_adjointTest_jxi_Bform(self): + self.assertTrue(adjointTest('b', 'jxi')) + def test_Jtvec_adjointTest_jyi_Bform(self): + self.assertTrue(adjointTest('b', 'jyi')) + def test_Jtvec_adjointTest_jzi_Bform(self): + self.assertTrue(adjointTest('b', 'jzi')) - if testHJ: - def test_Jtvec_adjointTest_jxr_Jform(self): - self.assertTrue(adjointTest('j', 'jxr')) - def test_Jtvec_adjointTest_jyr_Jform(self): - self.assertTrue(adjointTest('j', 'jyr')) - def test_Jtvec_adjointTest_jzr_Jform(self): - self.assertTrue(adjointTest('j', 'jzr')) - def test_Jtvec_adjointTest_jxi_Jform(self): - self.assertTrue(adjointTest('j', 'jxi')) - def test_Jtvec_adjointTest_jyi_Jform(self): - self.assertTrue(adjointTest('j', 'jyi')) - def test_Jtvec_adjointTest_jzi_Jform(self): - self.assertTrue(adjointTest('j', 'jzi')) - - def test_Jtvec_adjointTest_hxr_Jform(self): - self.assertTrue(adjointTest('j', 'hxr')) - def test_Jtvec_adjointTest_hyr_Jform(self): - self.assertTrue(adjointTest('j', 'hyr')) - def test_Jtvec_adjointTest_hzr_Jform(self): - self.assertTrue(adjointTest('j', 'hzr')) - def test_Jtvec_adjointTest_hxi_Jform(self): - self.assertTrue(adjointTest('j', 'hxi')) - def test_Jtvec_adjointTest_hyi_Jform(self): - self.assertTrue(adjointTest('j', 'hyi')) - def test_Jtvec_adjointTest_hzi_Jform(self): - self.assertTrue(adjointTest('j', 'hzi')) - - def test_Jtvec_adjointTest_hxr_Hform(self): - self.assertTrue(adjointTest('h', 'hxr')) - def test_Jtvec_adjointTest_hyr_Hform(self): - self.assertTrue(adjointTest('h', 'hyr')) - def test_Jtvec_adjointTest_hzr_Hform(self): - self.assertTrue(adjointTest('h', 'hzr')) - def test_Jtvec_adjointTest_hxi_Hform(self): - self.assertTrue(adjointTest('h', 'hxi')) - def test_Jtvec_adjointTest_hyi_Hform(self): - self.assertTrue(adjointTest('h', 'hyi')) - def test_Jtvec_adjointTest_hzi_Hform(self): - self.assertTrue(adjointTest('h', 'hzi')) - - def test_Jtvec_adjointTest_hxr_Hform(self): - self.assertTrue(adjointTest('h', 'jxr')) - def test_Jtvec_adjointTest_hyr_Hform(self): - self.assertTrue(adjointTest('h', 'jyr')) - def test_Jtvec_adjointTest_hzr_Hform(self): - self.assertTrue(adjointTest('h', 'jzr')) - def test_Jtvec_adjointTest_hxi_Hform(self): - self.assertTrue(adjointTest('h', 'jxi')) - def test_Jtvec_adjointTest_hyi_Hform(self): - self.assertTrue(adjointTest('h', 'jyi')) - def test_Jtvec_adjointTest_hzi_Hform(self): - self.assertTrue(adjointTest('h', 'jzi')) + def test_Jtvec_adjointTest_hxr_Bform(self): + self.assertTrue(adjointTest('b', 'hxr')) + def test_Jtvec_adjointTest_hyr_Bform(self): + self.assertTrue(adjointTest('b', 'hyr')) + def test_Jtvec_adjointTest_hzr_Bform(self): + self.assertTrue(adjointTest('b', 'hzr')) + def test_Jtvec_adjointTest_hxi_Bform(self): + self.assertTrue(adjointTest('b', 'hxi')) + def test_Jtvec_adjointTest_hyi_Bform(self): + self.assertTrue(adjointTest('b', 'hyi')) + def test_Jtvec_adjointTest_hzi_Bform(self): + self.assertTrue(adjointTest('b', 'hzi')) if __name__ == '__main__': diff --git a/tests/em/fdem/inverse/adjoint/test_FDEM_adjointHJ.py b/tests/em/fdem/inverse/adjoint/test_FDEM_adjointHJ.py new file mode 100644 index 00000000..c3fb3d37 --- /dev/null +++ b/tests/em/fdem/inverse/adjoint/test_FDEM_adjointHJ.py @@ -0,0 +1,155 @@ +import unittest +from SimPEG import * +from SimPEG import EM +import sys +from scipy.constants import mu_0 +from SimPEG.EM.Utils.testingUtils import getFDEMProblem + +testJ = True +testH = True + +verbose = False + +TOL = 1e-5 +FLR = 1e-20 # "zero", so if residual below this --> pass regardless of order +CONDUCTIVITY = 1e1 +MU = mu_0 +freq = 1e-1 +addrandoms = True + +SrcList = ['RawVec', 'MagDipole'] #or 'MAgDipole_Bfield', 'CircularLoop', 'RawVec' + +def adjointTest(fdemType, comp): + prb = getFDEMProblem(fdemType, comp, SrcList, freq) + print 'Adjoint %s formulation - %s' % (fdemType, comp) + + m = np.log(np.ones(prb.mapping.nP)*CONDUCTIVITY) + mu = np.ones(prb.mesh.nC)*MU + + if addrandoms is True: + m = m + np.random.randn(prb.mapping.nP)*np.log(CONDUCTIVITY)*1e-1 + mu = mu + np.random.randn(prb.mesh.nC)*MU*1e-1 + + survey = prb.survey + u = prb.fields(m) + + v = np.random.rand(survey.nD) + w = np.random.rand(prb.mesh.nC) + + vJw = v.dot(prb.Jvec(m, w, u)) + wJtv = w.dot(prb.Jtvec(m, v, u)) + tol = np.max([TOL*(10**int(np.log10(np.abs(vJw)))),FLR]) + print vJw, wJtv, vJw - wJtv, tol, np.abs(vJw - wJtv) < tol + return np.abs(vJw - wJtv) < tol + +class FDEM_AdjointTests(unittest.TestCase): + + if testJ: + def test_Jtvec_adjointTest_jxr_Jform(self): + self.assertTrue(adjointTest('j', 'jxr')) + def test_Jtvec_adjointTest_jyr_Jform(self): + self.assertTrue(adjointTest('j', 'jyr')) + def test_Jtvec_adjointTest_jzr_Jform(self): + self.assertTrue(adjointTest('j', 'jzr')) + def test_Jtvec_adjointTest_jxi_Jform(self): + self.assertTrue(adjointTest('j', 'jxi')) + def test_Jtvec_adjointTest_jyi_Jform(self): + self.assertTrue(adjointTest('j', 'jyi')) + def test_Jtvec_adjointTest_jzi_Jform(self): + self.assertTrue(adjointTest('j', 'jzi')) + + def test_Jtvec_adjointTest_hxr_Jform(self): + self.assertTrue(adjointTest('j', 'hxr')) + def test_Jtvec_adjointTest_hyr_Jform(self): + self.assertTrue(adjointTest('j', 'hyr')) + def test_Jtvec_adjointTest_hzr_Jform(self): + self.assertTrue(adjointTest('j', 'hzr')) + def test_Jtvec_adjointTest_hxi_Jform(self): + self.assertTrue(adjointTest('j', 'hxi')) + def test_Jtvec_adjointTest_hyi_Jform(self): + self.assertTrue(adjointTest('j', 'hyi')) + def test_Jtvec_adjointTest_hzi_Jform(self): + self.assertTrue(adjointTest('j', 'hzi')) + + def test_Jtvec_adjointTest_exr_Jform(self): + self.assertTrue(adjointTest('j', 'exr')) + def test_Jtvec_adjointTest_eyr_Jform(self): + self.assertTrue(adjointTest('j', 'eyr')) + def test_Jtvec_adjointTest_ezr_Jform(self): + self.assertTrue(adjointTest('j', 'ezr')) + def test_Jtvec_adjointTest_exi_Jform(self): + self.assertTrue(adjointTest('j', 'exi')) + def test_Jtvec_adjointTest_eyi_Jform(self): + self.assertTrue(adjointTest('j', 'eyi')) + def test_Jtvec_adjointTest_ezi_Jform(self): + self.assertTrue(adjointTest('j', 'ezi')) + + def test_Jtvec_adjointTest_bxr_Jform(self): + self.assertTrue(adjointTest('j', 'bxr')) + def test_Jtvec_adjointTest_byr_Jform(self): + self.assertTrue(adjointTest('j', 'byr')) + def test_Jtvec_adjointTest_bzr_Jform(self): + self.assertTrue(adjointTest('j', 'bzr')) + def test_Jtvec_adjointTest_bxi_Jform(self): + self.assertTrue(adjointTest('j', 'bxi')) + def test_Jtvec_adjointTest_byi_Jform(self): + self.assertTrue(adjointTest('j', 'byi')) + def test_Jtvec_adjointTest_bzi_Jform(self): + self.assertTrue(adjointTest('j', 'bzi')) + + if testH: + def test_Jtvec_adjointTest_hxr_Hform(self): + self.assertTrue(adjointTest('h', 'hxr')) + def test_Jtvec_adjointTest_hyr_Hform(self): + self.assertTrue(adjointTest('h', 'hyr')) + def test_Jtvec_adjointTest_hzr_Hform(self): + self.assertTrue(adjointTest('h', 'hzr')) + def test_Jtvec_adjointTest_hxi_Hform(self): + self.assertTrue(adjointTest('h', 'hxi')) + def test_Jtvec_adjointTest_hyi_Hform(self): + self.assertTrue(adjointTest('h', 'hyi')) + def test_Jtvec_adjointTest_hzi_Hform(self): + self.assertTrue(adjointTest('h', 'hzi')) + + def test_Jtvec_adjointTest_jxr_Hform(self): + self.assertTrue(adjointTest('h', 'jxr')) + def test_Jtvec_adjointTest_jyr_Hform(self): + self.assertTrue(adjointTest('h', 'jyr')) + def test_Jtvec_adjointTest_jzr_Hform(self): + self.assertTrue(adjointTest('h', 'jzr')) + def test_Jtvec_adjointTest_jxi_Hform(self): + self.assertTrue(adjointTest('h', 'jxi')) + def test_Jtvec_adjointTest_jyi_Hform(self): + self.assertTrue(adjointTest('h', 'jyi')) + def test_Jtvec_adjointTest_jzi_Hform(self): + self.assertTrue(adjointTest('h', 'jzi')) + + def test_Jtvec_adjointTest_exr_Hform(self): + self.assertTrue(adjointTest('h', 'exr')) + def test_Jtvec_adjointTest_eyr_Hform(self): + self.assertTrue(adjointTest('h', 'eyr')) + def test_Jtvec_adjointTest_ezr_Hform(self): + self.assertTrue(adjointTest('h', 'ezr')) + def test_Jtvec_adjointTest_exi_Hform(self): + self.assertTrue(adjointTest('h', 'exi')) + def test_Jtvec_adjointTest_eyi_Hform(self): + self.assertTrue(adjointTest('h', 'eyi')) + def test_Jtvec_adjointTest_ezi_Hform(self): + self.assertTrue(adjointTest('h', 'ezi')) + + def test_Jtvec_adjointTest_bxr_Hform(self): + self.assertTrue(adjointTest('h', 'bxr')) + def test_Jtvec_adjointTest_byr_Hform(self): + self.assertTrue(adjointTest('h', 'byr')) + def test_Jtvec_adjointTest_bzr_Hform(self): + self.assertTrue(adjointTest('h', 'bzr')) + def test_Jtvec_adjointTest_bxi_Hform(self): + self.assertTrue(adjointTest('h', 'bxi')) + def test_Jtvec_adjointTest_byi_Hform(self): + self.assertTrue(adjointTest('h', 'byi')) + def test_Jtvec_adjointTest_bzi_Hform(self): + self.assertTrue(adjointTest('h', 'bzi')) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/em/fdem/inverse/derivs/test_FDEM_derivs.py b/tests/em/fdem/inverse/derivs/test_FDEM_derivs.py index d3bcb218..0a2e8b82 100644 --- a/tests/em/fdem/inverse/derivs/test_FDEM_derivs.py +++ b/tests/em/fdem/inverse/derivs/test_FDEM_derivs.py @@ -5,9 +5,11 @@ import sys from scipy.constants import mu_0 from SimPEG.EM.Utils.testingUtils import getFDEMProblem -testDerivs = True -testEB = True -testHJ = True + +testE = True +testB = True +testH = True +testJ = True verbose = False @@ -18,12 +20,12 @@ MU = mu_0 freq = 1e-1 addrandoms = True -SrcType = 'RawVec' #or 'MAgDipole_Bfield', 'CircularLoop', 'RawVec' +SrcType = ['MagDipole', 'RawVec'] #or 'MAgDipole_Bfield', 'CircularLoop', 'RawVec' def derivTest(fdemType, comp): - prb = getFDEMProblem(fdemType, comp, [SrcType], freq) + prb = getFDEMProblem(fdemType, comp, SrcType, freq) print '%s formulation - %s' % (fdemType, comp) x0 = np.log(np.ones(prb.mapping.nP)*CONDUCTIVITY) mu = np.log(np.ones(prb.mesh.nC)*MU) @@ -32,9 +34,6 @@ def derivTest(fdemType, comp): x0 = x0 + np.random.randn(prb.mapping.nP)*np.log(CONDUCTIVITY)*1e-1 mu = mu + np.random.randn(prb.mapping.nP)*MU*1e-1 - # prb.PropMap.PropModel.mu = mu - # prb.PropMap.PropModel.mui = 1./mu - survey = prb.survey def fun(x): return survey.dpred(x), lambda x: prb.Jvec(x0, x) @@ -43,7 +42,7 @@ def derivTest(fdemType, comp): class FDEM_DerivTests(unittest.TestCase): - if testEB: + if testE: def test_Jvec_exr_Eform(self): self.assertTrue(derivTest('e', 'exr')) def test_Jvec_eyr_Eform(self): @@ -70,6 +69,33 @@ class FDEM_DerivTests(unittest.TestCase): def test_Jvec_bzi_Eform(self): self.assertTrue(derivTest('e', 'bzi')) + def test_Jvec_exr_Eform(self): + self.assertTrue(derivTest('e', 'jxr')) + def test_Jvec_eyr_Eform(self): + self.assertTrue(derivTest('e', 'jyr')) + def test_Jvec_ezr_Eform(self): + self.assertTrue(derivTest('e', 'jzr')) + def test_Jvec_exi_Eform(self): + self.assertTrue(derivTest('e', 'jxi')) + def test_Jvec_eyi_Eform(self): + self.assertTrue(derivTest('e', 'jyi')) + def test_Jvec_ezi_Eform(self): + self.assertTrue(derivTest('e', 'jzi')) + + def test_Jvec_bxr_Eform(self): + self.assertTrue(derivTest('e', 'hxr')) + def test_Jvec_byr_Eform(self): + self.assertTrue(derivTest('e', 'hyr')) + def test_Jvec_bzr_Eform(self): + self.assertTrue(derivTest('e', 'hzr')) + def test_Jvec_bxi_Eform(self): + self.assertTrue(derivTest('e', 'hxi')) + def test_Jvec_byi_Eform(self): + self.assertTrue(derivTest('e', 'hyi')) + def test_Jvec_bzi_Eform(self): + self.assertTrue(derivTest('e', 'hzi')) + + if testB: def test_Jvec_exr_Bform(self): self.assertTrue(derivTest('b', 'exr')) def test_Jvec_eyr_Bform(self): @@ -96,7 +122,33 @@ class FDEM_DerivTests(unittest.TestCase): def test_Jvec_bzi_Bform(self): self.assertTrue(derivTest('b', 'bzi')) - if testHJ: + def test_Jvec_jxr_Bform(self): + self.assertTrue(derivTest('b', 'jxr')) + def test_Jvec_jyr_Bform(self): + self.assertTrue(derivTest('b', 'jyr')) + def test_Jvec_jzr_Bform(self): + self.assertTrue(derivTest('b', 'jzr')) + def test_Jvec_jxi_Bform(self): + self.assertTrue(derivTest('b', 'jxi')) + def test_Jvec_jyi_Bform(self): + self.assertTrue(derivTest('b', 'jyi')) + def test_Jvec_jzi_Bform(self): + self.assertTrue(derivTest('b', 'jzi')) + + def test_Jvec_hxr_Bform(self): + self.assertTrue(derivTest('b', 'hxr')) + def test_Jvec_hyr_Bform(self): + self.assertTrue(derivTest('b', 'hyr')) + def test_Jvec_hzr_Bform(self): + self.assertTrue(derivTest('b', 'hzr')) + def test_Jvec_hxi_Bform(self): + self.assertTrue(derivTest('b', 'hxi')) + def test_Jvec_hyi_Bform(self): + self.assertTrue(derivTest('b', 'hyi')) + def test_Jvec_hzi_Bform(self): + self.assertTrue(derivTest('b', 'hzi')) + + if testJ: def test_Jvec_jxr_Jform(self): self.assertTrue(derivTest('j', 'jxr')) def test_Jvec_jyr_Jform(self): @@ -123,6 +175,34 @@ class FDEM_DerivTests(unittest.TestCase): def test_Jvec_hzi_Jform(self): self.assertTrue(derivTest('j', 'hzi')) + def test_Jvec_exr_Jform(self): + self.assertTrue(derivTest('j', 'exr')) + def test_Jvec_eyr_Jform(self): + self.assertTrue(derivTest('j', 'eyr')) + def test_Jvec_ezr_Jform(self): + self.assertTrue(derivTest('j', 'ezr')) + def test_Jvec_exi_Jform(self): + self.assertTrue(derivTest('j', 'exi')) + def test_Jvec_eyi_Jform(self): + self.assertTrue(derivTest('j', 'eyi')) + def test_Jvec_ezi_Jform(self): + self.assertTrue(derivTest('j', 'ezi')) + + def test_Jvec_bxr_Jform(self): + self.assertTrue(derivTest('j', 'bxr')) + def test_Jvec_byr_Jform(self): + self.assertTrue(derivTest('j', 'byr')) + def test_Jvec_bzr_Jform(self): + self.assertTrue(derivTest('j', 'bzr')) + def test_Jvec_bxi_Jform(self): + self.assertTrue(derivTest('j', 'bxi')) + def test_Jvec_byi_Jform(self): + self.assertTrue(derivTest('j', 'byi')) + def test_Jvec_bzi_Jform(self): + self.assertTrue(derivTest('j', 'bzi')) + + + if testH: def test_Jvec_hxr_Hform(self): self.assertTrue(derivTest('h', 'hxr')) def test_Jvec_hyr_Hform(self): @@ -149,6 +229,32 @@ class FDEM_DerivTests(unittest.TestCase): def test_Jvec_hzi_Hform(self): self.assertTrue(derivTest('h', 'jzi')) + def test_Jvec_exr_Hform(self): + self.assertTrue(derivTest('h', 'exr')) + def test_Jvec_eyr_Hform(self): + self.assertTrue(derivTest('h', 'eyr')) + def test_Jvec_ezr_Hform(self): + self.assertTrue(derivTest('h', 'ezr')) + def test_Jvec_exi_Hform(self): + self.assertTrue(derivTest('h', 'exi')) + def test_Jvec_eyi_Hform(self): + self.assertTrue(derivTest('h', 'eyi')) + def test_Jvec_ezi_Hform(self): + self.assertTrue(derivTest('h', 'ezi')) + + def test_Jvec_bxr_Hform(self): + self.assertTrue(derivTest('h', 'bxr')) + def test_Jvec_byr_Hform(self): + self.assertTrue(derivTest('h', 'byr')) + def test_Jvec_bzr_Hform(self): + self.assertTrue(derivTest('h', 'bzr')) + def test_Jvec_bxi_Hform(self): + self.assertTrue(derivTest('h', 'bxi')) + def test_Jvec_byi_Hform(self): + self.assertTrue(derivTest('h', 'byi')) + def test_Jvec_bzi_Hform(self): + self.assertTrue(derivTest('h', 'bzi')) + if __name__ == '__main__': unittest.main() diff --git a/tests/em/tdem/test_TDEM_b_DerivAdjoint.py b/tests/em/tdem/test_TDEM_b_DerivAdjoint.py index 570c808b..30630d8d 100644 --- a/tests/em/tdem/test_TDEM_b_DerivAdjoint.py +++ b/tests/em/tdem/test_TDEM_b_DerivAdjoint.py @@ -18,8 +18,8 @@ class TDEM_bDerivTests(unittest.TestCase): mesh = Mesh.CylMesh([hx,1,hy], '00C') active = mesh.vectorCCz<0. - activeMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) - mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * activeMap + activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) + mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 40. rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 0.]]), np.logspace(-4,-3, 20), 'bz') @@ -204,8 +204,8 @@ class TDEM_bDerivTests(unittest.TestCase): 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) diff --git a/tests/em/tdem/test_TDEM_b_MultiSrc_DerivAdjoint.py b/tests/em/tdem/test_TDEM_b_MultiSrc_DerivAdjoint.py index de261a10..8f3ebcc1 100644 --- a/tests/em/tdem/test_TDEM_b_MultiSrc_DerivAdjoint.py +++ b/tests/em/tdem/test_TDEM_b_MultiSrc_DerivAdjoint.py @@ -17,8 +17,8 @@ class TDEM_bDerivTests(unittest.TestCase): mesh = Mesh.CylMesh([hx,1,hy], '00C') active = mesh.vectorCCz<0. - activeMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) - mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * activeMap + activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) + mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 40. rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 0.]]), np.logspace(-4,-3, 20), 'bz') @@ -108,8 +108,8 @@ class TDEM_bDerivTests(unittest.TestCase): 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) diff --git a/tests/em/tdem/test_TDEM_combos.py b/tests/em/tdem/test_TDEM_combos.py index 1f538c3c..926cdf23 100644 --- a/tests/em/tdem/test_TDEM_combos.py +++ b/tests/em/tdem/test_TDEM_combos.py @@ -14,8 +14,8 @@ def getProb(meshType='CYL',rxTypes='bx,bz',nSrc=1): mesh = Mesh.CylMesh([hx,1,hy], '00C') active = mesh.vectorCCz<0. - activeMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) - mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * activeMap + activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) + mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 40. diff --git a/tests/em/tdem/test_TDEM_forward_Analytic.py b/tests/em/tdem/test_TDEM_forward_Analytic.py index 06890541..dc3696ef 100644 --- a/tests/em/tdem/test_TDEM_forward_Analytic.py +++ b/tests/em/tdem/test_TDEM_forward_Analytic.py @@ -24,8 +24,8 @@ def halfSpaceProblemAnaDiff(meshType, sig_half=1e-2, rxOffset=50., bounds=[1e-5, mesh = Mesh.TensorMesh([hx,hy,hz], 'CCC') active = mesh.vectorCCz<0. - actMap = Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) - mapping = Maps.ExpMap(mesh) * Maps.Vertical1DMap(mesh) * actMap + actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) + mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 0.]]), np.logspace(-5,-4, 21), 'bz') src = EM.TDEM.SrcTDEM_VMD_MVP([rx], loc=np.array([0., 0., 0.])) diff --git a/tests/mt/__init__.py b/tests/mt/__init__.py new file mode 100644 index 00000000..420388ef --- /dev/null +++ b/tests/mt/__init__.py @@ -0,0 +1,12 @@ +import os +import glob +import unittest + +if __name__ == '__main__': + test_file_strings = glob.glob('test_*.py') + module_strings = [str[0:len(str)-3] for str in test_file_strings] + suites = [unittest.defaultTestLoader.loadTestsFromName(str) for str + in module_strings] + testSuite = unittest.TestSuite(suites) + + unittest.TextTestRunner(verbosity=2).run(testSuite) diff --git a/tests/mt/test_ApparentResistivityAnalytic.py b/tests/mt/test_ApparentResistivityAnalytic.py new file mode 100644 index 00000000..2a3b1ba9 --- /dev/null +++ b/tests/mt/test_ApparentResistivityAnalytic.py @@ -0,0 +1,48 @@ +import unittest +from SimPEG import * +from SimPEG import MT + +TOL = 1e-6 + +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 appResNorm(sigmaHalf): + nFreq = 26 + + m1d = Mesh.TensorMesh([[(100,5,1.5),(100.,10),(100,5,1.5)]], x0=['C']) + sigma = np.zeros(m1d.nC) + sigmaHalf + sigma[m1d.gridCC[:]>200] = 1e-8 + + # Calculate the analytic fields + freqs = np.logspace(4,-4,nFreq) + Z = [] + for freq in freqs: + Ed, Eu, Hd, Hu = MT.Utils.getEHfields(m1d,sigma,freq,np.array([200])) + Z.append((Ed + Eu)/(Hd + Hu)) + + Zarr = np.concatenate(Z) + + app_r, app_p = appResPhs(freqs,Zarr) + + return np.linalg.norm(np.abs(app_r - np.ones(nFreq)/sigmaHalf)) / np.log10(sigmaHalf) + + +class TestAnalytics(unittest.TestCase): + + def setUp(self): + pass + def test_appRes2en1(self):self.assertLess(appResNorm(2e-1), TOL) + def test_appRes2en2(self):self.assertLess(appResNorm(2e-2), TOL) + def test_appRes2en3(self):self.assertLess(appResNorm(2e-3), TOL) + def test_appRes2en4(self):self.assertLess(appResNorm(2e-4), TOL) + def test_appRes2en5(self):self.assertLess(appResNorm(2e-5), TOL) + def test_appRes2en6(self):self.assertLess(appResNorm(2e-6), TOL) + + + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/mt/test_Problem1D_againstAnalyticHalfspace.py b/tests/mt/test_Problem1D_againstAnalyticHalfspace.py new file mode 100644 index 00000000..dcfb7978 --- /dev/null +++ b/tests/mt/test_Problem1D_againstAnalyticHalfspace.py @@ -0,0 +1,162 @@ +import unittest +import SimPEG as simpeg +from SimPEG import MT +from SimPEG.Utils import meshTensor +import numpy as np +# Define the tolerances +TOLr = 5e-2 +TOLp = 5e-2 + + +def setupSurvey(sigmaHalf,tD=True): + + # Frequency + nFreq = 33 + freqs = np.logspace(3,-3,nFreq) + # Make the mesh + ct = 5 + air = meshTensor([(ct,25,1.3)]) + # coreT0 = meshTensor([(ct,15,1.2)]) + # coreT1 = np.kron(meshTensor([(coreT0[-1],15,1.3)]),np.ones((7,))) + core = np.concatenate( ( np.kron(meshTensor([(ct,15,-1.2)]),np.ones((10,))) , meshTensor([(ct,20)]) ) ) + bot = meshTensor([(core[0],10,-1.3)]) + x0 = -np.array([np.sum(np.concatenate((core,bot)))]) + m1d = simpeg.Mesh.TensorMesh([np.concatenate((bot,core,air))], x0=x0) + # Make the model + sigma = np.zeros(m1d.nC) + sigmaHalf + sigma[m1d.gridCC > 0 ] = 1e-8 + + rxList = [] + for rxType in ['z1dr','z1di']: + rxList.append(MT.Rx(simpeg.mkvc(np.array([0.0]),2).T,rxType)) + # Source list + srcList =[] + if tD: + for freq in freqs: + srcList.append(MT.SrcMT.polxy_1DhomotD(rxList,freq)) + else: + for freq in freqs: + srcList.append(MT.SrcMT.polxy_1Dprimary(rxList,freq)) + + survey = MT.Survey(srcList) + return survey, sigma, m1d + +def getAppResPhs(MTdata): + # Make impedance + 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 + 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 appRes_TotalFieldNorm(sigmaHalf): + + # Make the survey + survey, sigma, mesh = setupSurvey(sigmaHalf) + problem = MT.Problem1D.eForm_TotalField(mesh) + problem.pair(survey) + + # Get the fields + fields = problem.fields(sigma) + + # Project the data + data = survey.eval(fields) + + # Calculate the app res and phs + app_r = np.array(getAppResPhs(data))[:,0] + + return np.linalg.norm(np.abs(app_r - np.ones(survey.nFreq)/sigmaHalf)*sigmaHalf) + +def appPhs_TotalFieldNorm(sigmaHalf): + + # Make the survey + survey, sigma, mesh = setupSurvey(sigmaHalf) + problem = MT.Problem1D.eForm_TotalField(mesh) + problem.pair(survey) + + # Get the fields + fields = problem.fields(sigma) + + # Project the data + data = survey.eval(fields) + + # Calculate the app phs + app_p = np.array(getAppResPhs(data))[:,1] + + return np.linalg.norm(np.abs(app_p - np.ones(survey.nFreq)*45)/ 45) + +def appRes_psFieldNorm(sigmaHalf): + + # Make the survey + survey, sigma, mesh = setupSurvey(sigmaHalf,False) + problem = MT.Problem1D.eForm_psField(mesh, sigmaPrimary = sigma) + problem.pair(survey) + + # Get the fields + fields = problem.fields(sigma) + + # Project the data + data = survey.eval(fields) + + # Calculate the app res and phs + app_r = np.array(getAppResPhs(data))[:,0] + + return np.linalg.norm(np.abs(app_r - np.ones(survey.nFreq)/sigmaHalf)*sigmaHalf) + +def appPhs_psFieldNorm(sigmaHalf): + + # Make the survey + survey, sigma, mesh = setupSurvey(sigmaHalf,False) + problem = MT.Problem1D.eForm_psField(mesh, sigmaPrimary = sigma) + problem.pair(survey) + + # Get the fields + fields = problem.fields(sigma) + + # Project the data + data = survey.eval(fields) + + # Calculate the app phs + app_p = np.array(getAppResPhs(data))[:,1] + + return np.linalg.norm(np.abs(app_p - np.ones(survey.nFreq)*45)/ 45) + +class TestAnalytics(unittest.TestCase): + + def setUp(self): + pass + # Total Fields + # def test_appRes2en1(self):self.assertLess(appRes_TotalFieldNorm(2e-1), TOLr) + # def test_appPhs2en1(self):self.assertLess(appPhs_TotalFieldNorm(2e-1), TOLp) + + # def test_appRes2en2(self):self.assertLess(appRes_TotalFieldNorm(2e-2), TOLr) + # def test_appPhs2en2(self):self.assertLess(appPhs_TotalFieldNorm(2e-2), TOLp) + + # def test_appRes2en3(self):self.assertLess(appRes_TotalFieldNorm(2e-3), TOLr) + # def test_appPhs2en3(self):self.assertLess(appPhs_TotalFieldNorm(2e-3), TOLp) + + # def test_appRes2en4(self):self.assertLess(appRes_TotalFieldNorm(2e-4), TOLr) + # def test_appPhs2en4(self):self.assertLess(appPhs_TotalFieldNorm(2e-4), TOLp) + + # def test_appRes2en5(self):self.assertLess(appRes_TotalFieldNorm(2e-5), TOLr) + # def test_appPhs2en5(self):self.assertLess(appPhs_TotalFieldNorm(2e-5), TOLp) + + # def test_appRes2en6(self):self.assertLess(appRes_TotalFieldNorm(2e-6), TOLr) + # def test_appPhs2en6(self):self.assertLess(appPhs_TotalFieldNorm(2e-6), TOLp) + + # Primary/secondary + def test_appRes2en2_ps(self):self.assertLess(appRes_psFieldNorm(2e-2), TOLr) + def test_appPhs2en2_ps(self):self.assertLess(appPhs_psFieldNorm(2e-2), TOLp) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/mt/test_Problem1D_totalDvsPSvsAnalytic.py b/tests/mt/test_Problem1D_totalDvsPSvsAnalytic.py new file mode 100644 index 00000000..2a2e82fd --- /dev/null +++ b/tests/mt/test_Problem1D_totalDvsPSvsAnalytic.py @@ -0,0 +1,135 @@ +import unittest +import SimPEG as simpeg +from SimPEG import MT +from SimPEG.Utils import meshTensor +import numpy as np +# Define the tolerances +TOLr = 5e-2 +TOLp = 5e-2 + + +def setupSurvey(sigmaHalf,tD=True): + + # Frequency + nFreq = 33 + freqs = np.logspace(3,-3,nFreq) + # Make the mesh + ct = 5 + air = meshTensor([(ct,25,1.3)]) + # coreT0 = meshTensor([(ct,15,1.2)]) + # coreT1 = np.kron(meshTensor([(coreT0[-1],15,1.3)]),np.ones((7,))) + core = np.concatenate( ( np.kron(meshTensor([(ct,15,-1.2)]),np.ones((10,))) , meshTensor([(ct,20)]) ) ) + bot = meshTensor([(core[0],15,-1.3)]) + x0 = -np.array([np.sum(np.concatenate((core,bot)))]) + m1d = simpeg.Mesh.TensorMesh([np.concatenate((bot,core,air))], x0=x0) + # Make the model + sigma = np.zeros(m1d.nC) + sigmaHalf + sigma[m1d.gridCC > 0 ] = 1e-8 + sigmaBack = sigma.copy() + # Add structure + shallow = (m1d.gridCC < -200) * (m1d.gridCC > -600) + deep = (m1d.gridCC < -3000) * (m1d.gridCC > -5000) + sigma[shallow] = 1 + sigma[deep] = 0.1 + + rxList = [] + for rxType in ['z1dr','z1di']: + rxList.append(MT.Rx(simpeg.mkvc(np.array([0.0]),2).T,rxType)) + # Source list + srcList =[] + if tD: + for freq in freqs: + srcList.append(MT.SrcMT.polxy_1DhomotD(rxList,freq)) + else: + for freq in freqs: + srcList.append(MT.SrcMT.polxy_1Dprimary(rxList,freq)) + + survey = MT.Survey(srcList) + return survey, sigma, m1d + +def getAppResPhs(MTdata): + # Make impedance + 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 + 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 calculateAnalyticSolution(srcList,mesh,model): + surveyAna = MT.Survey(srcList) + data1D = MT.Data(surveyAna) + for src in surveyAna.srcList: + elev = src.rxList[0].locs[0] + anaEd, anaEu, anaHd, anaHu = MT.Utils.MT1Danalytic.getEHfields(mesh,model,src.freq,elev) + anaE = anaEd+anaEu + anaH = anaHd+anaHu + # Scale the solution + # anaE = (anaEtemp/anaEtemp[-1])#.conj() + # anaH = (anaHtemp/anaEtemp[-1])#.conj() + anaZ = anaE/anaH + for rx in src.rxList: + data1D[src,rx] = getattr(anaZ, rx.projComp) + return data1D + +def dataMis_AnalyticTotalDomain(sigmaHalf): + + # Make the survey + + # Total domain solution + surveyTD, sigma, mesh = setupSurvey(sigmaHalf) + problemTD = MT.Problem1D.eForm_TotalField(mesh) + problemTD.pair(surveyTD) + # Analytic data + dataAnaObj = calculateAnalyticSolution(surveyTD.srcList,mesh,sigma) + # dataTDObj = MT.DataMT.DataMT(surveyTD, surveyTD.dpred(sigma)) + dataTD = surveyTD.dpred(sigma) + dataAna = simpeg.mkvc(dataAnaObj) + return np.all((dataTD - dataAna)/dataAna < 2.) + # surveyTD.dtrue = -simpeg.mkvc(dataAna,2) + # surveyTD.dobs = -simpeg.mkvc(dataAna,2) + # surveyTD.Wd = np.ones(surveyTD.dtrue.shape) #/(np.abs(surveyTD.dtrue)*0.01) + # # Setup the data misfit + # dmis = simpeg.DataMisfit.l2_DataMisfit(surveyTD) + # dmis.Wd = surveyTD.Wd + # return dmis.eval(sigma) + + +def dataMis_AnalyticPrimarySecondary(sigmaHalf): + + # Make the survey + # Primary secondary + surveyPS, sigmaPS, mesh = setupSurvey(sigmaHalf,tD=False) + problemPS = MT.Problem1D.eForm_psField(mesh) + problemPS.sigmaPrimary = sigmaPS + problemPS.pair(surveyPS) + # Analytic data + dataAnaObj = calculateAnalyticSolution(surveyPS.srcList,mesh,sigmaPS) + + dataPS = surveyPS.dpred(sigmaPS) + dataAna = simpeg.mkvc(dataAnaObj) + return np.all((dataPS - dataAna)/dataAna < 2.) + + + +class TestNumericVsAnalytics(unittest.TestCase): + + def setUp(self): + pass + # Total Fields + # def test_appRes2en2(self):self.assertTrue(dataMis_AnalyticTotalDomain(2e-2)) + + # Primary/secondary + def test_appRes2en2_ps(self):self.assertTrue(dataMis_AnalyticPrimarySecondary(2e-2)) + +if __name__ == '__main__': + unittest.main() diff --git a/tests/mt/test_Problem3D_againstAnalytic.py b/tests/mt/test_Problem3D_againstAnalytic.py new file mode 100644 index 00000000..f68e515f --- /dev/null +++ b/tests/mt/test_Problem3D_againstAnalytic.py @@ -0,0 +1,271 @@ +# Test functions +from glob import glob +import numpy as np, sys, os, time, scipy, subprocess +import SimPEG as simpeg +import unittest +from SimPEG import MT +from SimPEG.Utils import meshTensor +from scipy.constants import mu_0 + +TOLr = 5e-2 +TOL = 1e-4 +FLR = 1e-20 # "zero", so if residual below this --> pass regardless of order +CONDUCTIVITY = 1e1 +MU = mu_0 +freq = [1e-1, 2e-1] +addrandoms = True + + +def getInputs(): + """ + Function that returns Mesh, freqs, rx_loc, elev. + """ + # 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]) + # M = simpeg.Mesh.TensorMesh([[(1000,6,-1.5),(1000.,6),(1000,6,1.5)],[(1000,6,-1.5),(1000.,2),(1000,6,1.5)],[(1000,6,-1.3),(1000.,6),(1000,6,1.3)]], x0=['C','C','C'])# Setup the model + M = simpeg.Mesh.TensorMesh([[(1000,6,-1.5),(1000.,4),(1000,6,1.5)],[(1000,6,-1.5),(1000.,4),(1000,6,1.5)],[(500,8,-1.3),(500.,8),(500,8,1.3)]], x0=['C','C','C'])# Setup the model + # Set the frequencies + freqs = np.logspace(1,-3,5) + elev = 0 + + ## Setup the the survey object + # Receiver locations + rx_x, rx_y = np.meshgrid(np.arange(-1000,1001,500),np.arange(-1000,1001,500)) + rx_loc = np.hstack((simpeg.Utils.mkvc(rx_x,2),simpeg.Utils.mkvc(rx_y,2),elev+np.zeros((np.prod(rx_x.shape),1)))) + + return M, freqs, rx_loc, elev + +def random(conds): + ''' Returns a halfspace model based on the inputs''' + M, freqs, rx_loc, elev = getInputs() + + # Backround + sigBG = np.ones(M.nC)*conds + # Add randomness to the model (10% of the value). + sig = np.exp( np.log(sigBG) + np.random.randn(M.nC)*(conds)*1e-1 ) + + return (M, freqs, sig, sigBG, rx_loc) + +def halfSpace(conds): + ''' Returns a halfspace model based on the inputs''' + M, freqs, rx_loc, elev = getInputs() + + # Model + ccM = M.gridCC + # conds = [1e-2] + groundInd = ccM[:,2] < elev + sig = np.zeros(M.nC) + 1e-8 + sig[groundInd] = conds + # Set the background, not the same as the model + sigBG = np.zeros(M.nC) + 1e-8 + sigBG[groundInd] = conds + + return (M, freqs, sig, sigBG, rx_loc) + +def blockInhalfSpace(conds): + ''' Returns a halfspace model based on the inputs''' + M, freqs, rx_loc, elev = getInputs() + + # Model + ccM = M.gridCC + # conds = [1e-2] + groundInd = ccM[:,2] < elev + sig = simpeg.Utils.ModelBuilder.defineBlock(M.gridCC,np.array([-1000,-1000,-1500]),np.array([1000,1000,-1000]),conds) + sig[~groundInd] = 1e-8 + # Set the background, not the same as the model + sigBG = np.zeros(M.nC) + 1e-8 + sigBG[groundInd] = conds[1] + + return (M, freqs, sig, sigBG, rx_loc) + +def twoLayer(conds): + ''' Returns a 2 layer model based on the conductivity values given''' + M, freqs, rx_loc, elev = getInputs() + + # Model + ccM = M.gridCC + groundInd = ccM[:,2] < elev + botInd = ccM[:,2] < -3000 + sig = np.zeros(M.nC) + 1e-8 + sig[groundInd] = conds[1] + sig[botInd] = conds[0] + # Set the background, not the same as the model + sigBG = np.zeros(M.nC) + 1e-8 + sigBG[groundInd] = conds[1] + + + return (M, freqs, sig, sigBG, rx_loc) + + + +def setupSimpegMTfwd_eForm_ps(inputSetup,comp='Imp',singleFreq=False,expMap=True): + M,freqs,sig,sigBG,rx_loc = inputSetup + # Make a receiver list + rxList = [] + if comp == 'All': + for rxType in ['zxxr','zxxi','zxyr','zxyi','zyxr','zyxi','zyyr','zyyi','tzxr','tzxi','tzyr','tzyi']: + rxList.append(MT.Rx(rx_loc,rxType)) + elif comp == 'Imp': + for rxType in ['zxxr','zxxi','zxyr','zxyi','zyxr','zyxi','zyyr','zyyi']: + rxList.append(MT.Rx(rx_loc,rxType)) + elif comp == 'Tip': + for rxType in ['tzxr','tzxi','tzyr','tzyi']: + rxList.append(MT.Rx(rx_loc,rxType)) + else: + rxList.append(MT.Rx(rx_loc,comp)) + # Source list + srcList =[] + + if singleFreq: + srcList.append(MT.SrcMT.polxy_1Dprimary(rxList,singleFreq)) + else: + for freq in freqs: + srcList.append(MT.SrcMT.polxy_1Dprimary(rxList,freq)) + # Survey MT + survey = MT.Survey(srcList) + + ## Setup the problem object + sigma1d = M.r(sigBG,'CC','CC','M')[0,0,:] + if expMap: + problem = MT.Problem3D.eForm_ps(M,sigmaPrimary= np.log(sigma1d) ) + problem.mapping = simpeg.Maps.ExpMap(problem.mesh) + problem.curModel = np.log(sig) + else: + problem = MT.Problem3D.eForm_ps(M,sigmaPrimary= sigma1d) + problem.curModel = sig + problem.pair(survey) + problem.verbose = False + try: + from pymatsolver import MumpsSolver + problem.Solver = MumpsSolver + except: + pass + + return (survey, problem) + +def getAppResPhs(MTdata): + # Make impedance + 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 + recData = MTdata.toRecArray('Complex') + return appResPhs(recData['freq'],recData['zxy']), appResPhs(recData['freq'],recData['zyx']) + +def JvecAdjointTest(inputSetup,comp='All',freq=False): + (M, freqs, sig, sigBG, rx_loc) = inputSetup + survey, problem = setupSimpegMTfwd_eForm_ps(inputSetup,comp='All',singleFreq=freq) + print 'Adjoint test of eForm primary/secondary for {:s} comp at {:s}\n'.format(comp,str(survey.freqs)) + + m = sig + u = problem.fields(m) + + v = np.random.rand(survey.nD,) + # print problem.PropMap.PropModel.nP + w = np.random.rand(problem.mesh.nC,) + + vJw = v.ravel().dot(problem.Jvec(m, w, u)) + wJtv = w.ravel().dot(problem.Jtvec(m, v, u)) + tol = np.max([TOL*(10**int(np.log10(np.abs(vJw)))),FLR]) + print ' vJw wJtv vJw - wJtv tol abs(vJw - wJtv) < tol' + print vJw, wJtv, vJw - wJtv, tol, np.abs(vJw - wJtv) < tol + return np.abs(vJw - wJtv) < tol + +# Test the Jvec derivative +def DerivJvecTest(inputSetup,comp='All',freq=False,expMap=True): + (M, freqs, sig, sigBG, rx_loc) = inputSetup + survey, problem = setupSimpegMTfwd_eForm_ps(inputSetup,comp=comp,singleFreq=freq,expMap=expMap) + print 'Derivative test of Jvec for eForm primary/secondary for {:s} comp at {:s}\n'.format(comp,survey.freqs) + # problem.mapping = simpeg.Maps.ExpMap(problem.mesh) + # problem.sigmaPrimary = np.log(sigBG) + x0 = np.log(sigBG) + # cond = sig[0] + # x0 = np.log(np.ones(problem.mesh.nC)*cond) + # problem.sigmaPrimary = x0 + # if True: + # x0 = x0 + np.random.randn(problem.mesh.nC)*cond*1e-1 + survey = problem.survey + def fun(x): + return survey.dpred(x), lambda x: problem.Jvec(x0, x) + return simpeg.Tests.checkDerivative(fun, x0, num=3, plotIt=False, eps=FLR) + +def DerivProjfieldsTest(inputSetup,comp='All',freq=False): + + survey, problem = setupSimpegMTfwd_eForm_ps(inputSetup,comp,freq) + print 'Derivative test of data projection for eFormulation primary/secondary\n\n' + # problem.mapping = simpeg.Maps.ExpMap(problem.mesh) + # Initate things for the derivs Test + src = survey.srcList[0] + rx = src.rxList[0] + + u0x = np.random.randn(survey.mesh.nE)+np.random.randn(survey.mesh.nE)*1j + u0y = np.random.randn(survey.mesh.nE)+np.random.randn(survey.mesh.nE)*1j + u0 = np.vstack((simpeg.mkvc(u0x,2),simpeg.mkvc(u0y,2))) + f0 = problem.fieldsPair(survey.mesh,survey) + # u0 = np.hstack((simpeg.mkvc(u0_px,2),simpeg.mkvc(u0_py,2))) + f0[src,'e_pxSolution'] = u0[:len(u0)/2]#u0x + f0[src,'e_pySolution'] = u0[len(u0)/2::]#u0y + + 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.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) + +def appResPhsHalfspace_eFrom_ps_Norm(sigmaHalf,appR=True,expMap=False): + if appR: + label = 'resistivity' + else: + label = 'phase' + # Make the survey and the problem + survey, problem = setupSimpegMTfwd_eForm_ps(halfSpace(sigmaHalf),expMap=expMap) + print 'Apperent {:s} test of eFormulation primary/secondary at {:g}\n\n'.format(label,sigmaHalf) + + data = problem.dataPair(survey,survey.dpred(problem.curModel)) + # Calculate the app phs + app_rpxy, app_rpyx = np.array(getAppResPhs(data)) + if appR: + return np.all(np.abs(app_rpxy[0,:] - 1./sigmaHalf) * sigmaHalf < .4) + else: + return np.all(np.abs(app_rpxy[1,:] + 135) / 135 < .4) + +class TestAnalytics(unittest.TestCase): + + def setUp(self): + pass + # # Test apparent resistivity and phase + def test_appRes1en2(self):self.assertTrue(appResPhsHalfspace_eFrom_ps_Norm(1e-2)) + def test_appPhs1en2(self):self.assertTrue(appResPhsHalfspace_eFrom_ps_Norm(1e-2,False)) + + def test_appRes1en3(self):self.assertTrue(appResPhsHalfspace_eFrom_ps_Norm(1e-3)) + def test_appPhs1en3(self):self.assertTrue(appResPhsHalfspace_eFrom_ps_Norm(1e-3,False)) + + # Do a derivative test + def test_derivProj1(self):self.assertTrue(DerivProjfieldsTest(halfSpace(1e-2))) + + # Do a derivative test of Jvec + # def test_derivJvec_zxxr(self):self.assertTrue(DerivJvecTest(random(1e-2),'zxxr',.1)) + # def test_derivJvec_zxxi(self):self.assertTrue(DerivJvecTest(random(1e-2),'zxxi',.1)) + # def test_derivJvec_zxyr(self):self.assertTrue(DerivJvecTest(random(1e-2),'zxyr',.1)) + # def test_derivJvec_zxyi(self):self.assertTrue(DerivJvecTest(random(1e-2),'zxyi',.1)) + # def test_derivJvec_zyxr(self):self.assertTrue(DerivJvecTest(random(1e-2),'zyxr',.1)) + # def test_derivJvec_zyxi(self):self.assertTrue(DerivJvecTest(random(1e-2),'zyxi',.1)) + # def test_derivJvec_zyyr(self):self.assertTrue(DerivJvecTest(random(1e-2),'zyyr',.1)) + # def test_derivJvec_zyyi(self):self.assertTrue(DerivJvecTest(random(1e-2),'zyyi',.1)) + def test_derivJvec_All(self):self.assertTrue(DerivJvecTest(random(1e-2),'All',.1)) + + # Test the adjoint of Jvec and Jtvec + # def test_JvecAdjoint_zxxr(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zxxr',.1)) + # def test_JvecAdjoint_zxxi(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zxxi',.1)) + # def test_JvecAdjoint_zxyr(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zxyr',.1)) + # def test_JvecAdjoint_zxyi(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zxyi',.1)) + # def test_JvecAdjoint_zyxr(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zyxr',.1)) + # def test_JvecAdjoint_zyxi(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zyxi',.1)) + # def test_JvecAdjoint_zyyr(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zyyr',.1)) + # def test_JvecAdjoint_zyyi(self):self.assertTrue(JvecAdjointTest(random(1e-2),'zyyi',.1)) + def test_JvecAdjoint_All(self):self.assertTrue(JvecAdjointTest(random(1e-2),'All',.1)) + +if __name__ == '__main__': + unittest.main()