class TestTT(unittest.TestCase):
def setUp(self):
# Dummy data container
self.data = pg.DataContainer()
self.data.createSensor([0.0, 0.0])
self.data.createSensor([1.0, 2.0])
self.data.resize(1)
self.data.set("s", pg.Vector(1, 1.0))
self.data.set("g", pg.Vector(1, 2.0))
self.data.registerSensorIndex("s")
self.data.registerSensorIndex("g")
# Without secondary nodes
self.mesh = pg.createGrid([0, 1, 2], [0, 1, 2])
# Slowness
self.slo = [1, 2, 1, 4]
self.mgr = TravelTimeManager()
def test_withoutSecNodes(self):
fop = self.mgr.fop
fop.setData(self.data)
fop.setMesh(self.mesh, ignoreRegionManager=True)
t = fop.response(self.slo)
np.testing.assert_allclose(t, 1 + np.sqrt(2))
data = self.mgr.simulate(slowness=self.slo,
scheme=self.data,
mesh=self.mesh,
secNodes=0)
np.testing.assert_allclose(data['t'], 1 + np.sqrt(2))
def test_withSecNodes(self):
fop = self.mgr.fop
fop.setData(self.data)
fop.setMesh(self.mesh.createMeshWithSecondaryNodes(n=3),
ignoreRegionManager=True)
t = fop.response(self.slo)
np.testing.assert_allclose(t,
np.sqrt(5)) # only works for odd secNodes
data = self.mgr.simulate(slowness=self.slo,
scheme=self.data,
mesh=self.mesh,
secNodes=3)
np.testing.assert_allclose(data['t'],
np.sqrt(5)) # only works for odd secNodes
def test_Jacobian(self):
fop = self.mgr.fop
fop.setData(self.data)
fop.setMesh(self.mesh.createMeshWithSecondaryNodes(n=5),
ignoreRegionManager=True)
fop.createJacobian(self.slo)
J = fop.jacobian()
np.testing.assert_allclose(J * self.slo, np.sqrt(5))
def setUp(self):
# Dummy data container
self.data = pg.DataContainer()
self.data.createSensor([0.0, 0.0])
self.data.createSensor([1.0, 2.0])
self.data.resize(1)
self.data.set("s", pg.Vector(1, 1.0))
self.data.set("g", pg.Vector(1, 2.0))
self.data.registerSensorIndex("s")
self.data.registerSensorIndex("g")
# Without secondary nodes
self.mesh = pg.createGrid([0, 1, 2], [0, 1, 2])
# Slowness
self.slo = [1, 2, 1, 4]
self.mgr = TravelTimeManager()
# Adapt sensor positions to slope
pos = np.array(scheme.sensors())
for x in pos[:, 0]:
i = np.where(pos[:, 0] == x)
new_y = x * slope + 137
pos[i, 1] = new_y
scheme.setSensors(pos)
###############################################################################
# Now we initialize the TravelTime manager and asssign P-wave velocities to the
# layers. To this end, we create a map from cell markers 0 through 3 to
# velocities (in m/s) and generate a velocity vector. To check whether the
# model looks correct, we plot it along with the sensor positions.
mgr = TravelTimeManager()
vp = np.array(mesh.cellMarkers())
vp[vp == 1] = 250
vp[vp == 2] = 500
vp[vp == 3] = 1300
ax, _ = pg.show(mesh, vp, colorBar=True, logScale=False, label='v in m/s')
pg.viewer.mpl.drawSensors(ax,
scheme.sensors(),
diam=0.5,
facecolor='white',
edgecolor='black')
###############################################################################
# We use this model to create noisified synthetic data and look at the
# traveltime data matrix. Note, we force a specific noise seed as we want
# into a temporary location. Printing the data reveals that there are 714 data
# points using 63 sensors (shots and geophones) with the data columns s (shot),
# g (geophone), and t (traveltime). By default, there is also a validity flag.
data = pg.getExampleFile("traveltime/koenigsee.sgt", load=True, verbose=True)
print(data)
################################################################################
# Let's have a look at the data in the form of traveltime curves.
fig, ax = pg.plt.subplots()
pg.physics.traveltime.drawFirstPicks(ax, data)
################################################################################
# We initialize the refraction manager.
mgr = TravelTimeManager()
# Alternatively, one can plot a matrix plot of apparent velocities which is the
# more general function also making sense for crosshole data.
ax, cbar = mgr.showData(data)
################################################################################
# Finally, we call the `invert` method and plot the result.The mesh is created
# based on the sensor positions on-the-fly.
mgr.invert(data,
secNodes=3,
paraMaxCellSize=5.0,
zWeight=0.2,
vTop=500,
vBottom=5000,
smoothing = 100
vertWeight = 0.1
minVel = 1000
maxVel = 4500
maxIterations = 15
#*************************************************************************
#********** DO INVERSION***************************************************
#Convert the file
inFile = convertPicks2Gimli(pickFile, topoFile, minError, maxError)
#Read in the file with gimli method
data = loadGimliTT(inFile)
#Create the structure required for inversion using TravelTimeManager and data container
ra = TravelTimeManager(data)
#Generate the mesh
mesh = ra.createMesh(data=ra.data,
paraDepth=maxDepth,
paraDX=meshDx,
paraMaxCellSize=maxTriArea)
#Plot the mesh
#pg.show(mesh=mesh)
#Do the Inversion (time the inversion)
start1 = time.time()
ra.inv.maxIter = maxIterations
#ra.invert(data=ra.data,mesh=mesh,lam=smoothing,zWeight=vertWeight,useGradient=True,vTop=minVel,vBottom=maxVel,maxIter=maxIterations,limits=[100,5000])
#ra2.invert(data=ra2.data,mesh=mesh,lam=smoothing,zWeight=vertWeight,useGradient=True,vTop=minVel-minVel/1.6,vBottom=maxVel-maxVel/1.6,maxIter=maxIterations,limits=[25,3000])
ra.invert(data=ra.data,
data.resize(nData)
data['s'] = [source] * nData # only one shot at first sensor
data['g'] = range(nData) # and all sensors are receiver geophones
# Draw initial mesh with velocity distribution
pg.show(mesh, vel, ax=ax[0, j], label="Velocity (m/s)", hold=True,
logScale=False, cMap="summer_r", coverage=0.7)
drawMesh(ax[0, j], mesh, color="white", lw=0.21)
# We compare the accuracy for 0-5 secondary nodes
sec_nodes = [0, 1, 5]
t_all = []
durations = []
paths = []
mgr = TravelTimeManager()
cols = ["orangered", "blue", "black"]
recs = [1, 3, 8, 13]
for i, n in enumerate(sec_nodes):
# Perform traveltime calculations and log time with pg.tic() & pg.toc()
pg.tic()
res = mgr.simulate(vel=vel, scheme=data, mesh=mesh, secNodes=n)
# We need to copy res['t'] here because res['t'] is a reference to
# an array in res, and res will be removed in the next iteration.
# Unfortunately, we don't have any reverence counting for core objects yet.
t_all.append(res['t'].array())
durations.append(pg.dur())
pg.toc("Raytracing with %d secondary nodes:" % n)
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")
print(ttData)
rst = TravelTimeManager(verbose=True)
rst.setMesh(meshRST, secNodes=3)
veltrue = np.loadtxt("veltrue.dat")
startmodel = createGradientModel2D(ttData, meshRST, np.min(veltrue),
np.max(veltrue))
np.savetxt("rst_startmodel_%d.dat" % case, 1 / startmodel)
vest = rst.invert(ttData,
zWeight=zWeight,
startModel=startmodel,
maxIter=maxIter,
lam=220)
print("RST chi: %.2f" % rst.inv.chi2())
print("RST rms: %.2f" % rst.inv.inv.relrms())
rst.rayCoverage().save("rst_coverage_%d.dat" % case)
nRuns = 2
path2Runs = "/Users/bflinch/Dropbox/Clemson/Research/GithubDevel/PyGimliRefractionInversionScripts/BootstrapInversion/runs/"
#*************************************************************************
#********** DO INVERSION***************************************************
if nRuns > 1:
for i in range(0, nRuns):
folderName = "run" + str(i + 1)
#Convert the file
inFile = resamplePicks(pickFile, fract2Remove, topoFile, minError,
maxError)
#Read in the file with gimli method
data = loadGimliTT(inFile)
#Create the structure required for inversion using TravelTimeManager and data container
ra = TravelTimeManager(data)
#Generate the mesh
mesh = ra.createMesh(data=ra.data,
paraDepth=maxDepth,
paraDX=meshDx,
paraMaxCellSize=maxTriArea)
#Do the Inversion (time the inversion)
start = time.time()
ra.inv.maxIter = maxIterations
ra.invert(data=ra.data,
mesh=mesh,
lam=smoothing,
zWeight=vertWeight,
useGradient=True,
vTop=minVel,
# points using 63 sensors (shots and geophones) with the data columns s (shot),
# g (geophone), and t (traveltime). By default, there is also a validity flag.
data = pg.getExampleFile("traveltime/koenigsee.sgt", load=True, verbose=True)
print(data)
################################################################################
# Let's have a look at the data in the form of traveltime curves.
fig, ax = pg.plt.subplots()
pg.physics.traveltime.drawFirstPicks(ax, data)
################################################################################
# We initialize the refraction manager.
mgr = TravelTimeManager()
# Alternatively, one can plot a matrix plot of apparent velocities which is the
# more general function also making sense for crosshole data.
ax, cbar = mgr.showData(data)
################################################################################
# Finally, we call the `invert` method and plot the result.The mesh is created
# based on the sensor positions on-the-fly.
mgr.invert(data, secNodes=3, paraMaxCellSize=5.0,
zWeight=0.2, vTop=500, vBottom=5000,
verbose=1)
################################################################################
import numpy as np
from matplotlib import pyplot as plt
# Import of PyGimli
import pygimli as pg
from pygimli import meshtools as mt
from pygimli.physics import TravelTimeManager as TTMgr
# Import of TKinker
from tkinter import Tk
from tkinter.filedialog import askopenfilename as askfilename
if __name__ == '__main__':
root = Tk()
filename = askfilename(filetypes = (("First-Arrival", "*.sgt"), ("All types", "*.*")))
root.destroy()
# Parameters:
lambdaParam = 10 # Smoothing the model
depthMax = 50 # Forcing a given depth to the model
maxCellSize = 2.5 # Forcing a given size for the mesh cells
zWeightParam = 0.1 # Forcing Horizontal features in the model (smaller than 1) or vertical (larger than 1)
# Inversion:
dataTT = pg.DataContainer(filename, 's g t')
print(dataTT)
mgr = TTMgr(data=dataTT)
meshTT = mgr.createMesh(data=dataTT, paraMaxCellSize=maxCellSize, paraDepth=depthMax)
mgr.invert(data=dataTT, mesh= meshTT, zWeight=zWeightParam, lam=lambdaParam, verbose=True)
ax,cbar = mgr.showResult(logScale=True)
mgr.drawRayPaths(ax=ax, color='w', lw=0.3, alpha=0.5)
plt.show()
mgr.showCoverage()
plt.show()
################################################################################
# We import pyGIMLi and the refraction manager.
import pygimli as pg
from pygimli.physics import TravelTimeManager
################################################################################
# The helper function `pg.getExampleFile` downloads the data set and saves it
# into a temporary location.
data = pg.getExampleFile("traveltime/koenigsee.sgt", load=True, verbose=True)
################################################################################
# We initialize the refraction manager.
mgr = TravelTimeManager()
################################################################################
# Let's have a look at the data in the form of traveltime curves and apparent
# velocity images.
mgr.showData(data) # show first arrivals as curves (done later with response)
#TODO mgr.showVA(data) # show data as apparent velocity image
################################################################################
# Finally, we call the `invert` method and plot the result.The mesh is created
# based on the sensor positions on-the-fly. Yes, it is really as simple as that.
mgr.invert(data,
secNodes=3,
paraMaxCellSize=5.0,
zWeight=0.2,
phi.append(1 - frtrue[idx])
phi = np.array(phi)
fr_min = 0
fr_max = 1
else:
phi = poro
fpm = FourPhaseModel(phi=phi)
# Setup managers and equip with meshes
ert = ERTManager()
ert.setMesh(meshERT)
ert.setData(ertScheme)
ttData = pg.DataContainer("tttrue.dat")
rst = TravelTimeManager(verbose=True)
rst.setData(ttData)
rst.setMesh(meshRST, secNodes=3)
# Setup joint modeling and inverse operators
JM = JointMod(meshRST, ert, rst, fpm, fix_poro=fix_poro, zWeight=0.25)
data = pg.cat(ttData("t"), ertScheme("rhoa"))
error = pg.cat(ttData("err") / ttData("t"), ertScheme("err"))
# Set gradient starting model of f_ice, f_water, f_air = phi/3
velstart = np.loadtxt("rst_startmodel_%d.dat" % case)
rhostart = np.ones_like(velstart) * np.mean(ertScheme("rhoa"))
fas, fis, fws, _ = fpm.all(rhostart, velstart)
frs = np.ones_like(fas) - fpm.phi
if not fix_poro:
