def model_fields(A, B, zcLayer, dzLayer, xc, zc, r, sigLayer, sigTarget, sigHalf): # Create halfspace model mhalf = sigHalf * np.ones([mesh.nC]) # Add layer to model mLayer = addLayer2Mod(zcLayer, dzLayer, mhalf, sigLayer) # Add plate or cylinder # fullMod = addPlate2Mod(xc,zc,dx,dz,rotAng,LayerMod,sigTarget) mtrue = addCylinder2Mod(xc, zc, r, mLayer, sigTarget) Mx = np.empty(shape=(0, 2)) Nx = np.empty(shape=(0, 2)) rx = DC.Rx.Dipole(Mx, Nx) if B == []: src = DC.Src.Pole([rx], np.r_[A, 0.0]) else: src = DC.Src.Dipole([rx], np.r_[A, 0.0], np.r_[B, 0.0]) survey = DC.Survey([src]) survey_prim = DC.Survey([src]) problem = DC.Problem3D_CC(mesh, sigmaMap=sigmaMap) problem_prim = DC.Problem3D_CC(mesh, sigmaMap=sigmaMap) problem.Solver = SolverLU problem_prim.Solver = SolverLU problem.pair(survey) problem_prim.pair(survey_prim) primary_field = problem_prim.fields(mhalf) total_field = problem.fields(mtrue) return mtrue, mhalf, src, primary_field, total_field
def plate_fields(A, B, dx, dz, xc, zc, rotAng, sigplate, sighalf): # Create halfspace model mhalf = np.log(sighalf * np.ones([mesh.nC])) # Create true model with plate mtrue = createPlateMod(xc, zc, dx, dz, rotAng, sigplate, sighalf) Mx = np.empty(shape=(0, 2)) Nx = np.empty(shape=(0, 2)) rx = DC.Rx.Dipole(Mx, Nx) if B == []: src = DC.Src.Pole([rx], np.r_[A, 0.0]) else: src = DC.Src.Dipole([rx], np.r_[A, 0.0], np.r_[B, 0.0]) survey = DC.Survey([src]) survey_prim = DC.Survey([src]) problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem_prim = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.Solver = SolverLU problem_prim.Solver = SolverLU problem.pair(survey) problem_prim.pair(survey_prim) primary_field = problem_prim.fields(mhalf) total_field = problem.fields(mtrue) return mtrue, mhalf, src, primary_field, total_field
def simpeg_survey(self): """ Create the measurement setup as an instance of DC Survey. :return: DC.Survey instance """ if self._simpeg_survey is None: probe_points = self.points.all_points group_by_cc = {} for ca, cb, pa, pb in self.measurements: group_by_cc.setdefault((ca, cb), []) group_by_cc[(ca, cb)].append((pa, pb)) src_list = [] sorted = [(cc, pp) for cc, pp in group_by_cc.items()] sorted.sort() for cc, pp_list in sorted: rx_list = [ DC.Rx.Dipole(probe_points[pp[0], :], probe_points[pp[1], :]) for pp in pp_list ] I = 1.0 src = DC.Src.Dipole(rx_list, probe_points[cc[0], :], probe_points[cc[1], :], current=I) src_list.append(src) self._simpeg_survey = DC.Survey(src_list) if self._values is not None: self._simpeg_survey.dobs = self._values self._simpeg_survey.std = self._errors return self._simpeg_survey
def setUp(self): mesh = Mesh.TensorMesh([30, 30], x0=[-0.5, -1.]) sigma = np.ones(mesh.nC) model = np.log(sigma) prob = DC.Problem3D_CC(mesh, rhoMap=Maps.ExpMap(mesh)) rx = DC.Rx.Pole( Utils.ndgrid([mesh.vectorCCx, np.r_[mesh.vectorCCy.max()]]) ) src = DC.Src.Dipole( [rx], np.r_[-0.25, mesh.vectorCCy.max()], np.r_[0.25, mesh.vectorCCy.max()] ) survey = DC.Survey([src]) prob.pair(survey) self.std = 0.01 survey.std = self.std dobs = survey.makeSyntheticData(model) self.eps = 1e-8 * np.min(np.abs(dobs)) survey.eps = self.eps dmis = DataMisfit.l2_DataMisfit(survey) self.model = model self.mesh = mesh self.survey = survey self.prob = prob self.dobs = dobs self.dmis = dmis
def setUp(self): cs = 10 nc = 20 npad = 10 mesh = Mesh.CylMesh([[(cs, nc), (cs, npad, 1.3)], np.r_[2 * np.pi], [(cs, npad, -1.3), (cs, nc), (cs, npad, 1.3)]]) mesh.x0 = np.r_[0., 0., -mesh.hz[:npad + nc].sum()] # receivers rx_x = np.linspace(10, 200, 20) rx_z = np.r_[-5] rx_locs = Utils.ndgrid([rx_x, np.r_[0], rx_z]) rx_list = [DC.Rx.BaseRx(rx_locs, 'ex')] # sources src_a = np.r_[0., 0., -5.] src_b = np.r_[55., 0., -5.] src_list = [DC.Src.Dipole(rx_list, locA=src_a, locB=src_b)] self.mesh = mesh self.sigma_map = Maps.ExpMap(mesh) * Maps.InjectActiveCells( mesh, mesh.gridCC[:, 2] <= 0, np.log(1e-8)) self.prob = DC.Problem3D_CC(mesh, sigmaMap=self.sigma_map, Solver=Pardiso, bc_type="Dirichlet") self.survey = DC.Survey(src_list) self.prob.pair(self.survey)
def setUp(self): 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), (cs, 7, -1.3)] mesh = Mesh.TensorMesh([hx, hy, hz], x0="CCC") sigma = np.ones(mesh.nC)*1e-2 x = mesh.vectorCCx[(mesh.vectorCCx > -155.) & (mesh.vectorCCx < 155.)] y = mesh.vectorCCx[(mesh.vectorCCy > -155.) & (mesh.vectorCCy < 155.)] Aloc = np.r_[-200., 0., 0.] Bloc = np.r_[200., 0., 0.] M = Utils.ndgrid(x-25., y, np.r_[0.]) N = Utils.ndgrid(x+25., y, np.r_[0.]) phiA = EM.Analytics.DCAnalytic_Pole_Dipole( Aloc, [M, N], 1e-2, earth_type="wholespace" ) phiB = EM.Analytics.DCAnalytic_Pole_Dipole( Bloc, [M, N], 1e-2, earth_type="wholespace" ) data_anal = phiA-phiB rx = DC.Rx.Dipole(M, N) src = DC.Src.Dipole([rx], Aloc, Bloc) survey = DC.Survey([src]) self.survey = survey self.mesh = mesh self.sigma = sigma self.data_anal = data_anal
def setUp(self): cs = 25. hx = [(cs, 7, -1.5), (cs, 21), (cs, 7, 1.5)] hy = [(cs, 7, -1.5), (cs, 21), (cs, 7, 1.5)] hz = [(cs, 7, -1.5), (cs, 20)] mesh = Mesh.TensorMesh([hx, hy, hz], x0="CCN") sigma = np.ones(mesh.nC) * 1e-2 x = mesh.vectorCCx[(mesh.vectorCCx > -155.) & (mesh.vectorCCx < 155.)] y = mesh.vectorCCy[(mesh.vectorCCy > -155.) & (mesh.vectorCCy < 155.)] Aloc = np.r_[-200., 0., 0.] M = Utils.ndgrid(x, y, np.r_[0.]) phiA = EM.Analytics.DCAnalytic_Pole_Pole(Aloc, M, 1e-2, earth_type="halfspace") data_ana = phiA rx = DC.Rx.Pole(M) src = DC.Src.Pole([rx], Aloc) survey = DC.Survey([src]) self.survey = survey self.mesh = mesh self.sigma = sigma self.data_ana = data_ana
def getSensitivity(survey, A, B, M, N, model): if survey == "Dipole-Dipole": rx = DC.Rx.Dipole(np.r_[M, 0.0], np.r_[N, 0.0]) src = DC.Src.Dipole([rx], np.r_[A, 0.0], np.r_[B, 0.0]) elif survey == "Pole-Dipole": rx = DC.Rx.Dipole(np.r_[M, 0.0], np.r_[N, 0.0]) src = DC.Src.Pole([rx], np.r_[A, 0.0]) elif survey == "Dipole-Pole": rx = DC.Rx.Pole(np.r_[M, 0.0]) src = DC.Src.Dipole([rx], np.r_[A, 0.0], np.r_[B, 0.0]) elif survey == "Pole-Pole": rx = DC.Rx.Pole(np.r_[M, 0.0]) src = DC.Src.Pole([rx], np.r_[A, 0.0]) # Model mappings expmap = Maps.ExpMap(mesh) mapping = expmap survey = DC.Survey([src]) problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.Solver = SolverLU problem.pair(survey) fieldObj = problem.fields(model) J = problem.Jtvec(model, np.array([1.0]), f=fieldObj) return J
def readReservoirDC(fname): f = open(fname, 'r') data = f.readlines() temp = data[3].split() nelec, ndata, aspacing = int(temp[0]), int(temp[1]), float(temp[2]) height_water = float(data[4 + ndata + 3].split()[0]) height_dam = float(data[4 + ndata + 4].split()[0]) ntx = nelec - 2 datalist = [] for iline, line in enumerate(data[4:4 + ndata]): # line = line.replace(ignorevalue, 'nan') linelist = line.split() datalist.append(np.array(map(float, linelist))) DAT = np.vstack(datalist) datalistSRC = [] srcList = [] # for i in range(ntx-1): for i in range(ntx - 1): txloc = np.array([i + 2, i + 1.]) ind = (DAT[:, :2] == txloc).sum(axis=1) == 2. temp = DAT[ind, :] datalistSRC.append(temp) e = np.zeros_like(temp[:, 2]) rxtemp = DC.Rx.Dipole(np.c_[temp[:, 2] * aspacing, e, e], np.c_[temp[:, 3] * aspacing, e, e]) srctemp = DC.Src.Dipole([rxtemp], np.r_[txloc[1] * aspacing, 0., 0.], np.r_[txloc[0] * aspacing, 0., 0.]) srcList.append(srctemp) DAT_src = np.vstack(datalistSRC) survey = DC.Survey(srcList) survey.dobs = DAT_src[:, -1] survey.height_water = height_water survey.height_dam = height_dam return survey
def run(plotIt=True): cs = 25. hx = [(cs, 7, -1.3), (cs, 21), (cs, 7, 1.3)] hy = [(cs, 7, -1.3), (cs, 21), (cs, 7, 1.3)] 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.Rx.Dipole(xyz_rxP, xyz_rxN) src = DC.Src.Dipole([rx], np.r_[-200, 0, -12.5], np.r_[+200, 0, -12.5]) survey = DC.Survey([src]) problem = DC.Problem3D_CC(mesh) problem.pair(survey) try: from pymatsolver import MumpsSolver problem.Solver = MumpsSolver except Exception, e: pass
def run(plotIt=True): cs = 25. hx = [(cs, 7, -1.3), (cs, 21), (cs, 7, 1.3)] hy = [(cs, 7, -1.3), (cs, 21), (cs, 7, 1.3)] 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.Rx.Dipole(xyz_rxP, xyz_rxN) src = DC.Src.Dipole([rx], np.r_[-200, 0, -12.5], np.r_[+200, 0, -12.5]) survey = DC.Survey([src]) problem = DC.Problem3D_CC(mesh, Solver=Solver, sigma=sigma) problem.pair(survey) data = survey.dpred() 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: fig, ax = plt.subplots(1, 2, figsize=(12, 5)) vmin = np.r_[data, data_ana].min() vmax = np.r_[data, data_ana].max() dat0 = ax[0].contourf(X, Y, Data_ana, 60, vmin=vmin, vmax=vmax) dat1 = ax[1].contourf(X, Y, Data, 60, vmin=vmin, vmax=vmax) plt.colorbar(dat0, orientation='horizontal', ax=ax[0]) plt.colorbar(dat1, orientation='horizontal', ax=ax[1]) ax[1].set_title('Analytic') ax[0].set_title('Computed') return np.linalg.norm(data-data_ana)/np.linalg.norm(data_ana)
def setUp(self): cs = 12.5 npad = 2 hx = [(cs, npad, -1.3), (cs, 21), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, 21), (cs, npad, 1.3)] hz = [(cs, npad, -1.3), (cs, 20)] mesh = Mesh.TensorMesh([hx, hy, hz], x0="CCN") x = mesh.vectorCCx[(mesh.vectorCCx > -80.) & (mesh.vectorCCx < 80.)] y = mesh.vectorCCx[(mesh.vectorCCy > -80.) & (mesh.vectorCCy < 80.)] Aloc = np.r_[-100., 0., 0.] Bloc = np.r_[100., 0., 0.] M = Utils.ndgrid(x-12.5, y, np.r_[0.]) N = Utils.ndgrid(x+12.5, y, np.r_[0.]) radius = 50. xc = np.r_[0., 0., -100] blkind = Utils.ModelBuilder.getIndicesSphere(xc, radius, mesh.gridCC) sigmaInf = np.ones(mesh.nC)*1e-2 eta = np.zeros(mesh.nC) eta[blkind] = 0.1 sigma0 = sigmaInf*(1.-eta) rx = DC.Rx.Dipole(M, N) src = DC.Src.Dipole([rx], Aloc, Bloc) surveyDC = DC.Survey([src]) self.surveyDC = surveyDC self.mesh = mesh self.sigmaInf = sigmaInf self.sigma0 = sigma0 self.src = src self.eta = eta
def generateSurvey(rx, tx, min_dipole_size, max_dipole_size): """ Generates a survey to through into a forward model INPUT: rx_dx = array of Rx x spacings rx_dy = array of Rx y spacings Tx_dx = array of Tx x spacings Tx_dy = array of Tx y spacings """ SrcList = [] rx_length = rx.shape[0] for idk in range(tx.shape[0]): rx1 = [] rx2 = [] for idx in range(rx_length): node1 = rx[idx, :] for idj in range(idx, rx_length): node2 = rx[idj, :] dist = np.sqrt(np.sum((node1 - node2)**2)) distE = np.abs(node1[0] - tx[idk, 0]) if distE < 80: if (min_dipole_size) < dist < (max_dipole_size): rx1.append(node1) rx2.append(node2) # print(dist) rx1 = np.asarray(rx1) rx2 = np.asarray(rx2) rxClass = DC.Rx.Dipole(rx1, rx2) srcClass = DC.Src.Pole([rxClass], tx[idk, :]) SrcList.append(srcClass) survey = DC.Survey(SrcList) return survey
def _setupSurvey(self): epp = self.tunnelParams.getSingleArrayTunnelCelingEnds() p1, s1 = Tunnel_SurveyTools.getLinearArraySurvey(epp, 5, self.surveyType) epp = self.tunnelParams.getSingleArrayFloorEnds() p2, s2 = Tunnel_SurveyTools.getLinearArraySurvey(epp, 5, self.surveyType) epp = self.tunnelParams.getSingleArrayRightSideEnds() p3, s3 = Tunnel_SurveyTools.getLinearArraySurvey(epp, 5, self.surveyType) epp = self.tunnelParams.getSingleArrayLeftSideEnds() p4, s4 = Tunnel_SurveyTools.getLinearArraySurvey(epp, 5, self.surveyType) self.allSurveyPoints = numpy.vstack((p1, p2, p3, p4)) self.survey = DC.Survey(s1.srcList + s2.srcList + s3.srcList + s4.srcList) pass
def cylinder_fields(A, B, r, sigcyl, sighalf, xc=0.0, zc=-20.0): circhalf = np.r_[np.log(sighalf), np.log(sighalf), xc, zc, r] circtrue = np.r_[np.log(sigcyl), np.log(sighalf), xc, zc, r] mhalf = circmap * circhalf mtrue = circmap * circtrue Mx = np.empty(shape=(0, 2)) Nx = np.empty(shape=(0, 2)) # rx = DC.Rx.Dipole_ky(Mx,Nx) rx = DC.Rx.Dipole(Mx, Nx) if B == []: src = DC.Src.Pole([rx], np.r_[A, 0.0]) else: src = DC.Src.Dipole([rx], np.r_[A, 0.0], np.r_[B, 0.0]) # survey = DC.Survey_ky([src]) survey = DC.Survey([src]) survey_prim = DC.Survey([src]) # problem = DC.Problem2D_CC(mesh, sigmaMap = sigmaMap) problem = DC.Problem3D_CC(mesh, sigmaMap=sigmaMap) problem_prim = DC.Problem3D_CC(mesh, sigmaMap=sigmaMap) problem.Solver = SolverLU problem_prim.Solver = SolverLU problem.pair(survey) problem_prim.pair(survey_prim) primary_field = problem_prim.fields(mhalf) # phihalf = f[src, 'phi', 15] # ehalf = f[src, 'e'] # jhalf = f[src, 'j'] # charge = f[src, 'charge'] total_field = problem.fields(mtrue) # phi = f[src, 'phi', 15] # e = f[src, 'e'] # j = f[src, 'j'] # charge = f[src, 'charge'] return mtrue, mhalf, src, total_field, primary_field
def _getSimpleLinearArraySurvey(points): sources = [] for ii in range(points.shape[0] - 3): Apos = points[ii] Bpos = points[ii + 1] Mpos = points[ii + 2:-1] Npos = points[ii + 3:] receiver = DC.Rx.Dipole(Mpos, Npos) source = DC.Src.Dipole([receiver], Apos, Bpos) sources.append(source) survey = DC.Survey(sources) return survey pass
def __init__(self, **kwargs): super(SimulationDC, self).__init__(**kwargs) self._prob = DC.Problem3D_CC( self.meshGenerator.mesh, sigmaMap=self.physprops.wires.sigma, bc_type='Dirichlet', Solver=Pardiso ) self._src = DC.Src.Dipole([], self.src_a, self.src_b) self._survey = DC.Survey([self._src]) self._prob.pair(self._survey)
def setUp(self): mesh = Mesh.TensorMesh([30, 30], x0=[-0.5, -1.]) sigma = np.random.rand(mesh.nC) model = np.log(sigma) prob = DC.Problem3D_CC(mesh, rhoMap=Maps.ExpMap(mesh)) prob1 = DC.Problem3D_CC(mesh, rhoMap=Maps.ExpMap(mesh)) rx = DC.Rx.Pole( Utils.ndgrid([mesh.vectorCCx, np.r_[mesh.vectorCCy.max()]])) rx1 = DC.Rx.Pole( Utils.ndgrid([mesh.vectorCCx, np.r_[mesh.vectorCCy.min()]])) src = DC.Src.Dipole([rx], np.r_[-0.25, mesh.vectorCCy.max()], np.r_[0.25, mesh.vectorCCy.max()]) src1 = DC.Src.Dipole([rx1], np.r_[-0.25, mesh.vectorCCy.max()], np.r_[0.25, mesh.vectorCCy.max()]) survey = DC.Survey([src]) prob.pair(survey) survey1 = DC.Survey([src1]) prob1.pair(survey1) dobs0 = survey.makeSyntheticData(model) dobs1 = survey1.makeSyntheticData(model) self.mesh = mesh self.model = model self.survey0 = survey self.prob0 = prob self.survey1 = survey1 self.prob1 = prob1 self.dmis0 = DataMisfit.l2_DataMisfit(self.survey0) self.dmis1 = DataMisfit.l2_DataMisfit(self.survey1) self.dmiscobmo = self.dmis0 + self.dmis1
def __init__(self, **kwargs): super(SimulationDC, self).__init__(**kwargs) self._prob = DC.Problem3D_CC(self.meshGenerator.mesh, sigmaMap=self.physprops.wires.sigma, bc_type='Dirichlet', Solver=Solver) self._srcList = [ DC.Src.Dipole([], self.src_a[i, :], self.src_b[i, :]) for i in range(self.src_a.shape[0]) ] # self._src = DC.Src.Dipole([], self.src_a, self.src_b) self._survey = DC.Survey(self._srcList) self._prob.pair(self._survey)
def _getDipoleDipoleConfigurationSurvey(points): sources = [] pb = points.shape[0] for ii in range(pb - 3): Apos = points[ii] Bpos = points[ii + 1] Mpos = points[ii + 2:-1] Npos = points[ii + 3:] if ii < pb - 4: Mpos = numpy.vstack([Mpos, points[pb - 3]]) Npos = numpy.vstack([Npos, points[pb - 1]]) receiver = DC.Rx.Dipole(Mpos, Npos) source = DC.Src.Dipole([receiver], Apos, Bpos) sources.append(source) survey = DC.Survey(sources) return survey pass
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.Survey(srcList) problem = DC.Problem3D_N(mesh, rhoMap=Maps.IdentityMap(mesh), storeJ=True) 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 setUp(self): 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], x0="CCN") sigma = np.ones(mesh.nC) * 1e-2 x = mesh.vectorCCx[(mesh.vectorCCx > -155.) & (mesh.vectorCCx < 155.)] y = mesh.vectorCCx[(mesh.vectorCCy > -155.) & (mesh.vectorCCy < 155.)] Aloc = np.r_[-200., 0., 0.] Bloc = np.r_[200., 0., 0.] M = Utils.ndgrid(x - 25., y, np.r_[0.]) N = Utils.ndgrid(x + 25., y, np.r_[0.]) phiA = EM.Analytics.DCAnalyticHalf(Aloc, [M, N], 1e-2, earth_type="halfspace") phiB = EM.Analytics.DCAnalyticHalf(Bloc, [M, N], 1e-2, earth_type="halfspace") data_anal = phiA - phiB rx = DC.Rx.Dipole(M, N) src = DC.Src.Dipole([rx], Aloc, Bloc) survey = DC.Survey([src]) self.survey = survey self.mesh = mesh self.sigma = sigma self.data_anal = data_anal try: from pymatsolver import MumpsSolver self.Solver = MumpsSolver except ImportError, e: self.Solver = SolverLU
def getSensitivity(survey, A, B, M, N, model): if (survey == "Dipole-Dipole"): rx = DC.Rx.Dipole(np.r_[M, 0.], np.r_[N, 0.]) src = DC.Src.Dipole([rx], np.r_[A, 0.], np.r_[B, 0.]) elif (survey == "Pole-Dipole"): rx = DC.Rx.Dipole(np.r_[M, 0.], np.r_[N, 0.]) src = DC.Src.Pole([rx], np.r_[A, 0.]) elif (survey == "Dipole-Pole"): rx = DC.Rx.Pole(np.r_[M, 0.]) src = DC.Src.Dipole([rx], np.r_[A, 0.], np.r_[B, 0.]) elif (survey == "Pole-Pole"): rx = DC.Rx.Pole(np.r_[M, 0.]) src = DC.Src.Pole([rx], np.r_[A, 0.]) Srv = DC.Survey([src]) problem = DC.Problem3D_CC(mesh, sigmaMap=sigmaMap) problem.Solver = SolverLU problem.pair(Srv) fieldObj = problem.fields(model) J = problem.Jtvec(model, np.array([1.]), f=fieldObj) return J
n=8) # Line 3 xmin, xmax = -15., 15. ymin, ymax = -5., -5. zmin, zmax = 0, 0 endl = np.array([[xmin, ymin, zmin], [xmax, ymax, zmax]]) survey3 = DCUtils.gen_DCIPsurvey(endl, "dipole-dipole", dim=mesh.dim, a=3, b=3, n=8) # Concatenate lines survey = DC.Survey(survey1.srcList + survey2.srcList + survey3.srcList) # Setup Problem with exponential mapping and Active cells only in the core mesh expmap = Maps.ExpMap(mesh) mapactive = Maps.InjectActiveCells(mesh=mesh, indActive=actind, valInactive=-5.) mapping = expmap * mapactive problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.pair(survey) problem.Solver = Solver survey.dpred(mtrue[actind]) survey.makeSyntheticData(mtrue[actind], std=0.05, force=True) # Tikhonov Inversion
locB = np.r_[14. - 1., z] #M = np.c_[np.arange(locA[0]+1.,12.,2),np.ones(nSrc-i)*z] #N = np.c_[np.arange(locA[0]+3.,14.,2),np.ones(nSrc-i)*z] M = np.c_[np.arange(-12., 10 + 1, 2), np.ones(12) * z] N = np.c_[np.arange(-10., 12 + 1, 2), np.ones(12) * z] rx = DC.Rx.Dipole(M, N) src = DC.Src.Dipole([rx], locA, locB) srclist.append(src) #print "line2",locA,locB,"\n",[M,N],"\n" #rx = DC.Rx.Dipole(-M,-N) #src= DC.Src.Dipole([rx],-locA,-locB) #srclist.append(src) mapping = Maps.ExpMap(mesh) survey = DC.Survey(srclist) problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.pair(survey) problem.Solver = PardisoSolver survey.dpred(mtrue) survey.makeSyntheticData(mtrue, std=0.05, force=True) print '# of data: ', survey.dobs.shape #Simple Inversion regmesh = mesh m0 = (-5.) * np.ones(mapping.nP) dmis = DataMisfit.l2_DataMisfit(survey) reg = Regularization.Tikhonov(regmesh) #,mapping = mapping)#,indActive=actind) reg.mref = m0
locB = np.r_[14. - 1., z] #M = np.c_[np.arange(locA[0]+1.,12.,2),np.ones(nSrc-i)*z] #N = np.c_[np.arange(locA[0]+3.,14.,2),np.ones(nSrc-i)*z] M = np.c_[np.arange(-12., 10 + 1, 2), np.ones(12) * z] N = np.c_[np.arange(-10., 12 + 1, 2), np.ones(12) * z] rx = DC.Rx.Dipole(M, N) src = DC.Src.Dipole([rx], locA, locB) srclist.append(src) #print "line2",locA,locB,"\n",[M,N],"\n" #rx = DC.Rx.Dipole(-M,-N) #src= DC.Src.Dipole([rx],-locA,-locB) #srclist.append(src) mapping = Maps.ExpMap(mesh) survey = DC.Survey(srclist) problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.pair(survey) problem.Solver = PardisoSolver survey.dobs = survey.dpred(mtrue) survey.std = 0.05 * np.ones_like(survey.dobs) survey.eps = 1e-5 * np.linalg.norm(survey.dobs) dmisAll = DataMisfit.l2_DataMisfit(survey) print '# of data: ', survey.dobs.shape class SimultaneousSrc(DC.Src.BaseSrc): """ Dipole source """
def gen_DCIPsurvey(endl, mesh, surveyType, 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 surveyType -> "dipole-dipole" (dipole-dipole) | "pole-dipole" (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 """ 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 = int(np.floor(dl_len / a)) # Compute discrete pole location along line stn_x = endl[0, 0] + np.array(range(int(nstn))) * dl_x * a stn_y = endl[0, 1] + np.array(range(int(nstn))) * dl_y * a if mesh.dim == 2: ztop = mesh.vectorNy[-1] # Create line of P1 locations M = np.c_[stn_x, np.ones(nstn).T * ztop] # Create line of P2 locations N = np.c_[stn_x + a * dl_x, np.ones(nstn).T * ztop] elif mesh.dim == 3: ztop = mesh.vectorNz[-1] # Create line of P1 locations M = np.c_[stn_x, stn_y, np.ones(nstn).T * ztop] # Create line of P2 locations N = np.c_[stn_x + a * dl_x, stn_y + a * dl_y, np.ones(nstn).T * ztop] # Build list of Tx-Rx locations depending on survey type # Dipole-dipole: Moving tx with [a] spacing -> [AB a MN1 a MN2 ... a MNn] # Pole-dipole: Moving pole on one end -> [A a MN1 a MN2 ... MNn a B] SrcList = [] if surveyType != 'gradient': for ii in range(0, int(nstn) - 1): if surveyType == 'dipole-dipole': tx = np.c_[M[ii, :], N[ii, :]] elif surveyType == 'pole-dipole': tx = np.c_[M[ii, :], M[ii, :]] else: raise Exception( 'The surveyType must be "dipole-dipole" or "pole-dipole"') # 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 = int(np.min([np.floor((AB - b) / a), n])) # Check if there is enough space, else break the loop if nstn <= 0: continue # Compute discrete pole location along line stn_x = N[ii, 0] + dl_x * b + np.array(range(int(nstn))) * dl_x * a stn_y = N[ii, 1] + dl_y * b + np.array(range(int(nstn))) * dl_y * a # Create receiver poles if mesh.dim == 3: # Create line of P1 locations P1 = np.c_[stn_x, stn_y, np.ones(nstn).T * ztop] # Create line of P2 locations P2 = np.c_[stn_x + a * dl_x, stn_y + a * dl_y, np.ones(nstn).T * ztop] rxClass = DC.Rx.Dipole(P1, P2) elif mesh.dim == 2: # Create line of P1 locations P1 = np.c_[stn_x, np.ones(nstn).T * ztop] # Create line of P2 locations P2 = np.c_[stn_x + a * dl_x, np.ones(nstn).T * ztop] rxClass = DC.Rx.Dipole_ky(P1, P2) if surveyType == 'dipole-dipole': srcClass = DC.Src.Dipole([rxClass], M[ii, :], N[ii, :]) elif surveyType == 'pole-dipole': srcClass = DC.Src.Pole([rxClass], M[ii, :]) SrcList.append(srcClass) elif surveyType == 'gradient': # Gradient survey takes the "b" parameter to define the limits of a # square survey grid. The pole seperation within the receiver grid is # define the "a" parameter. # 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 # Define the size of the survey grid (square for now) box_l = np.sqrt((min_x - max_x)**2 + (min_y - max_y)**2) box_w = box_l / 2. nstn = int(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) npoles = int(nstn * len(lind)) rx = np.zeros([npoles, 6]) for ii in range(len(lind)): # Move station location to current survey line This is a # perpendicular move then line survey orientation, hence the y, x # switch lxx = stn_x - lind[ii] * a * dl_y lyy = stn_y + lind[ii] * a * dl_x M = np.c_[lxx, lyy, np.ones(nstn).T * ztop] N = np.c_[lxx + a * dl_x, lyy + a * dl_y, np.ones(nstn).T * ztop] rx[(ii * nstn):((ii + 1) * nstn), :] = np.c_[M, N] if mesh.dim == 3: rxClass = DC.Rx.Dipole(rx[:, :3], rx[:, 3:]) elif mesh.dim == 2: M = M[:, [0, 2]] N = N[:, [0, 2]] rxClass = DC.Rx.Dipole_ky(rx[:, [0, 2]], rx[:, [3, 5]]) srcClass = DC.Src.Dipole([rxClass], (endl[0, :]), (endl[1, :])) SrcList.append(srcClass) else: print( """surveyType must be either 'pole-dipole', 'dipole-dipole' or 'gradient'. """ ) survey = DC.Survey(SrcList) return survey
def DC2Dsurvey(mtrue, flag="PoleDipole", nmax=8): if flag == "PoleDipole": ntx = xr.size - 2 elif flag == "DipolePole": ntx = xr.size - 2 elif flag == "DipoleDipole": ntx = xr.size - 3 else: raise Exception("Not Implemented") xzlocs = getPseudoLocs(xr, ntx, nmax, flag) txList = [] zloc = -cs / 2.0 for i in range(ntx): if flag == "PoleDipole": A = np.r_[xr[i], zloc] B = np.r_[mesh.vectorCCx.min(), zloc] if i < ntx - nmax + 1: Mx = xr[i + 1:i + 1 + nmax] _, Mz = get_Surface(mtrue, Mx) Nx = xr[i + 2:i + 2 + nmax] _, Nz = get_Surface(mtrue, Nx) M = np.c_[Mx, Mz] N = np.c_[Nx, Nz] else: Mx = xr[i + 1:ntx + 1] _, Mz = get_Surface(mtrue, Mx) Nx = xr[i + 2:i + 2 + nmax] _, Nz = get_Surface(mtrue, Nx) M = np.c_[Mx, Mz] N = np.c_[Nx, Nz] elif flag == "DipolePole": A = np.r_[xr[i], zloc] B = np.r_[xr[i + 1], zloc] if i < ntx - nmax + 1: Mx = xr[i + 2:i + 2 + nmax] _, Mz = get_Surface(mtrue, Mx) Nx = np.ones(nmax) * mesh.vectorCCx.max() _, Nz = get_Surface(mtrue, Nx) M = np.c_[Mx, Mz] N = np.c_[Nx, Nz] else: Mx = xr[i + 2:ntx + 2] _, Mz = get_Surface(mtrue, Mx) Nx = np.ones(ntx - i) * mesh.vectorCCx.max() _, Nz = get_Surface(mtrue, Nx) M = np.c_[Mx, Mz] N = np.c_[Nx, Nz] elif flag == "DipoleDipole": A = np.r_[xr[i], zloc] B = np.r_[xr[i + 1], zloc] if i < ntx - nmax: Mx = xr[i + 2:i + 2 + nmax] _, Mz = get_Surface(mtrue, Mx) Nx = xr[i + 3:i + 3 + nmax] _, Nz = get_Surface(mtrue, Nx) M = np.c_[Mx, Mz] N = np.c_[Nx, Nz] else: Mx = xr[i + 2:len(xr) - 1] _, Mz = get_Surface(mtrue, Mx) Nx = xr[i + 3:len(xr)] _, Nz = get_Surface(mtrue, Nx) M = np.c_[Mx, Mz] N = np.c_[Nx, Nz] rx = DC.Rx.Dipole(M, N) src = DC.Src.Dipole([rx], A, B) txList.append(src) survey = DC.Survey(txList) problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.pair(survey) return survey, xzlocs
def model_fields(A, B, mtrue, mhalf, mair, mover, whichprimary="overburden"): idA, surfaceA = get_Surface(mtrue, A) idB, surfaceB = get_Surface(mtrue, B) Mx = mesh.gridCC # Nx = np.empty(shape =(mesh.nC, 2)) rx = DC.Rx.Pole(Mx) # rx = DC.Rx.Dipole(Mx, Nx) if B == []: src = DC.Src.Pole([rx], np.r_[A, surfaceA]) else: src = DC.Src.Dipole([rx], np.r_[A, surfaceA], np.r_[B, surfaceB]) # src = DC.Src.Dipole([rx], np.r_[A, 0.], np.r_[B, 0.]) survey = DC.Survey([src]) # survey = DC.Survey([src]) # survey_prim = DC.Survey([src]) survey_prim = DC.Survey([src]) survey_air = DC.Survey([src]) # problem = DC.Problem3D_CC(mesh, sigmaMap = mapping) problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) # problem_prim = DC.Problem3D_CC(mesh, sigmaMap = mapping) problem_prim = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem_air = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.Solver = SolverLU problem_prim.Solver = SolverLU problem_air.Solver = SolverLU problem.pair(survey) problem_prim.pair(survey_prim) problem_air.pair(survey_air) mesh.setCellGradBC("neumann") cellGrad = mesh.cellGrad faceDiv = mesh.faceDiv if whichprimary == "air": phi_primary = survey_prim.dpred(mair) elif whichprimary == "half": phi_primary = survey_prim.dpred(mhalf) elif whichprimary == "overburden": phi_primary = survey_prim.dpred(mover) e_primary = -cellGrad * phi_primary j_primary = problem_prim.MfRhoI * problem_prim.Grad * phi_primary q_primary = epsilon_0 * problem_prim.Vol * (faceDiv * e_primary) primary_field = { "phi": phi_primary, "e": e_primary, "j": j_primary, "q": q_primary } phi_total = survey.dpred(mtrue) e_total = -cellGrad * phi_total j_total = problem.MfRhoI * problem.Grad * phi_total q_total = epsilon_0 * problem.Vol * (faceDiv * e_total) total_field = {"phi": phi_total, "e": e_total, "j": j_total, "q": q_total} phi_air = survey.dpred(mair) e_air = -cellGrad * phi_air j_air = problem.MfRhoI * problem.Grad * phi_air q_air = epsilon_0 * problem.Vol * (faceDiv * e_air) air_field = {"phi": phi_air, "e": e_air, "j": j_air, "q": q_air} return src, primary_field, air_field, total_field
def gen_DCIPsurvey(endl, survey_type, a, b, n, dim=3, d2flag='2.5D'): """ Load in endpoints and survey specifications to generate Tx, Rx location stations. Assumes flat topo for now... Input: :param numpy.ndarray endl: input endpoints [x1, y1, z1, x2, y2, z2] :param discretize.BaseMesh mesh: discretize mesh object :param str survey_type: 'dipole-dipole' | 'pole-dipole' | 'dipole-pole' | 'pole-pole' | 'gradient' :param int a: pole seperation :param int b: dipole separation :param int n: number of rx dipoles per tx :param str d2flag: choose for 2D mesh between a '2D' or a '2.5D' survey Output: :return SimPEG.EM.Static.DC.SurveyDC.Survey dc_survey: DC survey object """ 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 = int(np.floor(dl_len / a)) # Compute discrete pole location along line stn_x = endl[0, 0] + np.array(range(int(nstn))) * dl_x * a stn_y = endl[0, 1] + np.array(range(int(nstn))) * dl_y * a if dim == 2: ztop = np.linspace(endl[0, 1], endl[0, 1], nstn) # Create line of P1 locations M = np.c_[stn_x, ztop] # Create line of P2 locations N = np.c_[stn_x + a * dl_x, ztop] elif dim == 3: stn_z = np.linspace(endl[0, 2], endl[0, 2], nstn) # Create line of P1 locations M = np.c_[stn_x, stn_y, stn_z] # Create line of P2 locations N = np.c_[stn_x + a * dl_x, stn_y + a * dl_y, stn_z] # Build list of Tx-Rx locations depending on survey type # Dipole-dipole: Moving tx with [a] spacing -> [AB a MN1 a MN2 ... a MNn] # Pole-dipole: Moving pole on one end -> [A a MN1 a MN2 ... MNn a B] SrcList = [] if survey_type != 'gradient': for ii in range(0, int(nstn) - 1): if survey_type == 'dipole-dipole' or survey_type == 'dipole-pole': tx = np.c_[M[ii, :], N[ii, :]] # Current elctrode separation AB = xy_2_r(tx[0, 1], endl[1, 0], tx[1, 1], endl[1, 1]) elif survey_type == 'pole-dipole' or survey_type == 'pole-pole': tx = np.r_[M[ii, :]] # Current elctrode separation AB = xy_2_r(tx[0], endl[1, 0], tx[1], endl[1, 1]) else: raise Exception( """survey_type must be 'dipole-dipole' | 'pole-dipole' | 'dipole-pole' | 'pole-pole'""" " not {}".format(survey_type)) # Rx.append(np.c_[M[ii+1:indx, :], N[ii+1:indx, :]]) # Number of receivers to fit nstn = int(np.min([np.floor((AB - b) / a), n])) # Check if there is enough space, else break the loop if nstn <= 0: continue # Compute discrete pole location along line stn_x = N[ii, 0] + dl_x * b + np.array(range(int(nstn))) * dl_x * a stn_y = N[ii, 1] + dl_y * b + np.array(range(int(nstn))) * dl_y * a # Create receiver poles if dim == 3: stn_z = np.linspace(endl[0, 2], endl[0, 2], nstn) # Create line of P1 locations P1 = np.c_[stn_x, stn_y, stn_z] # Create line of P2 locations P2 = np.c_[stn_x + a * dl_x, stn_y + a * dl_y, stn_z] if survey_type == 'dipole-dipole' or survey_type == 'pole-dipole': rxClass = DC.Rx.Dipole(P1, P2) elif survey_type == 'dipole-pole' or survey_type == 'pole-pole': rxClass = DC.Rx.Pole(P1) elif dim == 2: ztop = np.linspace(endl[0, 1], endl[0, 1], nstn) # Create line of P1 locations P1 = np.c_[stn_x, np.ones(nstn).T * ztop] # Create line of P2 locations P2 = np.c_[stn_x + a * dl_x, np.ones(nstn).T * ztop] if survey_type == 'dipole-dipole' or survey_type == 'pole-dipole': if d2flag == '2.5D': rxClass = DC.Rx.Dipole_ky(P1, P2) elif d2flag == '2D': rxClass = DC.Rx.Dipole(P1, P2) elif survey_type == 'dipole-pole' or survey_type == 'pole-pole': if d2flag == '2.5D': rxClass = DC.Rx.Pole_ky(P1) elif d2flag == '2D': rxClass = DC.Rx.Pole(P1) if survey_type == 'dipole-dipole' or survey_type == 'dipole-pole': srcClass = DC.Src.Dipole([rxClass], M[ii, :], N[ii, :]) elif survey_type == 'pole-dipole' or survey_type == 'pole-pole': srcClass = DC.Src.Pole([rxClass], M[ii, :]) SrcList.append(srcClass) elif survey_type == 'gradient': # Gradient survey takes the "b" parameter to define the limits of a # square survey grid. The pole seperation within the receiver grid is # define the "a" parameter. # 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 # Define the size of the survey grid (square for now) box_l = np.sqrt((min_x - max_x)**2. + (min_y - max_y)**2.) box_w = box_l / 2. nstn = int(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) npoles = int(nstn * len(lind)) rx = np.zeros([npoles, 6]) for ii in range(len(lind)): # Move station location to current survey line This is a # perpendicular move then line survey orientation, hence the y, x # switch lxx = stn_x - lind[ii] * a * dl_y lyy = stn_y + lind[ii] * a * dl_x M = np.c_[lxx, lyy, np.ones(nstn).T * ztop] N = np.c_[lxx + a * dl_x, lyy + a * dl_y, np.ones(nstn).T * ztop] rx[(ii * nstn):((ii + 1) * nstn), :] = np.c_[M, N] if mesh.dim == 3: rxClass = DC.Rx.Dipole(rx[:, :3], rx[:, 3:]) elif mesh.dim == 2: M = M[:, [0, 2]] N = N[:, [0, 2]] if d2flag == '2.5D': rxClass = DC.Rx.Dipole_ky(rx[:, [0, 2]], rx[:, [3, 5]]) elif d2flag == '2D': rxClass = DC.Rx.Dipole(rx[:, [0, 2]], rx[:, [3, 5]]) srcClass = DC.Src.Dipole([rxClass], (endl[0, :]), (endl[1, :])) SrcList.append(srcClass) else: raise Exception( """survey_type must be either 'pole-dipole', 'dipole-dipole', 'dipole-pole','pole-pole' or 'gradient'""" " not {}".format(survey_type)) if (d2flag == '2.5D') and (dim == 2): survey = DC.Survey_ky(SrcList) else: survey = DC.Survey(SrcList) return survey