def test_appendTriangleBoundary(self):
geom = mt.createWorld(start=[-10, 0], end=[10, -10], layers=[-5, -10])
mesh = mt.createMesh(geom, area=1)
mesh2 = mt.appendTriangleBoundary(mesh, marker=0)
# test if boundary markers are preserved
np.testing.assert_array_equal(
pg.unique(pg.sort(mesh2.boundaryMarkers())), [-2, -1, 0, 2, 7, 8])
def calcApparentResistivities(mesh, meshERT, poro, rhoBrine):
ert = ERT(verbose=False)
meshFOP = appendTriangleBoundary(meshERT,
xbound=50, ybound=50, marker=1,
quality=34.0, smooth=False,
markerBoundary=1,
isSubSurface=False, verbose=False)
swatch = pg.Stopwatch(True)
print("res 1:", swatch.duration(True))
resis = resistivityArchie(rBrine=rhoBrine, porosity=poro, S=1.0,
mesh=mesh, meshI=meshFOP)
print("res 2:", swatch.duration(True))
ertPointsX = [pg.RVector3(x, 0) for x in np.arange(-19, 19.1, 1)]
ertScheme = ert.createData(ertPointsX, scheme="Dipole Dipole (CC-PP)")
solutionName = createCacheName('appRes', mesh) + "-" + \
str(ertScheme.size()) + "-" + str(len(rhoBrine))
try:
rhoa = np.load(solutionName + '.bmat.npy')
ertData = pb.DataContainerERT(solutionName + '.dat')
except Exception as e:
print(e)
print("Building .... ")
rhoa = np.zeros((len(resis), ertScheme.size()))
ertScheme.set('k', pb.geometricFactor(ertScheme))
ertData = ert.simulate(meshFOP, resis[0], ertScheme)
errPerc = 1
errVolt = 1e-5
voltage = ertData('rhoa') / ertData('k')
ertData.set('err', pg.abs(errVolt / voltage) + errPerc / 100.0)
print('err min:', min(ertData('err'))*100, 'max:',
max(ertData('err'))*100)
ertData.save(solutionName + '.dat', 'a b m n rhoa err k')
for i in range(0, len(resis)):
tic = time.time()
rhoa[i] = ert.fop.response(resis[i])
rand = pg.RVector(len(rhoa[i]))
pg.randn(rand)
rhoa[i] *= (1.0 + rand * ertData('err'))
print(i, "/", len(resis), " : ", time.time()-tic, "s",
"min:", min(resis[i]), "max:", max(resis[i]),
"min:", min(rhoa[i]), "max:", max(rhoa[i]))
np.save(solutionName + '.bmat', rhoa)
return meshFOP, resis, ertData, rhoa
tri.generate(mesh2)
for cell in mesh2.cells():
cell.setMarker(1)
###############################################################################
# Finally, the grid and the unstructured mesh can be merged to single mesh for further
# modelling.
mesh3 = merge2Meshes(mesh1, mesh2)
###############################################################################
# Of course, you can treat the hybrid mesh like any other mesh and append a triangle
# boundary for example with :py:func:`pygimli.meshtools.grid.appendTriangleBoundary`.
mesh = appendTriangleBoundary(mesh3, -100., 100., quality=31,
smooth=True, marker=3, isSubSurface=True)
ax, cbar = showMesh(mesh, mesh.cellMarkers(),
cmap="summer",
label="Region marker")
drawMesh(ax, mesh)
ax, _ = showMesh(mesh, mesh.cellMarkers(),
logScale=False,
label="Region marker")
drawMesh(ax, mesh)
pg.wait()
def calcSeismics(meshIn, vP):
"""Do seismic computations."""
meshSeis = meshIn.createH2()
meshSeis = mt.appendTriangleBoundary(meshSeis,
xbound=25,
ybound=22.0,
marker=1,
quality=32.0,
area=0.3,
smooth=True,
markerBoundary=1,
isSubSurface=False,
verbose=False)
print(meshSeis)
meshSeis = meshSeis.createH2()
meshSeis = meshSeis.createH2()
# meshSeis = meshSeis.createP2()
meshSeis.smooth(1, 1, 1, 4)
vP = pg.interpolate(meshIn, vP, meshSeis.cellCenters())
mesh = meshSeis
vP = pg.solver.fillEmptyToCellArray(mesh, vP)
print(mesh)
# ax, cbar = pg.show(mesh, data=vP)
# pg.show(mesh, axes=ax)
geophPointsX = np.arange(-19, 19.1, 1)
geophPoints = np.vstack((geophPointsX, np.zeros(len(geophPointsX)))).T
sourcePos = geophPoints[4]
c = mesh.findCell(sourcePos)
h1 = pg.findBoundary(c.boundaryNodes(0)).size()
h2 = pg.findBoundary(c.boundaryNodes(1)).size()
h3 = pg.findBoundary(c.boundaryNodes(2)).size()
print([h1, h2, h3])
h = pg.math.median([h1, h2, h3])
# h = pg.math.median(mesh.boundarySizes())
f0scale = 0.25
cfl = 0.5
dt = cfl * h / max(vP)
print("Courant-Friedrich-Lewy number:", cfl)
tmax = 40. / min(vP)
times = np.arange(0.0, tmax, dt)
solutionName = createCacheName('seis', mesh, times) + "cfl-" + str(cfl)
try:
# u = pg.load(solutionName + '.bmat')
uI = pg.load(solutionName + 'I.bmat')
except Exception as e:
print(e)
f0 = f0scale * 1. / dt
print("h:", round(h, 2), "dt:", round(dt, 5), "1/dt:",
round(1 / dt, 1), "f0", round(f0, 2), "Wavelength: ",
round(max(vP) / f0, 2), " m")
uSource = ricker(times, f0, t0=1. / f0)
plt.figure()
plt.plot(times, uSource, '-*')
plt.show(block=0)
plt.pause(0.01)
u = solvePressureWave(mesh,
vP,
times,
sourcePos=sourcePos,
uSource=uSource,
verbose=10)
u.save(solutionName)
uI = pg.Matrix()
print("interpolate node to cell data ... ")
pg.interpolate(mesh, u, mesh.cellCenters(), uI)
print("... done")
uI.save(solutionName + 'I')
# nodes = [mesh.findNearestNode(p) for p in geophPoints]
# fig = plt.figure()
# axs = fig.add_subplot(1,1,1)
# drawSeismogramm(axs, mesh, u, nodes, dt, i=None)
# plt.show()
dpi = 92
scale = 1
fig = plt.figure(facecolor='white',
figsize=(scale * 800 / dpi, scale * 490 / dpi),
dpi=dpi)
ax = fig.add_subplot(1, 1, 1)
gci = pg.viewer.mpl.drawModel(ax,
mesh,
data=uI[0],
cMin=-1,
cMax=1,
cmap='bwr')
pg.viewer.mpl.drawMeshBoundaries(ax, meshIn, hideMesh=1)
ax.set_xlim((-20, 20))
ax.set_ylim((-15, 0))
ax.set_ylabel('Depth [m]')
ax.set_xlabel('$x$ [m]')
ticks = ax.yaxis.get_majorticklocs()
tickLabels = []
for t in ticks:
tickLabels.append(str(int(abs(t))))
ax.set_yticklabels(tickLabels)
plt.tight_layout()
# ax, cbar = pg.show(mesh, data=vP)
# pg.showNow()
# ax = fig.add_subplot(1,1,1)
def animate(i):
i = i * 5
if i > len(uI) - 1:
return
print("Frame:", i, "/", len(uI))
ui = uI[i]
ui = ui / max(pg.abs(ui))
ui = pg.logDropTol(ui, 1e-2)
cMax = max(pg.abs(ui))
pg.viewer.mpl.setMappableData(gci,
ui,
cMin=-cMax,
cMax=cMax,
logScale=False)
# plt.pause(0.001)
anim = animation.FuncAnimation(fig,
animate,
frames=int(len(uI) / 5),
interval=0.001,
repeat=0) # , blit=True)
out = 'seis' + str(f0scale) + "cfl-" + str(cfl)
anim.save(out + ".mp4",
writer=None,
fps=20,
dpi=dpi,
codec=None,
bitrate=24 * 1024,
extra_args=None,
metadata=None,
extra_anim=None,
savefig_kwargs=None)
try:
print("create frames ... ")
os.system('mkdir -p anim-' + out)
os.system('ffmpeg -i ' + out + '.mp4 anim-' + out + '/movie%d.jpg')
except:
pass
def calcSeismics(meshIn, vP):
"""Do seismic computations."""
meshSeis = meshIn.createH2()
meshSeis = mt.appendTriangleBoundary(
meshSeis, xbound=25, ybound=22.0, marker=1, quality=32.0, area=0.3,
smooth=True, markerBoundary=1, isSubSurface=False, verbose=False)
print(meshSeis)
meshSeis = meshSeis.createH2()
meshSeis = meshSeis.createH2()
# meshSeis = meshSeis.createP2()
meshSeis.smooth(1, 1, 1, 4)
vP = pg.interpolate(meshIn, vP, meshSeis.cellCenters())
mesh = meshSeis
vP = pg.solver.fillEmptyToCellArray(mesh, vP)
print(mesh)
# ax, cbar = pg.show(mesh, data=vP)
# pg.show(mesh, axes=ax)
geophPointsX = np.arange(-19, 19.1, 1)
geophPoints = np.vstack((geophPointsX, np.zeros(len(geophPointsX)))).T
sourcePos = geophPoints[4]
c = mesh.findCell(sourcePos)
h1 = pg.findBoundary(c.boundaryNodes(0)).size()
h2 = pg.findBoundary(c.boundaryNodes(1)).size()
h3 = pg.findBoundary(c.boundaryNodes(2)).size()
print([h1, h2, h3])
h = pg.median([h1, h2, h3])
# h = pg.median(mesh.boundarySizes())
f0scale = 0.25
cfl = 0.5
dt = cfl * h / max(vP)
print("Courant-Friedrich-Lewy number:", cfl)
tmax = 40./min(vP)
times = np.arange(0.0, tmax, dt)
solutionName = createCacheName('seis', mesh, times) + "cfl-" + str(cfl)
try:
# u = pg.load(solutionName + '.bmat')
uI = pg.load(solutionName + 'I.bmat')
except Exception as e:
print(e)
f0 = f0scale * 1./dt
print("h:", round(h, 2),
"dt:", round(dt, 5),
"1/dt:", round(1/dt, 1),
"f0", round(f0, 2),
"Wavelength: ", round(max(vP)/f0, 2), " m")
uSource = ricker(times, f0, t0=1./f0)
plt.figure()
plt.plot(times, uSource, '-*')
plt.show(block=0)
plt.pause(0.01)
u = solvePressureWave(mesh, vP, times, sourcePos=sourcePos,
uSource=uSource, verbose=10)
u.save(solutionName)
uI = pg.RMatrix()
print("interpolate node to cell data ... ")
pg.interpolate(mesh, u, mesh.cellCenters(), uI)
print("... done")
uI.save(solutionName+'I')
# nodes = [mesh.findNearestNode(p) for p in geophPoints]
# fig = plt.figure()
# axs = fig.add_subplot(1,1,1)
# drawSeismogramm(axs, mesh, u, nodes, dt, i=None)
# plt.show()
dpi = 92
scale = 1
fig = plt.figure(facecolor='white',
figsize=(scale*800/dpi, scale*490/dpi), dpi=dpi)
ax = fig.add_subplot(1, 1, 1)
gci = pg.mplviewer.drawModel(ax, mesh, data=uI[0],
cMin=-1, cMax=1, cmap='bwr')
pg.mplviewer.drawMeshBoundaries(ax, meshIn, hideMesh=1)
ax.set_xlim((-20, 20))
ax.set_ylim((-15, 0))
ax.set_ylabel('Depth [m]')
ax.set_xlabel('$x$ [m]')
ticks = ax.yaxis.get_majorticklocs()
tickLabels = []
for t in ticks:
tickLabels.append(str(int(abs(t))))
ax.set_yticklabels(tickLabels)
plt.tight_layout()
# ax, cbar = pg.show(mesh, data=vP)
# pg.showNow()
# ax = fig.add_subplot(1,1,1)
def animate(i):
i = i*5
if i > len(uI)-1:
return
print("Frame:", i, "/", len(uI))
ui = uI[i]
ui = ui / max(pg.abs(ui))
ui = pg.logDropTol(ui, 1e-2)
cMax = max(pg.abs(ui))
pg.mplviewer.setMappableData(gci, ui,
cMin=-cMax, cMax=cMax,
logScale=False)
# plt.pause(0.001)
anim = animation.FuncAnimation(fig, animate,
frames=int(len(uI)/5),
interval=0.001, repeat=0) # , blit=True)
out = 'seis' + str(f0scale) + "cfl-" + str(cfl)
anim.save(out + ".mp4", writer=None, fps=20, dpi=dpi, codec=None,
bitrate=24*1024, extra_args=None, metadata=None,
extra_anim=None, savefig_kwargs=None)
try:
print("create frames ... ")
os.system('mkdir -p anim-' + out)
os.system('ffmpeg -i ' + out + '.mp4 anim-' + out + '/movie%d.jpg')
except:
pass
def calcApparentResistivities(mesh, meshERT, poro, rhoBrine):
ert = ERT(verbose=False)
meshFOP = appendTriangleBoundary(meshERT,
xbound=50,
ybound=50,
marker=1,
quality=34.0,
smooth=False,
markerBoundary=1,
isSubSurface=False,
verbose=False)
swatch = pg.Stopwatch(True)
print("res 1:", swatch.duration(True))
resis = resistivityArchie(rBrine=rhoBrine,
porosity=poro,
S=1.0,
mesh=mesh,
meshI=meshFOP)
print("res 2:", swatch.duration(True))
ertPointsX = [pg.RVector3(x, 0) for x in np.arange(-19, 19.1, 1)]
ertScheme = ert.createData(ertPointsX, scheme="Dipole Dipole (CC-PP)")
solutionName = createCacheName('appRes', mesh) + "-" + \
str(ertScheme.size()) + "-" + str(len(rhoBrine))
try:
rhoa = np.load(solutionName + '.bmat.npy')
ertData = pb.DataContainerERT(solutionName + '.dat')
except Exception as e:
print(e)
print("Building .... ")
rhoa = np.zeros((len(resis), ertScheme.size()))
ertScheme.set('k', pb.geometricFactor(ertScheme))
ertData = ert.simulate(meshFOP, resis[0], ertScheme)
errPerc = 1
errVolt = 1e-5
voltage = ertData('rhoa') / ertData('k')
ertData.set('err', pg.abs(errVolt / voltage) + errPerc / 100.0)
print('err min:',
min(ertData('err')) * 100, 'max:',
max(ertData('err')) * 100)
ertData.save(solutionName + '.dat', 'a b m n rhoa err k')
for i in range(0, len(resis)):
tic = time.time()
rhoa[i] = ert.fop.response(resis[i])
rand = pg.RVector(len(rhoa[i]))
pg.randn(rand)
rhoa[i] *= (1.0 + rand * ertData('err'))
print(i, "/", len(resis), " : ",
time.time() - tic, "s", "min:", min(resis[i]), "max:",
max(resis[i]), "min:", min(rhoa[i]), "max:", max(rhoa[i]))
np.save(solutionName + '.bmat', rhoa)
return meshFOP, resis, ertData, rhoa
###############################################################################
# Finally, the grid and the unstructured mesh can be merged to single mesh for
# further modelling.
mesh3 = merge2Meshes(mesh1, mesh2)
###############################################################################
# Of course, you can treat the hybrid mesh like any other mesh and append a
# triangle boundary for example with the function
# :py:func:`pygimli.meshtools.grid.appendTriangleBoundary`.
mesh = appendTriangleBoundary(mesh3,
-100.,
100.,
quality=31,
smooth=True,
marker=3,
isSubSurface=True)
ax, cbar = showMesh(mesh,
mesh.cellMarkers(),
cmap="summer",
label="Region marker")
drawMesh(ax, mesh)
ax, _ = showMesh(mesh,
mesh.cellMarkers(),
logScale=False,
label="Region marker")
meshRST = mt.createMesh(geom, quality=34, area=1, smooth=[1, 2])
for cell in meshRST.cells():
cell.setMarker(2)
for boundary in meshRST.boundaries():
boundary.setMarker(0)
pg.show(meshRST)
print(meshRST)
# %%
meshRST.save("paraDomain_%d.bms" % case)
meshERT = mt.appendTriangleBoundary(meshRST,
xbound=500,
ybound=500,
quality=34,
isSubSurface=True)
meshERT.save("meshERT_%d.bms" % case)
# ERT inversion
ert = ERTManager()
ert.setMesh(meshERT)
resinv = ert.invert(ertData, lam=30, zWeight=zWeight, maxIter=maxIter)
print("ERT chi: %.2f" % ert.inv.chi2())
print("ERT rms: %.2f" % ert.inv.inv.relrms())
np.savetxt("res_conventional_%d.dat" % case, resinv)
# Seismic inversion
ttData = pg.DataContainer("tttrue.dat")
nB = poly.createNode(x, zmax, 0.0)
poly.createEdge(nA, nB)
nA = nB
z2 = 0.
nA = poly.createNode(xmax, z2, 0.0)
poly.createEdge(nB, nA)
nB = poly.createNode(xmin, z2, 0.0)
poly.createEdge(nA, nB)
poly.createEdge(nB, nStart)
mesh2 = mt.createMesh(poly, quality=31)
mesh2.setCellMarkers([1]*mesh2.cellCount())
print(mesh2)
###############################################################################
# Finally, the grid and the unstructured mesh can be merged to single mesh for
# further modelling.
mesh3 = mt.mergeMeshes([mesh1, mesh2])
###############################################################################
# Of course, you can treat the hybrid mesh like any other mesh and append a
# triangle boundary for example with the function
# :py:func:`pygimli.meshtools.grid.appendTriangleBoundary`.
mesh = mt.appendTriangleBoundary(mesh3, xbound=100., ybound=100., quality=31, smooth=True,
marker=3, isSubSurface=True, addNodes=5)
pg.show(mesh, markers=True, showMesh=True)
pg.wait()
