def animate(ii):
removeFrame2()
global ax1, ax2, fig
minv = mout[ii]
dpre = dout[ii]
#airind = minv==1e-8
#minv[airind] = np.nan
ax1 = plt.subplot(1, 2, 1)
ax1.set_title('2D Conductivity (S/m)', fontsize=10)
plt.xlim([mesh2d.vectorNx[padc], mesh2d.vectorNx[-padc]])
plt.ylim([mesh2d.vectorNy[-1] - dl_len / 3, mesh2d.vectorNy[-1] + 60])
plt.gca().set_aspect('equal', adjustable='box')
minv = np.reshape(minv, (mesh2d.nCy, mesh2d.nCx))
#plt.pcolormesh(mesh2d.vectorNx,mesh2d.vectorNy,np.log10(m2D),alpha=0.5, cmap='gray')
plt.pcolormesh(mesh2d.vectorNx,
mesh2d.vectorNy,
np.log10(minv),
vmin=-4,
vmax=2)
plt.gca().tick_params(axis='both', which='major', labelsize=8)
ax1.yaxis.tick_right()
cbar = plt.colorbar(format='%.2f', fraction=0.03, orientation="horizontal")
cmin, cmax = cbar.get_clim()
ticks = np.linspace(cmin, cmax, 3)
cbar.set_ticks(ticks)
cbar.ax.tick_params(labelsize=10)
ax2 = plt.subplot(1, 2, 2)
ax2 = DC.plot_pseudoSection(
dpre, ax2, 'pdp'
) #axs.pcolormesh(mesh_sub.vectorCCx,mesh_sub.vectorCCy,Q_sub, alpha=0.75,vmin=-1e-2, vmax=1e-2)
ax2.set_title('App Cond (S/m)', fontsize=10)
plt.draw()
bbox_props = dict(boxstyle="rarrow,pad=0.3", fc="w", ec="k", lw=2)
ax1.text(0.01, (float(ii) + 1.) / (len(uniqueID) + 2),
'N: ' + str(id_lbe),
transform=fig.transFigure,
ha="left",
va="center",
size=8,
bbox=bbox_props)
mrk_props = dict(boxstyle="square,pad=0.3", fc="b", ec="k", lw=2)
for jj in range(len(uniqueID)):
ax1.text(0.1, (float(jj) + 1.) / (len(uniqueID) + 2),
".",
transform=fig.transFigure,
ha="right",
va="center",
size=8,
bbox=mrk_props)
mrk_props = dict(boxstyle="square,pad=0.3", fc="r", ec="k", lw=2)
ax1.text(0.1, (float(ii) + 1.) / (len(uniqueID) + 2),
".",
transform=fig.transFigure,
ha="right",
va="center",
size=8,
bbox=mrk_props)
def animate(ii):
# Grab current line and
indx = np.where(lineID==ii)[0]
srcLeft = []
obs_l = []
std_l = []
srcRight = []
obs_r = []
std_r = []
# Split the obs file into left and right
for jj in range(len(indx)):
# Grab corresponding data
obs = dobs2D.dobs[dataID==indx[jj]]
std = dobs2D.std[dataID==indx[jj]]
Tx = dobs2D.srcList[indx[jj]].loc
Rx = dobs2D.srcList[indx[jj]].rxList[0].locs
# Create mid-point location
Cmid = (Tx[0][0] + Tx[1][0])/2
Pmid = (Rx[0][:,0] + Rx[1][:,0])/2
ileft = Pmid < Cmid
iright = Pmid >= Cmid
if np.any(ileft):
rx = DC.RxDipole(Rx[0][ileft,:],Rx[1][ileft,:])
srcLeft.append( DC.SrcDipole( [rx], Tx[0],Tx[1] ) )
obs_l = np.hstack([obs_l,obs[ileft]])
std_l = np.hstack([std_l,std[ileft]])
if np.any(iright):
rx = DC.RxDipole(Rx[0][iright,:],Rx[1][iright,:])
srcRight.append( DC.SrcDipole( [rx], Tx[0],Tx[1] ) )
obs_r = np.hstack([obs_r,obs[iright]])
std_r = np.hstack([std_r,std[iright]])
DC2D_l = DC.SurveyDC(srcLeft)
DC2D_l.dobs = np.asarray(obs_l)
DC2D_l.std = np.asarray(std_l)
DC2D_r = DC.SurveyDC(srcRight)
DC2D_r.dobs = np.asarray(obs_r)
DC2D_r.std = np.asarray(std_r)
removeFrame()
#DC.plot_pseudoSection(dobs2D,lineID, np.r_[0,1],'pdp')
id_lbe = int(DCsurvey.srcList[indx[jj]].loc[0][1])
global ax1, ax2, fig
ax1 = plt.subplot(2,1,1)
ph = DC.plot_pseudoSection(DC2D_l,ax1,stype = 'pdp', dtype = 'volt', colorbar=False)
ax1.set_title('Observed DP-P', fontsize=10)
ax1.set_xticklabels([])
plt.xlim([xmin,xmax])
plt.ylim([zmin,zmax])
plt.gca().set_aspect('equal', adjustable='box')
z = np.linspace(np.min(ph[2]),np.max(ph[2]), 5)
z_label = np.linspace(20,1, 5)
ax1.set_yticks(map(int, z))
ax1.set_yticklabels(map(str, map(int, z_label)),size=8)
ax1.set_ylabel('n-spacing',fontsize=8)
# Add colorbar
pos = ax1.get_position()
cbarax = fig.add_axes([pos.x0 + 0.72 , pos.y0 + 0.05, pos.width*0.05, pos.height*0.5]) ## the parameters are the specified position you set
cb = fig.colorbar(ph[0],cax=cbarax, orientation="vertical", ticks=np.linspace(ph[0].get_clim()[0],ph[0].get_clim()[1], 3), format="%4.1f")
cb.set_label("App. Charg.",size=8)
ax2 = plt.subplot(2,1,2)
ph = DC.plot_pseudoSection(DC2D_r,ax2,stype = 'pdp', dtype = 'volt', colorbar=False, clim = (ph[0].get_clim()[0],ph[0].get_clim()[1]))
pos = ax2.get_position()
ax2.set_position([pos.x0 , pos.y0, pos.width, pos.height])
plt.xlim([xmin,xmax])
plt.ylim([zmin,zmax])
plt.gca().set_aspect('equal', adjustable='box')
ax2.set_title('Observed P-DP', fontsize=10)
ax2.set_xlabel('Easting (m)', fontsize=8)
z = np.linspace(np.min(ph[2]),np.max(ph[2]), 5)
z_label = np.linspace(20,1, 5)
ax2.set_yticks(map(int, z))
ax2.set_yticklabels(map(str, map(int, z_label)),size=8)
ax2.set_ylabel('n-spacing',fontsize=8)
# Add colorbar
pos = ax2.get_position()
cbarax = fig.add_axes([pos.x0 + 0.72 , pos.y0 + 0.05, pos.width*0.05, pos.height*0.5]) ## the parameters are the specified position you set
cb = fig.colorbar(ph[0],cax=cbarax, orientation="vertical", ticks=np.linspace(ph[0].get_clim()[0],ph[0].get_clim()[1], 3), format="%4.1f")
cb.set_label("App. Charg.",size=8)
bbox_props = dict(boxstyle="circle,pad=0.3",fc="r", ec="k", lw=1)
ax2.text(0.00, 1, 'A', transform=ax2.transAxes, ha="left", va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3",fc="y", ec="k", lw=1)
ax2.text(0.1, 1, 'M', transform=ax2.transAxes, ha="left", va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3",fc="g", ec="k", lw=1)
ax2.text(0.2, 1, 'N', transform=ax2.transAxes, ha="left", va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3",fc="g", ec="k", lw=1)
ax1.text(0.00, 1, 'N', transform=ax1.transAxes, ha="left", va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3",fc="y", ec="k", lw=1)
ax1.text(0.1, 1, 'M', transform=ax1.transAxes, ha="left", va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3",fc="r", ec="k", lw=1)
ax1.text(0.2, 1, 'A', transform=ax1.transAxes, ha="left", va="center",
size=6,
bbox=bbox_props)
#ax2.labelsize(fontsize=10)
#==============================================================================
# ax2.annotate(str(id_lbe), xy=(0.0, float(ii)/len(uniqueID)), xycoords='figure fraction',
# xytext=(0.01, float(ii)/len(uniqueID)), textcoords='figure fraction',
# arrowprops=dict(facecolor='black'),rotation=90)
#==============================================================================
bbox_props = dict(boxstyle="rarrow,pad=0.3",fc="w", ec="k", lw=2)
ax2.text(0.01, (float(ii)+1.)/(len(uniqueID)+2), 'N: ' + str(id_lbe), transform=fig.transFigure, ha="left", va="center",
size=8,
bbox=bbox_props)
mrk_props = dict(boxstyle="square,pad=0.3",fc="w", ec="k", lw=2)
ax2.text(0.01, 0.9, 'Line ID#', transform=fig.transFigure, ha="left", va="center",
size=8,
bbox=mrk_props)
mrk_props = dict(boxstyle="square,pad=0.3",fc="b", ec="k", lw=2)
for jj in range(len(uniqueID)):
ax2.text(0.125, (float(jj)+1.)/(len(uniqueID)+2), ".", transform=fig.transFigure, ha="right", va="center",
size=8,
bbox=mrk_props)
mrk_props = dict(boxstyle="square,pad=0.3",fc="r", ec="k", lw=2)
ax2.text(0.125, (float(ii)+1.)/(len(uniqueID)+2), ".", transform=fig.transFigure, ha="right", va="center",
size=8,
bbox=mrk_props)
def animate(ii):
removeFrame()
# Grab current line and
indx = np.where(lineID == ii)[0]
srcLeft = []
obs_l = []
srcRight = []
obs_r = []
obs = []
srcList = []
# Split the obs file into left and right
for jj in range(len(indx)):
# Grab corresponding data
obs = np.hstack([obs, dobs2D.dobs[dataID == indx[jj]]])
#std = dobs2D.std[dataID==indx[jj]]
srcList.append(dobs2D.srcList[indx[jj]])
Tx = dobs2D.srcList[indx[jj]].loc
Rx = dobs2D.srcList[indx[jj]].rxList[0].locs
# Create mid-point location
Cmid = (Tx[0][0] + Tx[1][0]) / 2
Pmid = (Rx[0][:, 0] + Rx[1][:, 0]) / 2
ileft = Pmid < Cmid
iright = Pmid >= Cmid
temp = np.zeros(len(ileft))
temp[ileft] = 1
obs_l = np.hstack([obs_l, temp])
temp = np.zeros(len(iright))
temp[iright] = 1
obs_r = np.hstack([obs_r, temp])
if np.any(ileft):
rx = DC.RxDipole(Rx[0][ileft, :], Rx[1][ileft, :])
srcLeft.append(DC.SrcDipole([rx], Tx[0], Tx[1]))
#std_l = np.hstack([std_l,std[ileft]])
if np.any(iright):
rx = DC.RxDipole(Rx[0][iright, :], Rx[1][iright, :])
srcRight.append(DC.SrcDipole([rx], Tx[0], Tx[1]))
#obs_r = np.hstack([obs_r,iright])
#std_r = np.hstack([std_r,std[iright]])
DC2D_full = DC.SurveyDC(srcList)
DC2D_full.dobs = np.asarray(obs)
DC2D_full.std = DC2D_full.dobs * 0.
DC2D_full.std[obs_l ==
1] = np.abs(DC2D_full.dobs[obs_l == 1]) * 0.02 + 2e-5
DC2D_full.std[obs_r ==
1] = np.abs(DC2D_full.dobs[obs_r == 1]) * 0.06 + 4e-5
DC2D_l = DC.SurveyDC(srcLeft)
DC2D_l.dobs = np.asarray(obs[obs_l == 1])
DC2D_l.std = np.abs(np.asarray(DC2D_l.dobs)) * 0.05 + 2e-5
DC2D_r = DC.SurveyDC(srcRight)
DC2D_r.dobs = np.asarray(obs[obs_r == 1])
DC2D_r.std = np.abs(np.asarray(DC2D_r.dobs)) * 0.05 + 2e-5
#DC.plot_pseudoSection(dobs2D,lineID, np.r_[0,1],'pdp')
id_lbe = int(DCsurvey.srcList[indx[jj]].loc[0][1])
mesh3d = Mesh.TensorMesh([hx, 1, hz],
x0=(-np.sum(padx) + np.min(srcMat[0][:, 0]),
id_lbe, np.max(srcMat[0][0, 2]) - np.sum(hz)))
Mesh.TensorMesh.writeUBC(mesh3d,
home_dir + dsep + 'Mesh' + str(id_lbe) + '.msh')
global ax1, ax2, ax3, ax5, ax6, fig
ax2 = plt.subplot(3, 2, 2)
ph = DC.plot_pseudoSection(DC2D_r, ax2, stype='pdp', colorbar=False)
ax2.set_title('Observed P-DP', fontsize=10)
plt.xlim([xmin, xmax])
plt.ylim([zmin, zmax])
plt.gca().set_aspect('equal', adjustable='box')
ax2.set_xticklabels([])
ax2.set_yticklabels([])
ax1 = plt.subplot(3, 2, 1)
DC.plot_pseudoSection(DC2D_l,
ax1,
stype='pdp',
clim=(ph[0].get_clim()[0], ph[0].get_clim()[1]),
colorbar=False)
ax1.set_title('Observed DP-P', fontsize=10)
plt.xlim([xmin, xmax])
plt.ylim([zmin, zmax])
plt.gca().set_aspect('equal', adjustable='box')
ax1.set_xticklabels([])
z = np.linspace(np.min(ph[2]), np.max(ph[2]), 5)
z_label = np.linspace(20, 1, 5)
ax1.set_yticks(map(int, z))
ax1.set_yticklabels(map(str, map(int, z_label)), size=8)
ax1.set_ylabel('n-spacing', fontsize=8)
#%% Add labels
bbox_props = dict(boxstyle="circle,pad=0.3", fc="r", ec="k", lw=1)
ax2.text(0.00,
1,
'A',
transform=ax2.transAxes,
ha="left",
va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3", fc="y", ec="k", lw=1)
ax2.text(0.1,
1,
'M',
transform=ax2.transAxes,
ha="left",
va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3", fc="g", ec="k", lw=1)
ax2.text(0.2,
1,
'N',
transform=ax2.transAxes,
ha="left",
va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3", fc="g", ec="k", lw=1)
ax1.text(0.00,
1,
'N',
transform=ax1.transAxes,
ha="left",
va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3", fc="y", ec="k", lw=1)
ax1.text(0.1,
1,
'M',
transform=ax1.transAxes,
ha="left",
va="center",
size=6,
bbox=bbox_props)
bbox_props = dict(boxstyle="circle,pad=0.3", fc="r", ec="k", lw=1)
ax1.text(0.2,
1,
'A',
transform=ax1.transAxes,
ha="left",
va="center",
size=6,
bbox=bbox_props)
# Run both left and right survey seperately
survey = DC2D_full
# Export data file
DC.writeUBC_DCobs(inv_dir + dsep + obsfile2d, survey, '2D', 'SIMPLE')
# Write input file
fid = open(inv_dir + dsep + inp_file, 'w')
fid.write('OBS LOC_X %s \n' % obsfile2d)
fid.write('MESH FILE %s \n' % mshfile2d)
fid.write('CHIFACT 1 \n')
fid.write('TOPO DEFAULT \n')
fid.write('INIT_MOD VALUE %e\n' % ini_mod)
fid.write('REF_MOD VALUE %e\n' % ref_mod)
fid.write('ALPHA VALUE %f %f %F\n' % (1. / dx**4., 1, 1))
fid.write('WEIGHT DEFAULT\n')
fid.write('STORE_ALL_MODELS FALSE\n')
fid.write('INVMODE SVD\n')
#fid.write('CG_PARAM 200 1e-4\n')
fid.write('USE_MREF FALSE\n')
#fid.write('BOUNDS VALUE 1e-4 1e+2\n')
fid.close()
os.chdir(inv_dir)
os.system('dcinv2d ' + inp_file)
#%% Load model and predicted data
minv = DC.readUBC_DC2DModel(inv_dir + dsep + 'dcinv2d.con')
minv = np.reshape(minv, (mesh2d.nCy, mesh2d.nCx))
Mesh.TensorMesh.writeModelUBC(
mesh3d, home_dir + dsep + 'Model' + str(id_lbe) + '.con', minv.T)
dpre = DC.readUBC_DC2Dpre(inv_dir + dsep + 'dcinv2d.pre')
DCpre = dpre['DCsurvey']
DCtemp = DC2D_l
DCtemp.dobs = DCpre.dobs[obs_l == 1]
ax5 = plt.subplot(3, 2, 3)
DC.plot_pseudoSection(DCtemp,
ax5,
stype='pdp',
clim=(ph[0].get_clim()[0], ph[0].get_clim()[1]),
colorbar=False)
ax5.set_title('Predicted', fontsize=10)
plt.xlim([xmin, xmax])
plt.ylim([zmin, zmax])
plt.gca().set_aspect('equal', adjustable='box')
ax5.set_xticklabels([])
z = np.linspace(np.min(ph[2]), np.max(ph[2]), 5)
z_label = np.linspace(20, 1, 5)
ax5.set_yticks(map(int, z))
ax5.set_yticklabels(map(str, map(int, z_label)), size=8)
ax5.set_ylabel('n-spacing', fontsize=8)
DCtemp = DC2D_r
DCtemp.dobs = DCpre.dobs[obs_r == 1]
ax6 = plt.subplot(3, 2, 4)
DC.plot_pseudoSection(DCtemp,
ax6,
stype='pdp',
clim=(ph[0].get_clim()[0], ph[0].get_clim()[1]),
colorbar=False)
ax6.set_title('Predicted', fontsize=10)
plt.xlim([xmin, xmax])
plt.ylim([zmin, zmax])
plt.gca().set_aspect('equal', adjustable='box')
ax6.set_xticklabels([])
ax6.set_yticklabels([])
pos = ax6.get_position()
cbarax = fig.add_axes([
pos.x0 + 0.325, pos.y0 + 0.2, pos.width * 0.1, pos.height * 0.5
]) ## the parameters are the specified position you set
cb = fig.colorbar(ph[0],
cax=cbarax,
orientation="vertical",
ax=ax6,
ticks=np.linspace(ph[0].get_clim()[0],
ph[0].get_clim()[1], 4),
format="$10^{%.1f}$")
cb.set_label("App. Cond. (S/m)", size=8)
ax3 = plt.subplot(3, 1, 3)
ax3.set_title('2-D Model (S/m)', fontsize=10)
ax3.set_xticks(map(int, x))
ax3.set_xticklabels(map(str, map(int, x)))
ax3.set_xlabel('Easting (m)', fontsize=8)
ax3.set_yticks(map(int, z))
ax3.set_yticklabels(map(str, map(int, z)), rotation='vertical')
ax3.set_ylabel('Depth (m)', fontsize=8)
plt.xlim([xmin, xmax])
plt.ylim([zmin / 2, zmax])
plt.gca().set_aspect('equal', adjustable='box')
ph2 = plt.pcolormesh(mesh2d.vectorNx,
mesh2d.vectorNy,
np.log10(minv),
vmin=vmin,
vmax=vmax)
plt.gca().tick_params(axis='both', which='major', labelsize=8)
plt.draw()
for ss in range(survey.nSrc):
Tx = survey.srcList[ss].loc[0]
plt.scatter(Tx[0], mesh2d.vectorNy[-1] + 10, s=10)
pos = ax3.get_position()
ax3.set_position([pos.x0 + 0.025, pos.y0, pos.width, pos.height])
pos = ax3.get_position()
cbarax = fig.add_axes([
pos.x0 + 0.65, pos.y0 + 0.01, pos.width * 0.05, pos.height * 0.75
]) ## the parameters are the specified position you set
cb = fig.colorbar(ph2,
cax=cbarax,
orientation="vertical",
ax=ax4,
ticks=np.linspace(vmin, vmax, 4),
format="$10^{%.1f}$")
cb.set_label("Conductivity (S/m)", size=8)
pos = ax1.get_position()
ax1.set_position([pos.x0 + 0.03, pos.y0, pos.width, pos.height])
pos = ax5.get_position()
ax5.set_position([pos.x0 + 0.03, pos.y0, pos.width, pos.height])
pos = ax2.get_position()
ax2.set_position([pos.x0 - 0.03, pos.y0, pos.width, pos.height])
pos = ax6.get_position()
ax6.set_position([pos.x0 - 0.03, pos.y0, pos.width, pos.height])
#%% Add the extra
bbox_props = dict(boxstyle="rarrow,pad=0.3", fc="w", ec="k", lw=2)
ax2.text(0.01, (float(ii) + 1.) / (len(uniqueID) + 2),
'N: ' + str(id_lbe),
transform=fig.transFigure,
ha="left",
va="center",
size=8,
bbox=bbox_props)
mrk_props = dict(boxstyle="square,pad=0.3", fc="w", ec="k", lw=2)
ax2.text(0.01,
0.9,
'Line ID#',
transform=fig.transFigure,
ha="left",
va="center",
size=8,
bbox=mrk_props)
mrk_props = dict(boxstyle="square,pad=0.3", fc="b", ec="k", lw=2)
for jj in range(len(uniqueID)):
ax2.text(0.1, (float(jj) + 1.) / (len(uniqueID) + 2),
".",
transform=fig.transFigure,
ha="right",
va="center",
size=8,
bbox=mrk_props)
mrk_props = dict(boxstyle="square,pad=0.3", fc="r", ec="k", lw=2)
ax2.text(0.1, (float(ii) + 1.) / (len(uniqueID) + 2),
".",
transform=fig.transFigure,
ha="right",
va="center",
size=8,
bbox=mrk_props)
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
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
for jj in range(survey.nSrc):
Tx = survey.srcList[jj].loc
Rx = survey.srcList[jj].rxList[0].locs
# Create mid-point location
Cmid = (Tx[0][0] + Tx[1][0])/2
Pmid = (Rx[0][:,0] + Rx[1][:,0])/2
midx = np.hstack([midx, ( Cmid + Pmid )/2 ])
midz = np.hstack([midz, -np.abs(Cmid-Pmid)/2 + (Tx[0][2] + Tx[1][2])/2 ])
global ax1, fig
ax1 = plt.subplot(1,1,1)
ph = DC.plot_pseudoSection(survey,ax1,stype = 'pdp', dtype = dtype, colorbar=True)
# Call a ginput to delete points on pseudo-section
#uncert = np.hstack([uncert,src_uncert])
cfm1=get_current_fig_manager().window
cfm1.activateWindow()
plt.sca(ax1)
gin = plt.ginput(100, timeout = 0, show_clicks=True,mouse_add=1,mouse_stop=2)
# Find closest midx and midz from the list of gin and assign 0 to
#the global data indexing
for jj in range(len(gin)):
# Find the closest point on the pseudo section
rmin = np.argmin( (gin[jj][0] - midx)**2. + (gin[jj][1] - midz)**2. )
keeper[indx[rmin]] = 0
if pp == 0:
fig2 = plt.figure(figsize=(7, 7))
# Second plot for the predicted apparent resistivity data
ax2 = fig2.add_subplot(2, 1, pp + 1, aspect='equal')
if pp == 1:
pos = ax2.get_position()
ax2.set_position([pos.x0, pos.y0 + .05, pos.width, pos.height])
#ax2.pcolor(mesh2d.vectorNx,mesh2d.vectorNy,np.log10(m2D),edgecolor="none",alpha=0.5,cmap = 'gray')
# Add the speudo section
if pp == 0:
dat = DC.plot_pseudoSection(survey2D,
ax2,
stype=stype,
dtype=dtype,
colorbar=False,
clim=np.asarray([vmin, 0]))
else:
dat = DC.plot_pseudoSection(survey2D,
ax2,
stype=stype,
dtype=dtype,
clim=np.asarray([vmin, 0]))
#==============================================================================
# if pp == 0:
#
# circle=plt.Circle((11950,145),125,color='k',fill=False, lw=3)
# ax2.add_artist(circle)
#==============================================================================