def test_region_marker_position_two_ways_v2(self):
rect1 = mt.createRectangle(
start=[0.0, -1.5],
end=[4.0, -4.0],
isClosed=True,
marker=1,
)
# scaled version
rect2 = mt.createRectangle(
pos=[2.0, -2.75],
size=[4.0, 2.5],
isClosed=True,
marker=2,
)
assert rect1.regionMarkers()[0].x() == 4 * 0.2
assert rect1.regionMarkers()[0].y() == -1.5 - 2.5 * 0.2
assert rect1.regionMarkers()[0].marker() == 1
assert rect2.regionMarkers()[0].marker() == 2
assert rect1.regionMarkers()[0].x() == rect1.regionMarkers()[0].x()
assert rect2.regionMarkers()[0].x() == rect2.regionMarkers()[0].x()
assert rect1.regionMarkers()[0].y() == rect1.regionMarkers()[0].y()
assert rect2.regionMarkers()[0].y() == rect2.regionMarkers()[0].y()
def test_region_marker_position_two_ways_v2(self):
rect1 = mt.createRectangle(
start=[0.0, -1.5],
end=[4.0, -4.0],
isClosed=True,
marker=1,
)
# scaled version
rect2 = mt.createRectangle(
pos=[2.0, -2.75],
size=[4.0, 2.5],
isClosed=True,
marker=2,
)
assert rect1.regionMarker()[0].x() == 4 * 0.2
assert rect1.regionMarker()[0].y() == -1.5 - 2.5 * 0.2
assert rect1.regionMarker()[0].marker() == 1
assert rect2.regionMarker()[0].marker() == 2
assert rect1.regionMarker()[0].x() == rect1.regionMarker()[0].x()
assert rect2.regionMarker()[0].x() == rect2.regionMarker()[0].x()
assert rect1.regionMarker()[0].y() == rect1.regionMarker()[0].y()
assert rect2.regionMarker()[0].y() == rect2.regionMarker()[0].y()
def generate_hom_world_with_inclusion(world_dim: list, incl_start: list,
incl_dim: list):
""" Creates a homogeneous world with inclusion.
Utility function to create a homogeneous world with an inclusion. Region markers are set to 1 for the background
world and 2 for the inclusion.
Parameter:
world_dim: World dimensions as [x,z].
incl_start: Inclusion upper left corner as [x,z].
incl_dim: Inclusion dimension as [x,z].
Returns:
The created world.
"""
# Create geometric objects
world = mt.createWorld(start=[0, 0], end=[world_dim[0], -world_dim[1]])
inclusion = mt.createRectangle(
start=incl_start,
end=[incl_start[0] + incl_dim[0], incl_start[1] - incl_dim[1]],
marker=2,
boundaryMarker=10)
# Merge geometries
geom = mt.mergePLC([world, inclusion])
return geom
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 generate_layered_world_with_inclusion(world_dim: list, layer_heights: list,
incl_start: list, incl_dim: list):
""" Creates a layered world with inclusion.
Utility function to create a layered world with an inclusion. Region markers are starting at 1 and increasing with
depth. The inclusion has the highest marker number.
Parameter:
world_dim: World dimensions as [x,z].
layer_heights: Heights of the single layers.
incl_start: Inclusion upper left corner as [x,z].
incl_dim: Inclusion dimension as [x,z].
Returns:
The created world.
"""
# Check parameter integrity
if sum(layer_heights) > world_dim[1]:
return None
# Create geometric objects
world = mt.createWorld(start=[0, 0], end=[world_dim[0], -world_dim[1]])
current_depth = 0
layers = []
for i in range(len(layer_heights)):
layer = mt.createRectangle(
start=[0, -current_depth],
end=[world_dim[0], -(current_depth + layer_heights[i])],
marker=i + 1,
boundaryMarker=10)
current_depth += layer_heights[i]
layers.append(layer)
if current_depth != world_dim[1]:
layer = mt.createRectangle(start=[0, -current_depth],
end=[world_dim[0], -world_dim[1]],
marker=i + 2,
boundaryMarker=10)
layers.append(layer)
inclusion = mt.createRectangle(
start=incl_start,
end=[incl_start[0] + incl_dim[0], incl_start[1] - incl_dim[1]],
marker=len(layers) + 1,
boundaryMarker=10)
# Merge geometries
geom = mt.mergePLC([world, inclusion] + layers)
return geom
def test_region_marker_position_translation_scale(self):
rect1 = mt.createRectangle(
pos=[1.0, 2.0],
size=[2.0, 4],
isClosed=True,
marker=20,
)
assert rect1.regionMarkers()[0].x() == -0.3
assert rect1.regionMarkers()[0].y() == 0.3
assert rect1.regionMarkers()[0].marker() == 20
def test_region_marker_position_basics(self):
rect1 = mt.createRectangle(
start=[0.0, 0.0],
end=[2.0, -1.0],
isClosed=True,
marker=1,
)
# by default the region marker should be located at
# sPos + (ePos - sPos) * 0.2)
assert rect1.regionMarkers()[0].x() == 0.4
assert rect1.regionMarkers()[0].y() == -0.2
assert rect1.regionMarkers()[0].marker() == 1
def test_region_marker_position_translation_scale(self):
rect1 = mt.createRectangle(
pos=[1.0, 2.0],
size=[2.0, 4],
isClosed=True,
marker=20,
)
# by default the region marker should be located at
# sPos + (ePos - sPos) * 0.2)
assert rect1.regionMarker()[0].x() == 0.4
assert rect1.regionMarker()[0].y() == 4 - 4 * 0.2
assert rect1.regionMarker()[0].marker() == 20
def test_region_markerposition_pos_size(self):
# scaled version
rect1 = mt.createRectangle(
pos=[2.0, -2.75],
size=[4.0, 2.5],
isClosed=True,
marker=5,
markerPosition=[0.0, 0.0],
)
assert rect1.regionMarkers()[0].x() == 0
assert rect1.regionMarkers()[0].y() == 0
assert rect1.regionMarkers()[0].marker() == 5
def test_region_markerposition_start_end(self):
rect1 = mt.createRectangle(
start=[0.0, -1.5],
end=[4.0, -4.0],
isClosed=True,
marker=10,
markerPosition=[0.0, 0.0],
)
assert rect1.regionMarkers()[0].x() == 0
assert rect1.regionMarkers()[0].y() == 0
assert rect1.regionMarkers()[0].marker() == 10
def test_region_markerposition_pos_size(self):
# scaled version
rect1 = mt.createRectangle(
pos=[2.0, -2.75],
size=[4.0, 2.5],
isClosed=True,
marker=5,
markerPosition=[0.0, 0.0],
)
assert rect1.regionMarker()[0].x() == 0
assert rect1.regionMarker()[0].y() == 0
assert rect1.regionMarker()[0].marker() == 5
def test_region_markerposition_start_end(self):
rect1 = mt.createRectangle(
start=[0.0, -1.5],
end=[4.0, -4.0],
isClosed=True,
marker=10,
markerPosition=[0.0, 0.0],
)
assert rect1.regionMarker()[0].x() == 0
assert rect1.regionMarker()[0].y() == 0
assert rect1.regionMarker()[0].marker() == 10
def test_region_marker_position_basics(self):
rect1 = mt.createRectangle(
start=[0.0, 0.0],
end=[2.0, -1.0],
isClosed=True,
marker=1,
)
# by default the region marker should be located at
# sPos + (ePos - sPos) * 0.2)
assert rect1.regionMarker()[0].x() == 0.4
assert rect1.regionMarker()[0].y() == -0.2
assert rect1.regionMarker()[0].marker() == 1
def test_region_marker_position_translation_scale(self):
rect1 = mt.createRectangle(
pos=[1.0, 2.0],
size=[2.0, 4],
isClosed=True,
marker=20,
)
# by default the region marker should be located at
# sPos + (ePos - sPos) * 0.2)
assert rect1.regionMarker()[0].x() == 0.4
assert rect1.regionMarker()[0].y() == 4 - 4 * 0.2
assert rect1.regionMarker()[0].marker() == 20
def testCBarLevels():
"""
Expectations
------------
axs[0, 0]: show regions with plc
Show needs to deliver the regions with Set3 colormap. Each tick on the
colobar should be in the middle of the related color section.
axs[1, 0]: show regions with mesh
really the same thing as on axs[0, 0] but with mesh.
ax[0, 1]: show mesh with cell data
if nLevs is given i would expect that the colormap then is levelled.
currently that is not the fact. but at least its the full range. labels
need to be at begin/end of each color section.
ax[1, 1]: show mesh with node data
the colorbar range misses parts of its full range. labels need to be
at begin/end of each color section.
"""
# create a geometry
world = mt.createWorld(start=[-10, 0],
end=[10, -16],
layers=[-8],
worldMarker=False)
block = mt.createRectangle(start=[-6, -3.5],
end=[6, -6.0],
marker=4,
boundaryMarker=10,
area=0.1)
circ = mt.createCircle(pos=[0, -11], marker=5, radius=2, boundaryMarker=11)
poly = mt.mergePLC([world, block, circ])
mesh = mt.createMesh(poly, quality=34)
# create random data
rhomap = [[1, 10], [2, 4], [4, 20], [5, 8]]
# map data to cell/node count
cell_data = pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh)
node_data = mt.cellDataToNodeData(mesh, cell_data)
# plot everything
fig, axs = pg.plt.subplots(2, 2, figsize=(20, 10))
pg.show(poly, ax=axs[0, 0])
pg.show(mesh, ax=axs[1, 0], markers=True)
pg.show(mesh, cell_data, ax=axs[0, 1], colorBar=True, nLevs=7)
pg.show(mesh, node_data, ax=axs[1, 1], colorBar=True, nLevs=7)
def testShowVariants():
# Create geometry definition for the modelling domain
world = mt.createWorld(start=[-10, 0], end=[10, -16],
layers=[-8], worldMarker=False)
# Create a heterogeneous block
block = mt.createRectangle(start=[-6, -3.5], end=[6, -6.0],
marker=4, boundaryMarker=10, area=0.1)
circ = mt.createCircle(pos=[0, -11], radius=2, boundaryMarker=11, isHole=True)
# Merge geometrical entities
geom = world + block + circ
mesh = mt.createMesh(geom)
fig, axs = plt.subplots(3,5)
pg.show(geom, ax=axs[0][0])
axs[0][0].set_title('plc, (default)')
pg.show(geom, fillRegion=False, ax=axs[0][1])
axs[0][1].set_title('plc, fillRegion=False')
pg.show(geom, showBoundary=False, ax=axs[0][2])
axs[0][2].set_title('plc, showBoundary=False')
pg.show(geom, markers=True, ax=axs[0][3])
axs[0][3].set_title('plc, markers=True')
pg.show(mesh, ax=axs[0][4], showBoundary=False)
axs[0][4].set_title('mesh, showBoundary=False')
pg.show(mesh, ax=axs[1][0])
axs[1][0].set_title('mesh, (default)')
pg.show(mesh, mesh.cellMarkers(), label='Cell markers', ax=axs[1][1])
axs[1][1].set_title('mesh, cells, (default)')
pg.show(mesh, markers=True, ax=axs[1][2])
axs[1][2].set_title('mesh, cells, markers=True')
pg.show(mesh, mesh.cellMarkers(), label='Cell markers', showMesh=True, ax=axs[1][3])
axs[1][3].set_title('mesh, cells, showMesh=True')
pg.show(mesh, mesh.cellMarkers(), label='Cell markers', showBoundary=False, ax=axs[1][4])
axs[1][4].set_title('mesh, cells, showBoundary=False')
pg.show(mesh, pg.x(mesh), label='Nodes (x)', ax=axs[2][0])
axs[2][0].set_title('mesh, nodes, (default)')
pg.show(mesh, pg.x(mesh), label='Nodes (x)', showMesh=True, ax=axs[2][1])
axs[2][1].set_title('mesh, nodes, showMesh=True')
pg.show(mesh, pg.x(mesh), label='Nodes (x)', showBoundary=True, ax=axs[2][2])
axs[2][2].set_title('mesh, nodes, showBoundary=True')
pg.show(mesh, pg.y(mesh.cellCenters()), label='Cell center (y)',
tri=True, shading='flat', ax=axs[2][3])
axs[2][3].set_title('mesh, cells, tri=True, shading=flat')
pg.show(mesh, pg.y(mesh.cellCenters()), label='Cell center (y)',
tri=True, shading='gouraud', ax=axs[2][4])
axs[2][4].set_title('mesh, cells, tri=True, shading=gouraud')
##pg.show(mesh, mesh.cellMarker(), label(markers), axs[1][1])
axs[2][4].figure.tight_layout()
def test_region_marker_position_two_ways_v1(self):
rect1 = mt.createRectangle(
start=[-2.0, -1.0],
end=[2.0, 1.0],
isClosed=True,
marker=1,
)
# scaled version
rect2 = mt.createRectangle(
pos=[0.0, 0.0],
size=[4.0, 2],
isClosed=True,
marker=2,
)
assert rect1.regionMarkers()[0].x() == -2 + 0.2 * 4
assert rect1.regionMarkers()[0].y() == -1 + 0.2 * 2
assert rect1.regionMarkers()[0].marker() == 1
assert rect2.regionMarkers()[0].marker() == 2
assert rect1.regionMarkers()[0] == rect2.regionMarkers()[0]
def generate_layered_world(world_dim: list, layer_heights: list):
""" Creates a layered world.
Utility function to create a layered world. Region markers are starting at 1 and increasing with depth.
Parameter:
world_dim: World dimensions as [x,z].
layer_heights: Heights of the single layers.
Returns:
The created world.
"""
# Check parameter integrity
if sum(layer_heights) > world_dim[1]:
return None
# Create geometric objects
world = mt.createWorld(start=[0, 0], end=[world_dim[0], -world_dim[1]])
current_depth = 0
layers = []
for i in range(len(layer_heights)):
layer = mt.createRectangle(
start=[0, -current_depth],
end=[world_dim[0], -(current_depth + layer_heights[i])],
marker=i + 1,
boundaryMarker=10)
current_depth += layer_heights[i]
layers.append(layer)
if current_depth != world_dim[1]:
layer = mt.createRectangle(start=[0, -current_depth],
end=[world_dim[0], -world_dim[1]],
marker=i + 2,
boundaryMarker=10)
layers.append(layer)
# Merge geometries
geom = mt.mergePLC([world] + layers)
return geom
def generate_tiled_world(world_dim: list, tile_size: list):
""" Creates a tiled layered world.
Utility function to create a tiled layered world. Region marker 1 is upper left corner.
Parameter:
world_dim: World dimensions as [x,z].
tile_size: Tile dimensions as [x,z].
Returns:
The created world.
"""
# Create world
world = mt.createWorld(start=[0, 0], end=[world_dim[0], -world_dim[1]])
# Create tile counts
n_tiles_x = int(np.ceil(world_dim[0] / tile_size[0]))
n_tiles_y = int(np.ceil(world_dim[1] / tile_size[1]))
# Create and merge tiles
for j in range(n_tiles_y):
for i in range(n_tiles_x):
x_start = int(i * tile_size[0])
x_end = int((i + 1) * tile_size[0])
y_start = int(-j * tile_size[1])
y_end = int(-(j + 1) * tile_size[1])
if x_end > world_dim[0]:
x_end = world_dim[0]
if y_end < -world_dim[1]:
y_end = -world_dim[1]
marker = 1
if ((-1)**i) * ((-1)**j) < 0:
marker = 2
tile = mt.createRectangle(start=[x_start, y_start],
end=[x_end, y_end],
marker=marker,
boundaryMarker=10)
world = mt.mergePLC([world, tile])
return world
import pygimli as pg
# pg.setTestingMode(True)
import pygimli.meshtools as mt
from pygimli.physics.traveltime import TravelTimeManager
pg.utils.units.quants['vel']['cMap'] = 'inferno_r'
################################################################################
# Next, we build the crosshole acquisition geometry with two shallow boreholes.
# Acquisition parameters
bh_spacing = 20.0
bh_length = 25.0
sensor_spacing = 2.5
world = mt.createRectangle(start=[0, -(bh_length + 3)],
end=[bh_spacing, 0.0],
marker=0)
depth = -np.arange(sensor_spacing, bh_length + sensor_spacing, sensor_spacing)
sensors = np.zeros((len(depth) * 2, 2)) # two boreholes
sensors[len(depth):, 0] = bh_spacing # x
sensors[:, 1] = np.hstack([depth] * 2) # y
###############################################################################
# Traveltime calculations work on unstructured meshes and structured grids. We
# demonstrate this here by simulating the synthetic data on an unstructured
# mesh and inverting it on a simple structured grid.
# Create forward model and mesh
c0 = mt.createCircle(pos=(7.0, -10.0), radius=3, segments=25, marker=1)
isClosed=True,
area=1,
marker=2)
sup2 = mt.createPolygon([[40, 0], [81, 0], [81, -1.5], [38.8, -1.5]],
isClosed=True,
area=1,
marker=4)
sup3 = mt.createPolygon([[30, 0], [40, 0], [39.6, -0.5], [30.4, -0.5]],
isClosed=True,
area=1,
marker=4)
pol = mt.createPolygon([[30, 0], [40, 0], [38, -2.5], [32, -2.5]],
isClosed=True,
area=1,
marker=0)
square = mt.createRectangle(start=[34, -0.5], end=[36, -2.5], area=1, marker=3)
world = mt.mergePLC([background, pol, square, sup, sup2, sup3])
mesh = mt.createMesh(world, quality=33, area=0.1, smooth=[1, 2])
res_model = pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh)
#INTERPOLACIÓN MODELO A GRID
nan = 99.9
model_vector_nn = []
for pos in grid.cellCenters():
cell = mesh.findCell(pos)
if cell:
model_vector_nn.append(res_model[cell.id()])
else:
model_vector_nn.append(nan)
plc = mt.mergePLC([polygon1, polygon2])
ax, cb = pg.show(plc, markers=True)
fig = ax.get_figure()
for nr, marker in enumerate(plc.regionMarker()):
print('Position marker number {}:'.format(nr + 1), marker.x(), marker.y(),
marker.z())
ax.scatter(marker.x(), marker.y(), s=(4 - nr) * 20, color='k')
ax.set_title('marker positions - working example')
fig.show()
###############################################################################
# And finally, a similar example for rectangles...
rect1 = mt.createRectangle(
start=[0.0, 0.0],
end=[2.0, -1.0],
isClosed=True,
marker=1,
)
# move the rectangle by changing the center position
rect2 = mt.createRectangle(
start=[0.0, 0.0],
end=[1.0, -0.5],
isClosed=True,
marker=2,
)
plc = mt.mergePLC([rect1, rect2])
ax, cb = pg.show(plc, markers=True)
\textbf{C}_{\text{M},ij}=\sigma^{2}\exp{\left(
-3\sqrt{\left(\frac{\textbf{H}_{x,ij}}{I_{x}}\right)^{2}+
\left(\frac{\textbf{H}_{y,ij}}{I_{y}}\right)^{2}+
\left(\frac{\textbf{H}_{z,ij}}{I_{z}}\right)^{2}}\right)}.
It defines the correlation between model cells as a function of correlation
lenghts (ranges) :math:`I_x`, :math:`I_y`, and :math:`I_z`. Of course, the
orientation of the coordinate axes is arbitrary and can be chosen by rotation.
Let us illustrate this by a simple mesh:
"""
# %% create a simple mesh (e.g. a crosshole box geometry)
import pygimli as pg
import pygimli.meshtools as mt
# We create a rectangular domain and mesh it with small triangles
rect = mt.createRectangle(start=[0, -10], end=[10, 0])
mesh = mt.createMesh(rect, quality=34.5, area=0.1)
# %%
# We can compute this covariance matrix by calling
CM = pg.matrix.covarianceMatrix(mesh, I=5)
# We search for the cell where the midpoint (5, -5) is located in
ind = mesh.findCell([5, -5]).id()
# and plot the according column
# col = pg.log10(CM.dot(vec))
pg.show(mesh, CM[:, ind], cMap="magma_r")
# %%
# According to inverse theory, we use the square root of the covariance matrix
# as single-side regularization matrix C. It is computed by using an eigenvalue
# decomposition based on the numpy linalg procedure
@author: Aritz
"""
import numpy as np
import pygimli as pg
import pygimli.meshtools as mt
import matplotlib.pyplot as plt
import pybert as pb
#creación grid para comparación
grid = pg.createGrid(x=pg.utils.grange(start=0, end=71, n=500),
y=-pg.utils.grange(0, 15, n=250, log=False))
grid2 = pg.createGrid(x=pg.utils.grange(start=50, end=60, n=500),
y=-pg.utils.grange(5.5, 9.5, n=250, log=False))
square = mt.createRectangle(start=[50, -5.5], end=[60, -9.5])
#parametros inversion
quality = 34.5
maxCellArea = 1
robustData = True
paraDX = 0.25
lam = 20
#PARAMETROS MODELADO
noise = 0
rhomap = [[0, 500], [1, 50], [2, 100], [3, 2000]]
#CREACION MODELO GENERAL
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)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Minimal example of using pygimli to simulate the steady heat equation.
"""
import pygimli as pg
import pygimli.meshtools as mt
# Create geometry definition for the modelling domain
world = mt.createWorld(start=[-20, 0], end=[20, -16], layers=[-2, -8],
worldMarker=False)
# Create a heterogeneous block
block = mt.createRectangle(start=[-6, -3.5], end=[6, -6.0],
marker=4, boundaryMarker=10, area=0.1)
# Merge geometrical entities
geom = mt.mergePLC([world, block])
pg.show(geom, boundaryMarker=True, savefig='geometry.pdf')
# Create a mesh from the geometry definition
mesh = mt.createMesh(geom, quality=33, area=0.2, smooth=[1, 10])
pg.show(mesh, savefig='mesh.pdf')
# $\diverg(a\grad T)=0$ with $T(bottom)=1$, $T(top)=0$
T = pg.solver.solveFiniteElements(mesh,
a=[[1, 1.0], [2, 2.0], [3, 3.0], [4, 0.1]],
uB=[[8, 1.0], [4, 0.0]], verbose=True)
ax, _ = pg.show(mesh, data=T, label='Temperature $T$', cmap="hot_r",
showBoundary=True, savefig='T_field.pdf')
import pygimli as pg
import pygimli.meshtools as mt
from pygimli.physics.traveltime import Refraction
mpl.rcParams['image.cmap'] = 'inferno_r'
################################################################################
# Next, we build the crosshole acquisition geometry with two shallow boreholes.
# Acquisition parameters
bh_spacing = 20.0
bh_length = 25.0
sensor_spacing = 2.5
world = mt.createRectangle(start=[0, -(bh_length + 3)], end=[bh_spacing, 0.0],
marker=0)
depth = -np.arange(sensor_spacing, bh_length + sensor_spacing, sensor_spacing)
sensors = np.zeros((len(depth) * 2, 2)) # two boreholes
sensors[len(depth):, 0] = bh_spacing # x
sensors[:, 1] = np.hstack([depth] * 2) # y
################################################################################
# Traveltime calculations work on unstructured meshes and structured grids. We
# demonstrate this here by simulating the synthetic data on an unstructured mesh
# and inverting it on a simple structured grid.
# Create forward model and mesh
c0 = mt.createCircle(pos=(7.0, -10.0), radius=3, segments=25, marker=1)
c1 = mt.createCircle(pos=(12.0, -18.0), radius=4, segments=25, marker=2)
"""
import numpy as np
import pygimli as pg
import pygimli.meshtools as mt
import matplotlib.pyplot as plt
import pybert as pb
#creación grid para comparación
grid = pg.createGrid(x=pg.utils.grange(start=0, end=71, n=500),
y=-pg.utils.grange(0, 15, n=250, log=False))
grid2= pg.createGrid(x=pg.utils.grange(start=23.5, end=27.5, n=500),
y=-pg.utils.grange(5.5, 9.5
, n=250, log=False))
square=mt.createRectangle(start=[23.5,-5.5],end=[27.5,-9.5])
#parametros inversion
quality=34.5
maxCellArea=1
robustData=True
paraDX=0.25
lam=20
#PARAMETROS MODELADO
noise=0
rhomap= [[0,100],[1,100],[2,200],[3,1000]]
#CREACION MODELO GENERAL
CorERTBack == 1) + 'ERTscheme' + str(ertSchemeFull == 1)
path_Figures = PathSimu_salt + '/Sens/' + SimName + '/Figures/'
if not os.path.exists(path_Figures):
os.makedirs(path_Figures)
path_Data = PathSimu_salt + '/Sens/' + SimName + '/Data/'
if not os.path.exists(path_Data):
os.makedirs(path_Data)
# Create geometry definition for the modelling domain
world = mt.createWorld(start=[-20, 0], end=[20, -16], worldMarker=False)
# Create a heterogeneous block
block = mt.createRectangle(start=[-5, -2.5],
end=[5, -5.0],
marker=4,
boundaryMarker=10,
area=0.1)
# block = mt.createRectangle(start=[-5, -5], end=[5, -7.5],
# marker=4, boundaryMarker=10, area=0.1)
# Merge geometrical entities
# geom = mt.mergePLC([world, block])
geom = mt.mergePLC([world, block])
pg.show(geom, boundaryMarker=True, savefig='geometry.pdf')
# Create a mesh from the geometry definition
mesh = mt.createMesh(geom, quality=32, area=0.2, smooth=[1, 10])
# pg.show(mesh, savefig='mesh.pdf')
rMap = [[1, SoilR], [4, AnoR]]
paraDepth=depth,
paraDX=0.3,
boundary=0,
paraBoundary=2)
if case == 1:
for depth in (5, 15):
start = plc.createNode(mesh.xmin(), -depth, 0.0)
end = plc.createNode(mesh.xmax(), -depth, 0.0)
plc.createEdge(start, end, marker=1)
for sensor in ertData.sensorPositions():
plc.createNode([sensor.x(), sensor.y() - 0.1])
rect = mt.createRectangle([mesh.xmin(), mesh.ymin()],
[mesh.xmax(), mesh.ymax()],
boundaryMarker=0)
geom = mt.mergePLC([plc, rect])
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)
#plt.xkcd()
import pygimli as pg
import pygimli.meshtools as mt
# Create geometry definition for the modeling domain
world = mt.createWorld(start=[-10, 0],
end=[10, -16],
layers=[-8],
worldMarker=False)
# Create a heterogeneous block
block = mt.createRectangle(start=[-6, -3.5],
end=[6, -6.0],
marker=4,
boundaryMarker=10,
area=0.1)
circ = mt.createCircle(pos=[0, -11], radius=2, boundaryMarker=11, isHole=True)
# Merge geometrical entities
geom = mt.mergePLC([world, block, circ])
mesh = mt.createMesh(geom)
fig, axs = plt.subplots(3, 5)
pg.show(geom, ax=axs[0][0])
axs[0][0].set_title('plc, (default)')
pg.show(geom, fillRegion=False, ax=axs[0][1])
axs[0][1].set_title('plc, fillRegion=False')
shots_id.append(len(sensors_all_xpos) - 1)
print(sens_id)
print(shots_id)
sensors = np.zeros((len(sensors_all_xpos), 2)) # two boreholes
sensors[:, 0] = np.hstack([sensors_all_xpos]) # x
sensors[:, 1] = 0 # y
print()
print("sensors")
print(sensors)
########
# Create forward model and mesh
world = mt.createRectangle(start=[0, 0],
end=[ttm_length, -world_width],
marker=0)
# c0 = mt.createCircle(pos=(ttm_start + 60.0, -7), radius=7, segments=25, marker=1)
c0 = mt.createRectangle(start=[0, -2], end=[ttm_length, -4], marker=1)
# c1 = mt.createCircle(pos=(ttm_start + 120.0, -10.0), radius=10, segments=25, marker=2)
c1 = mt.createRectangle(start=[0, -4],
end=[ttm_length, -world_width],
marker=2)
geom = mt.mergePLC([world, c0, c1])
for sen in sensors:
geom.createNode(sen)
mesh_fwd = mt.createMesh(geom, quality=34, area=1.0)
model = np.array([1000., 2000., 5000.])[mesh_fwd.cellMarkers()]
print("model")
#inversion parameters
quality = 34.5
maxCellArea = 1
robustData = True
lam = 20
paraDX = 0.25
#creación grid para comparación
grid = pg.createGrid(x=pg.utils.grange(start=0.20, end=0.5, n=500),
y=-pg.utils.grange(0, 0.12, n=250, log=False))
grid2 = pg.createGrid(x=pg.utils.grange(start=0.33, end=0.35, n=500),
y=-pg.utils.grange(0.04, 0.06, n=250, log=False))
square = mt.createRectangle(start=[0.33, -0.04], end=[0.35, -0.06])
#MODELO
rhomap = [[1, 150], [0, 3000]]
background = mt.createWorld(start=[-1, 0], end=[1, -1], area=1, marker=1)
circle = mt.createCircle(pos=[0.34, -0.05], radius=0.01, marker=0)
world = mt.mergePLC([background, circle])
mesh = mt.createMesh(world, quality=33, area=0.1, smooth=[1, 2])
res_model = pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh)
#INTERPOLACIÓN MODELO A GRID
nan = 99.9
model_vector_nn = []
plc = mt.mergePLC([polygon1, polygon2])
ax, cb = pg.show(plc, markers=True)
fig = ax.get_figure()
for nr, marker in enumerate(plc.regionMarker()):
print('Position marker number {}:'.format(nr + 1), marker.x(), marker.y(),
marker.z())
ax.scatter(marker.x(), marker.y(), s=(4 - nr) * 20, color='k')
ax.set_title('marker positions - working example')
fig.show()
###############################################################################
# And finally, a similar example for rectangles...
rect1 = mt.createRectangle(
start=[0.0, 0.0],
end=[2.0, -1.0],
isClosed=True,
marker=1,
)
# move the rectangle by changing the center position
rect2 = mt.createRectangle(
start=[0.0, 0.0],
end=[1.0, -0.5],
isClosed=True,
marker=2,
)
plc = mt.mergePLC([rect1, rect2])
ax, cb = pg.show(plc, markers=True)
