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.RxDipole(np.c_[temp[:, 2] * aspacing, e, e],
np.c_[temp[:, 3] * aspacing, e, e])
srctemp = DC.SrcDipole([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.SurveyDC(srcList)
survey.dobs = DAT_src[:, -1]
survey.height_water = height_water
survey.height_dam = height_dam
return survey
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
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
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 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)
# Grab current line and
indx = np.where(lineID == ii)[0]
srcList = []
d = []
std = []
for ss in range(len(indx)):
Rx = dobs2D.srcList[indx[ss]].rxList[0]
Tx = dobs2D.srcList[indx[ss]].loc
d.extend(mkvc(dobs2D.dobs[dataID == indx[ss]]))
std.extend(dobs2D.std[dataID == indx[ss]])
srcList.append(DC.SrcDipole([Rx], Tx[0], Tx[1]))
data = np.array([np.array(xi) for xi in d])
unct = np.array([np.array(xi) for xi in std])
DC2D = DC.SurveyDC(srcList)
DC2D.dobs = data
DC2D.std = unct
#DC.plot_pseudoSection(dobs2D,lineID, np.r_[0,1],'pdp')
id_lbe = int(DCsurvey.srcList[indx[ss]].loc[0][1])
global ax1, fig
ax1 = plt.subplot(1, 1, 1)
for ss in range(DC2D.nSrc):
Tx = DC2D.srcList[ss].loc[0]
plt.scatter(Tx[0], Tx[2], s=10)
# Create topo file if not empty
if topo is not None:
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)
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]])
ind_l = np.hstack([ind_l,ind_data[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]])
ind_r = np.hstack([ind_r,ind_data[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)
#DC.plot_pseudoSection(dobs2D,lineID, np.r_[0,1],'pdp')
for kk in range(2):
removeFrame()
# Get the survey and data index for either the right or left config
if kk == 0:
survey = DC2D_l
indx = ind_l