def createSynthModel(): """Return the modeling mesh, the porosity distribution and the parametric mesh for inversion. """ # Create the synthetic model world = mt.createCircle(boundaryMarker=-1, segments=64) tri = mt.createPolygon([[-0.8, -0], [-0.5, -0.7], [0.7, 0.5]], isClosed=True, area=0.0015) c1 = mt.createCircle(radius=0.2, pos=[-0.2, 0.5], segments=32, area=0.0025, marker=3) c2 = mt.createCircle(radius=0.2, pos=[0.32, -0.3], segments=32, area=0.0025, marker=3) poly = mt.mergePLC([world, tri, c1, c2]) poly.addRegionMarker([0.0, 0, 0], 1, area=0.0015) poly.addRegionMarker([-0.9, 0, 0], 2, area=0.0015) c = mt.createCircle(radius=0.99, segments=16, start=np.pi, end=np.pi*3) [poly.createNode(p.pos(), -99) for p in c.nodes()] mesh = pg.meshtools.createMesh(poly, q=34.4, smooth=[1, 10]) mesh.scale(1.0/5.0) mesh.rotate([0., 0., 3.1415/3]) mesh.rotate([0., 0., 3.1415]) petro = pg.solver.parseArgToArray([[1, 0.9], [2, 0.6], [3, 0.3]], mesh.cellCount(), mesh) # Create the parametric mesh that only reflects the domain geometry world = mt.createCircle(boundaryMarker=-1, segments=32, area=0.0051) paraMesh = pg.meshtools.createMesh(world, q=34.0, smooth=[1, 10]) paraMesh.scale(1.0/5.0) return mesh, paraMesh, petro
def createSynthModel(): """Return the modelling mesh, the porosity distribution and the parametric mesh for inversion. """ # Create the synthetic model world = mt.createCircle(boundaryMarker=-1, nSegments=64) tri = mt.createPolygon([[-0.8, -0], [-0.5, -0.7], [0.7, 0.5]], isClosed=True, area=0.0015) c1 = mt.createCircle(radius=0.2, pos=[-0.2, 0.5], nSegments=32, area=0.0025, marker=3) c2 = mt.createCircle(radius=0.2, pos=[0.32, -0.3], nSegments=32, area=0.0025, marker=3) poly = mt.mergePLC([world, tri, c1, c2]) poly.addRegionMarker([0.0, 0, 0], 1, area=0.0015) poly.addRegionMarker([-0.9, 0, 0], 2, area=0.0015) c = mt.createCircle(radius=0.99, nSegments=16, start=np.pi, end=np.pi*3) [poly.createNode(p.pos(), -99) for p in c.nodes()] mesh = pg.meshtools.createMesh(poly, q=34.4, smooth=[1, 10]) mesh.scale(1.0/5.0) mesh.rotate([0., 0., 3.1415/3]) mesh.rotate([0., 0., 3.1415]) petro = pg.solver.parseArgToArray([[1, 0.9], [2, 0.6], [3, 0.3]], mesh.cellCount(), mesh) # Create the parametric mesh that only reflect the domain geometry world = mt.createCircle(boundaryMarker=-1, nSegments=32, area=0.0051) paraMesh = pg.meshtools.createMesh(world, q=34.0, smooth=[1, 10]) paraMesh.scale(1.0/5.0) return mesh, paraMesh, petro
def test_default_create_different_center(self): polygon = mt.createPolygon( [[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]], isClosed=True, marker=2, ) assert abs(polygon.regionMarkers()[0].dist(polygon.node(0).pos()) - 0.001) < 1e-8 assert polygon.regionMarkers()[0].marker() == 2
def test_default_create_different_center(self): polygon = mt.createPolygon( [[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]], isClosed=True, marker=2, ) assert polygon.regionMarker()[0].x() == 0.5 assert polygon.regionMarker()[0].y() == -0.5 assert polygon.regionMarker()[0].marker() == 2
def test_default_create(self): polygon = mt.createPolygon( [[-1.0, -1.0], [-1.0, 1.0], [1.0, 1.0], [1.0, -1]], isClosed=True, marker=1, ) assert polygon.regionMarker()[0].x() == 0 assert polygon.regionMarker()[0].y() == 0 assert polygon.regionMarker()[0].marker() == 1
def prepareMesh(self): geom = mt.createPolygon(self.meshPolygonVertexes, isClosed=True, marker=0) self.mesh = mt.createMesh(geom, quality=34.0, area=0.2, smooth=(1, 10)) self.startModel = np.array([1. / 2000.])[self.mesh.cellMarkers()] print(self.mesh.cellMarkers()) print("setting of mesh") self.travelTime.setMesh(self.mesh) pass
def test_create_with_custom_markerPosition(self): polygon = mt.createPolygon( [[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]], isClosed=True, marker=7, markerPosition=[0.1, -0.1], ) assert polygon.regionMarkers()[0].x() == 0.1 assert polygon.regionMarkers()[0].y() == -0.1 assert polygon.regionMarkers()[0].marker() == 7
def test_create_with_custom_markerPosition(self): polygon = mt.createPolygon( [[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]], isClosed=True, marker=7, markerPosition=[0.1, -0.1], ) assert polygon.regionMarker()[0].x() == 0.1 assert polygon.regionMarker()[0].y() == -0.1 assert polygon.regionMarker()[0].marker() == 7
def createTopo(efile, xextra, dep): eloc = pd.read_csv(efile, sep='\t', header=None) nelec = eloc.values.shape[0] topo = eloc.values[:, (1, 3)] e_bot = np.floor(np.min(topo[:, 1])) xL = np.floor(np.min(topo[:, 0])) xR = np.ceil(np.max(topo[:, 0])) L_ext = np.array([[xL - xextra, topo[0, 1]]]) R_ext = np.array([[xR + xextra, topo[nelec - 1, 1]]]) bots = np.array([[R_ext[0, 0], e_bot - dep], [L_ext[0, 0], e_bot - dep]]) combo = np.concatenate((topo, R_ext, bots, L_ext)) tpoly = mt.createPolygon(combo, isClosed=True, marker=2) return topo, tpoly
def createFault(topo, xpos, dip, H, dep, xtra=500): topo2 = np.concatenate( (np.array([[topo[0, 0] - xtra, topo[0, 1]]]), topo, np.array( [[topo[topo.shape[0] - 1, 0] + xtra, topo[topo.shape[0] - 1, 1]]]))) e_bot = np.floor(np.min(topo2[:, 1])) zbot = np.floor(np.min(topo2[:, 1])) - dep Z = interpolate.interp1d(topo2[:, 0], topo2[:, 1]) zx = Z(xpos) Dz = zx - zbot Dx = Dz / np.tan(np.deg2rad(dip)) xbot = xpos + Dx Dxbot = H / 2 / np.sin(np.deg2rad(dip)) LR = (xbot + Dxbot, zbot) LL = (xbot - Dxbot, zbot) zfR = zbot + (LR[0] - topo2[:, 0]) * np.tan(np.deg2rad(dip)) diffR = interpolate.interp1d(zfR - topo2[:, 1], topo2[:, 0]) UR = (float(diffR(0)), float(Z(diffR(0)))) zfL = zbot + (LL[0] - topo2[:, 0]) * np.tan(np.deg2rad(dip)) diffL = interpolate.interp1d(zfL - topo2[:, 1], topo2[:, 0]) UL = (float(diffL(0)), float(Z(diffL(0)))) idxabove = (topo2[topo2[:, 0] > UL[0], 0]).argmin() + (topo2[topo2[:, 0] < UL[0], 0]).shape[0] idxbelow = (topo2[topo2[:, 0] < UR[0], 0]).argmax() middles = [(topo[j, 0], topo[j, 1]) for j in range(idxabove, idxbelow)] verts = [LL, UL] + middles + [UR, LR] fpoly = mt.createPolygon(verts, isClosed=True, addNodes=3, marker=1) return fpoly
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 background=mt.createWorld(start=[-10,0],end=[81,-20], area=1,marker=0) pol0=mt.createPolygon([[-10,-2.5],[81,-2.5],[81,0],[-10,0]], isClosed=True,marker=1) pol1=mt.createPolygon([[-10,-15],[81,-15],[81,-2.5],[-10,-2.5]], isClosed=True,marker=2) circle1=mt.createCircle(pos=[25.5,-7.5],radius=2,isClosed=True, marker=3) circle2=mt.createCircle(pos=[45.5,-7.5],radius=2,isClosed=True, marker=3) circle3=mt.createCircle(pos=[35.5,-7.5],radius=2,isClosed=True,area=1, marker=3) world = mt.mergePLC([background,circle1,circle2,pol0,pol1]) mesh= mt.createMesh(world, quality=33, area=0.1,smooth=[1,2]) #EXPORTACION DATOS DE RESISTIVIDAD DEL MODELO (VECTOR) res_model=pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh) pg.show(mesh,res_model) #INTERPOLACION DATOS MODELO A MESH 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 background = mt.createWorld(start=[-10, 0], end=[81, -20], area=1, marker=0) pol0 = mt.createPolygon([[-10, -2.5], [27.5, -2.5], [30, 0], [-10, 0]], isClosed=True, marker=1) pol1 = mt.createPolygon([[-10, -20], [10, -20], [27.5, -2.5], [-10, -2.5]], isClosed=True, marker=2) pol2 = mt.createPolygon([[60, 0], [65, 0], [45, -20], [40, -20]], isClosed=True, marker=3) world = mt.mergePLC([background, pol0, pol1, pol2]) mesh = mt.createMesh(world, quality=33, area=0.1, smooth=[1, 2]) #EXPORTACION DATOS DE RESISTIVIDAD DEL MODELO (VECTOR) res_model = pg.solver.parseArgToArray(rhomap, mesh.cellCount(), mesh)
end=[50, -50], layers=[-1, -5], worldMarker=True) ############################################################################### # Create some heterogeneous circular anomaly block = mt.createCircle(pos=[-5, -3.], radius=[4, 1], marker=4, boundaryMarker=10, area=0.1) ############################################################################### poly = mt.createPolygon([(1, -4), (2, -1.5), (4, -2), (5, -2), (8, -3), (5, -3.5), (3, -4.5)], isClosed=True, addNodes=3, interpolate='spline', marker=5) ############################################################################### # Merge geometry definition into a Piecewise Linear Complex (PLC) geom = world + block + poly ############################################################################### # Optional: show the geometry pg.show(geom) ############################################################################### # Create a Dipole Dipole ('dd') measuring scheme with 21 electrodes. scheme = ert.createERTData(elecs=np.linspace(start=-15, stop=15, num=21), schemeName='dd')
lam = 50 paraDX = 0.25 #creación grid para comparación grid = pg.createGrid(x=pg.utils.grange(start=30, end=40, n=500), y=-pg.utils.grange(0, 4, n=250, log=False)) grid2 = pg.createGrid(x=pg.utils.grange(start=34, end=36, n=500), y=-pg.utils.grange(0.5, 2.5, n=250, log=False)) #MODELO rhomap = [[1, 50], [0, 200], [3, 700], [2, 75], [4, 100]] background = mt.createWorld(start=[-10, 0], end=[81, -21], area=1, marker=1) sup = mt.createPolygon([[-10, 0], [30, 0], [31.2, -1.5], [-10, -1.5]], 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])
def generate_dipped_layered_world(world_dim: list, layer_borders: list, dipping_angle: float): """ Creates a dipped layered world. Utility function to create a dipped layered world. Region markers are increasing with depth. Parameter: world_dim: World dimensions as [x,z]. layer_borders: List of layer borders at world X = 0. dipping_angle: Angle at which the layers are dipping. Value describing counter-clockwise angle. Returns: The created world. """ # Nested function to find the index to add a specific node def get_insert_index(nodes, node): i = 0 # Get edge starting index while (i < len(nodes)) and (nodes[i][3] < node[3]): i = i + 1 edge_start = i # Get edge ending index while (i < len(nodes)) and (nodes[i][3] <= node[3]): i = i + 1 edge_end = i # Check for input error if (node[3] == 0) or (node[3] == 2) or (node[3] == 4) or (node[3] == 6): print('Function can only be used for non-default edges (1,3,5,7)') return -1 # Find index based on specific edge i = edge_start if node[3] == 1: while (i < edge_end) and (node[1] > nodes[i][1]): i = i + 1 if node[3] == 3: while (i < edge_end) and (node[2] < nodes[i][2]): i = i + 1 if node[3] == 5: while (i < edge_end) and (node[1] < nodes[i][1]): i = i + 1 if node[3] == 7: while (i < edge_end) and (node[2] > nodes[i][2]): i = i + 1 return i # Nested function to find the connecting node of a given node def get_connecting_node(nodes_list, node, node_connections_list): for i in range(len(node_connections_list)): if node_connections_list[i][0] == nodes_list[node][0]: for j in range(len(nodes_list)): if node_connections_list[i][1] == nodes_list[j][0]: return j return -1 # Nested function to find the next node on the world border def get_next_node(nodes_list, current_node): if current_node >= len(nodes_list) - 1: return 0 else: return current_node + 1 # Nested function to create a polygon from a set of nodes def get_polygon_from_nodes(node_set): vertices = [] for i in range(len(node_set)): vertices.append([node_set[i][1], node_set[i][2]]) return vertices # Correct angle while dipping_angle > 180: dipping_angle -= 360 while dipping_angle < -180: dipping_angle += 360 # Create background world world = mt.createWorld(start=[0, 0], end=[world_dim[0], -world_dim[1]], worldMarker=True) # Remove layers out of world scope removed_indices = 0 for i in range(len(layer_borders)): if (dipping_angle >= 0 and layer_borders[i - removed_indices] > 0) or ( dipping_angle <= 0 and layer_borders[i - removed_indices] < -world_dim[1]): layer_borders.pop(i - removed_indices) removed_indices = removed_indices + 1 # Compute layer height difference based on dipping angle dipping_diff = world_dim[0] * math.tan(dipping_angle / 180 * math.pi) # Compute nodes on world border (id,x,y,edge) nodes = [[0, 0, 0, 0], [1, world_dim[0], 0, 2], [2, world_dim[0], -world_dim[1], 4], [3, 0, -world_dim[1], 6]] node_connections = [] next_id = 4 for i in range(len(layer_borders)): # Find starting node if layer_borders[i] <= 0 and layer_borders[i] >= -world_dim[1]: # Layer starts at left world border (default case) start_node = [next_id, 0, layer_borders[i], 7] else: if layer_borders[i] > 0: # Layer starts above world x = layer_borders[i] * math.tan( (90 + dipping_angle) * math.pi / 180) start_node = [next_id, x, 0, 1] else: # Layer starts below world x = -(layer_borders[i] + world_dim[1]) * math.tan( (90 - dipping_angle) * math.pi / 180) start_node = [next_id, x, -world_dim[1], 5] nodes.insert(get_insert_index(nodes, start_node), start_node) next_id = next_id + 1 # Find ending node if layer_borders[i] + dipping_diff <= 0 and layer_borders[ i] + dipping_diff >= -world_dim[1]: # Layer ends at right world border (default case) end_node = [ next_id, world_dim[0], layer_borders[i] + dipping_diff, 3 ] else: if layer_borders[i] + dipping_diff > 0: # Layer ends above world x = -layer_borders[i] / math.tan(dipping_angle / 180 * math.pi) end_node = [next_id, x, 0, 1] else: # Layer ends below world x = world_dim[0] - (layer_borders[i] + dipping_diff + world_dim[1]) / math.tan( dipping_angle / 180 * math.pi) end_node = [next_id, x, -world_dim[1], 5] nodes.insert(get_insert_index(nodes, end_node), end_node) next_id = next_id + 1 # Save node connections node_connections.append([start_node[0], end_node[0]]) node_connections.append([end_node[0], start_node[0]]) # Compute polygons from nodes polygons = [] first_node = 0 edge_to_finish = 4 if dipping_angle < 0: for i in range(len(nodes)): if nodes[i][3] == 2: break first_node = i edge_to_finish = 6 while edge_to_finish != -1: polygon = [] last_node_was_connected = False has_connected_nodes = False current_node_index = first_node polygon.append(nodes[first_node]) while (len(polygon) == 1) or (polygon[len(polygon) - 1] != polygon[0]): if (last_node_was_connected == False) and (len(polygon) != 1) and (get_connecting_node( nodes, current_node_index, node_connections) != -1): current_node_index = get_connecting_node( nodes, current_node_index, node_connections) polygon.append(nodes[current_node_index]) last_node_was_connected = True has_connected_nodes = True if nodes[current_node_index][3] == edge_to_finish: edge_to_finish = -1 continue current_node_index = get_next_node(nodes, current_node_index) polygon.append(nodes[current_node_index]) if not has_connected_nodes: first_node = current_node_index last_node_was_connected = False if nodes[current_node_index][3] == edge_to_finish: edge_to_finish = -1 polygons.append(polygon[:-1]) # Merge geometries for i in range(len(polygons)): poly = mt.createPolygon(get_polygon_from_nodes(polygons[i]), marker=i + 1, isClosed=True) world = mt.mergePLC([world, poly]) return world
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=(2 - nr) * 30, color='k') ax.set_title('marker positions - working example') fig.show() ############################################################################### # The same issue can occur for polygons. Polygons can assume complex forms, but # for simplicity we create cubes here. polygon1 = mt.createPolygon( [[0.0, 0.0], [1.0, 0.0], [1.0, -1.0], [0.0, -1]], isClosed=True, marker=1, ) polygon2 = mt.createPolygon( [[0.25, -0.25], [0.75, -0.25], [0.75, -0.75], [0.25, -0.75]], isClosed=True, marker=2, ) plc = mt.mergePLC([polygon1, polygon2]) ax, cb = pg.show(plc, markers=True) fig = ax.get_figure() for nr, marker in enumerate(plc.regionMarker()):
Refraction Manager ------------------ This example shows how to use the Refraction manager to generate the response of a three-layered sloping model and to invert the synthetic noisified data.""" import numpy as np import pygimli as pg import pygimli.meshtools as mt from pygimli.physics import Refraction ############################################################################### # We start by creating a three-layered slope (The model is taken from the BSc # thesis of Constanze Reinken (University of Bonn). layer1 = mt.createPolygon([[0.0, 137], [117.5, 164], [117.5, 162], [0.0, 135]], isClosed=True, marker=1, area=1) layer2 = mt.createPolygon([[0.0, 126], [0.0, 135], [117.5, 162], [117.5, 153]], isClosed=True, marker=2) layer3 = mt.createPolygon([[0.0, 110], [0.0, 126], [117.5, 153], [117.5, 110]], isClosed=True, marker=3) slope = (164 - 137) / 117.5 geom = mt.mergePLC([layer1, layer2, layer3]) mesh = mt.createMesh(geom, quality=34.3, area=3, smooth=[1, 10]) pg.show(mesh) ############################################################################### # Next we define geophone positions and a measurement scheme, which consists of # shot and receiver indices.
end=[50, -50], layers=[-1, -5], worldMarker=True) ############################################################################### # Create some heterogeneous circular anomaly block = mt.createCircle(pos=[-5, -3.], radius=[4, 1], marker=4, boundaryMarker=10, area=0.1) ############################################################################### poly = mt.createPolygon([(1, -4), (2, -1.5), (4, -2), (5, -2), (8, -3), (5, -3.5), (3, -4.5)], isClosed=True, addNodes=5, marker=5) ############################################################################### # Merge geometry definition into a Piecewise Linear Complex (PLC) geom = world + block + poly ############################################################################### # Optional: show the geometry pg.show(geom) ############################################################################### # Create a Dipole Dipole ('dd') measuring scheme with 21 electrodes. scheme = ert.createERTData(elecs=np.linspace(start=-15, stop=15, num=21), schemeName='dd')
------------------ This example shows how to use the Refraction manager to generate the response of a three-layered sloping model and to invert the synthetic noisified data.""" import numpy as np import pygimli as pg import pygimli.meshtools as mt from pygimli.physics import Refraction ############################################################################### # We start by creating a three-layered slope (The model is taken from the BSc # thesis of Constanze Reinken (University of Bonn). layer1 = mt.createPolygon([[0.0, 137], [117.5, 164], [117.5, 162], [0.0, 135]], isClosed=True, marker=1, area=1) layer2 = mt.createPolygon([[0.0, 126], [0.0, 135], [117.5, 162], [117.5, 153]], isClosed=True, marker=2) layer3 = mt.createPolygon([[0.0, 110], [0.0, 126], [117.5, 153], [117.5, 110]], isClosed=True, marker=3) slope = (164 - 137) / 117.5 geom = mt.mergePLC([layer1, layer2, layer3]) mesh = mt.createMesh(geom, quality=34.3, area=3, smooth=[1, 10]) pg.show(mesh) ###############################################################################