def simulateSynth(model, tMax=5000, satSteps=150, ertSteps=10, area=0.1,
synthPath='synth/'):
"""Create synthetic example."""
if not os.path.exists('synth/'):
os.mkdir(synthPath)
world = mt.createWorld(start=[-20, 0], end=[20, -16], layers=[-2, -8],
worldMarker=False)
for i, b in enumerate(world.boundaries()):
b.setMarker(i + 1)
block = mt.createRectangle(start=[-6, -3.5], end=[6, -6.0], marker=4,
boundaryMarker=11, area=area)
geom = mt.mergePLC([world, block])
geom.save(synthPath + 'synthGeom')
# pg.show(geom, boundaryMarker=1)
paraMesh = pg.meshtools.createMesh(geom, quality=32, area=area,
smooth=[1, 10])
# translate 1 2 3 4 - > 0 1 2 3
mapMarker = np.array([0, 0, 1, 2, 3], 'float')
paraMesh.setCellMarkers(mapMarker[np.array(paraMesh.cellMarkers())])
paraMesh.save(synthPath + 'synth.bms')
fop = HydroGeophysicalModelling(mesh=paraMesh, tMax=tMax,
satSteps=satSteps,
ertSteps=ertSteps,
verbose=1)
# openblas have some problems with to high thread count ..
# we need to dig into
print("ThreadCount:", pg.threadCount())
pg.setThreadCount(4)
print('##### Simulate synthetic data ' + '#'*50)
pg.tic()
rhoaR = fop.response(pg.RVector(model)[paraMesh.cellMarkers()])
pg.toc()
print('#'*100)
# add some noise here
rand = pg.RVector(len(rhoaR))
pg.randn(rand)
rhoaR *= (1.0 + rand * fop.ws.derr.flatten())
fop.ws.rhoaR = rhoaR.reshape(fop.ws.derr.shape)
# fop.ws.mesh.save(synthPath + 'synth.bms')
np.save(synthPath + 'synthK', fop.ws.k)
np.save(synthPath + 'synthVel', fop.ws.vel)
np.save(synthPath + 'synthSat', fop.ws.sat)
fop.ws.scheme.save(synthPath + 'synth.shm', 'a b m n')
np.save(synthPath + 'synthRhoaRatio', fop.ws.rhoaR)
np.save(synthPath + 'synthRhoa', fop.ws.rhoa)
np.save(synthPath + 'synthErr', fop.ws.derr)
def test(N):
x = np.linspace(0, 1, N)
pg.tic()
mesh = pg.createGrid(x, x, x)
print(mesh)
pg.toc()
A = pg.RSparseMatrix()
A.fillStiffnessMatrix(mesh)
pg.toc()
def test(N):
x = np.linspace(0, 1, N)
pg.tic()
mesh = pg.createGrid(x, x, x)
print(mesh)
pg.toc()
A = pg.RSparseMatrix()
A.fillStiffnessMatrix(mesh)
pg.toc()
def calculate_current_flow(self, time=False, verbose=False):
"""
Perform the simulation based on the mesh, data and scheme
Returns:
RMatrix and RVector
"""
if time:
pg.tic()
self.sim = ert.simulate(self.mesh, res=self.data, scheme=self.scheme, sr=False,
calcOnly=True, verbose=verbose, returnFields=True)
if time:
pg.toc("Current flow", box=True)
self.pot = pg.utils.logDropTol(self.sim[0] - self.sim[1], 10)
return self.sim, self.pot
def calculate_sensitivity(self, time=False):
"""
Make a sensitivity analysis
Returns:
"""
if time:
pg.tic()
self.fop = ert.ERTModelling()
self.fop.setData(self.scheme)
self.fop.setMesh(self.mesh)
self.fop.createJacobian(self.data)
if time:
pg.toc("Sensitivity calculation", box=True)
sens = self.fop.jacobian()[0] # first row = first measurement
self.normsens = pg.utils.logDropTol(sens / self.mesh.cellSizes(), 5e-5)
self.normsens /= numpy.max(self.normsens)
return self.fop
def createMeshPatches(ax, mesh, verbose=True):
"""Utility function to create 2d mesh patches within a given ax."""
if not mesh:
pg.error("drawMeshBoundaries(ax, mesh): invalid mesh:", mesh)
return
if mesh.nodeCount() < 2:
pg.error("drawMeshBoundaries(ax, mesh): to few nodes:", mesh)
return
pg.tic()
polys = [_createCellPolygon(c) for c in mesh.cells()]
patches = mpl.collections.PolyCollection(polys, picker=True)
if verbose:
pg.info("Creation of mesh patches took = ", pg.toc())
return patches
def createMeshPatches(ax, mesh, verbose=True, rasterized=False):
"""Utility function to create 2d mesh patches within a given ax."""
if not mesh:
pg.error("drawMeshBoundaries(ax, mesh): invalid mesh:", mesh)
return
if mesh.nodeCount() < 2:
pg.error("drawMeshBoundaries(ax, mesh): to few nodes:", mesh)
return
pg.tic()
polys = [_createCellPolygon(c) for c in mesh.cells()]
patches = mpl.collections.PolyCollection(polys, picker=True,
rasterized=rasterized)
if verbose:
pg.info("Creation of mesh patches took = ", pg.toc())
return patches
"""
mesh = pg.Mesh('vagnh_fwd_mesh.bms')
mesh.createNeighbourInfos()
data = pg.DataContainer('vagnh_NONOISE.sgt', 's g')
vel = [1400., 1700., 5000.]
slo = np.array([0, 0, 1. / 1400., 1. / 1700., 1. / 5000.])
cslo = slo.take(mesh.cellMarkers())
print(mesh)
print(data)
fwd = TravelTimeFMM(mesh, data, True)
pg.tic()
t_fmm = fwd.response(cslo)
# t_fmm = fwd.response(1.0/np.array(vel))
pg.toc()
# delta_t = np.array(data("t")) - t_fmm
# f, ax = plt.subplots()
# x = pg.x(data.sensorPositions())
# ax.plot(abs(delta_t), 'r-.', label='abs. diff')
# ax.plot(delta_t, 'b-', label='diff')
# ax.legend(loc='best')
# f.show()
# raise SystemExit()
l = fwd._trace_back(50, 0)
fig, a = plt.subplots()
drawMesh(a, mesh)
pg.show(mesh, axes=a, data=l[0])
def simulateSynth(model,
tMax=5000,
satSteps=150,
ertSteps=10,
area=0.1,
synthPath='synth/'):
"""Create synthetic example."""
if not os.path.exists('synth/'):
os.mkdir(synthPath)
world = mt.createWorld(start=[-20, 0],
end=[20, -16],
layers=[-2, -8],
worldMarker=False)
for i, b in enumerate(world.boundaries()):
b.setMarker(i + 1)
block = mt.createRectangle(start=[-6, -3.5],
end=[6, -6.0],
marker=4,
boundaryMarker=11,
area=area)
geom = mt.mergePLC([world, block])
geom.save(synthPath + 'synthGeom')
# pg.show(geom, boundaryMarker=1)
paraMesh = pg.meshtools.createMesh(geom,
quality=32,
area=area,
smooth=[1, 10])
# translate 1 2 3 4 - > 0 1 2 3
mapMarker = np.array([0, 0, 1, 2, 3], 'float')
paraMesh.setCellMarkers(mapMarker[np.array(paraMesh.cellMarkers())])
paraMesh.save(synthPath + 'synth.bms')
fop = HydroGeophysicalModelling(mesh=paraMesh,
tMax=tMax,
satSteps=satSteps,
ertSteps=ertSteps,
verbose=1)
# openblas have some problems with to high thread count ..
# we need to dig into
print("TC", pg.threadCount())
pg.setThreadCount(4)
print('##### Simulate synthetic data ' + '#' * 50)
pg.tic()
rhoaR = fop.response(pg.RVector(model)[paraMesh.cellMarkers()])
pg.toc()
print('#' * 100)
# add some noise here
rand = pg.RVector(len(rhoaR))
pg.randn(rand)
rhoaR *= (1.0 + rand * fop.ws.derr.flatten())
fop.ws.rhoaR = rhoaR.reshape(fop.ws.derr.shape)
# fop.ws.mesh.save(synthPath + 'synth.bms')
np.save(synthPath + 'synthK', fop.ws.k)
np.save(synthPath + 'synthVel', fop.ws.vel)
np.save(synthPath + 'synthSat', fop.ws.sat)
fop.ws.scheme.save(synthPath + 'synth.shm', 'a b m n')
np.save(synthPath + 'synthRhoaRatio', fop.ws.rhoaR)
np.save(synthPath + 'synthRhoa', fop.ws.rhoa)
np.save(synthPath + 'synthErr', fop.ws.derr)
"""
mesh = pg.Mesh('vagnh_fwd_mesh.bms')
mesh.createNeighbourInfos()
data = pg.DataContainer('vagnh_NONOISE.sgt', 's g')
vel = [1400., 1700., 5000.]
slo = np.array([0, 0, 1./1400., 1./1700., 1./5000.])
cslo = slo.take(mesh.cellMarkers())
print(mesh)
print(data)
fwd = TravelTimeFMM(mesh, data, True)
pg.tic()
t_fmm = fwd.response(cslo)
# t_fmm = fwd.response(1.0/np.array(vel))
pg.toc()
# delta_t = np.array(data("t")) - t_fmm
# f, ax = plt.subplots()
# x = pg.x(data.sensorPositions())
# ax.plot(abs(delta_t), 'r-.', label='abs. diff')
# ax.plot(delta_t, 'b-', label='diff')
# ax.legend(loc='best')
# f.show()
# raise SystemExit()
l = fwd._trace_back(50, 0)
fig, a = plt.subplots()
drawMesh(a, mesh)
pg.show(mesh, axes=a, data=l[0])
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)
for r, p in enumerate(recs):
if r == 0:
lab = "Raypath with %d sec nodes" % n
else:
lab = None
recNode = mgr.fop.mesh().findNearestNode([sensors[p], 0.0])
sourceNode = mgr.fop.mesh().findNearestNode([0.0, 0.0])
path = mgr.fop.dijkstra.shortestPath(sourceNode, recNode)
points = mgr.fop.mesh().positions(withSecNodes=True)[path]
ax[0, j].plot(pg.x(points), pg.y(points), cols[i], label=lab)
t_ana = ana(px)
ndata = len(px) - 1
data.resize(ndata)
data.set('s', pg.RVector(ndata, source)) # only one shot at first sensor
data.set('g', pg.utils.grange(1, ndata, 1)) # all others and geophones
# We compare the accuracy for 0-5 secondary nodes
sec_nodes = [0, 1, 3, 5]
t_all = []
durations = []
paths = []
for n in sec_nodes:
if n > 0:
pg.tic()
mesh2 = mesh.createMeshWithSecondaryNodes(n)
pg.toc("Mesh generation with %d secondary nodes:" % n)
else:
mesh2 = mesh
# Perform traveltime calculations and log time with pg.tic() & pg.toc()
pg.tic()
fop = pg.TravelTimeDijkstraModelling(mesh2, data)
t_all.append(fop.response(1 / vel))
durations.append(pg.dur())
pg.toc("Raytracing with %d secondary nodes:" % n)
# This is to show single raypaths.
dij = pg.Dijkstra(fop.createGraph(1 / vel))
dij.setStartNode(mesh2.findNearestNode([0, 0]))
paths_per_receiver = []
for receiver in sensors:
