def test_pile_geomodel_2(): ve = 3 extent = [451e3, 456e3, 6.7820e6, 6.7840e6, -2309 * ve, -1651 * ve] geo_model = gp.create_model('Topology-Gullfaks') gp.init_data(geo_model, extent, [30, 30, 30], path_o=input_path + "/filtered_orientations.csv", path_i=input_path + "/filtered_surface_points.csv", default_values=True) series_distribution = { "fault3": "fault3", "fault4": "fault4", "unconformity": "BCU", "sediments": ("tarbert", "ness", "etive"), } gp.map_series_to_surfaces(geo_model, series_distribution, remove_unused_series=True) geo_model.reorder_series( ["unconformity", "fault3", "fault4", "sediments", "Basement"]) geo_model.set_is_fault(["fault3"]) geo_model.set_is_fault(["fault4"]) rel_matrix = np.array([[0, 0, 0, 0, 0], [0, 0, 0, 1, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) geo_model.set_fault_relation(rel_matrix) surf_groups = pd.read_csv(input_path + "/filtered_surface_points.csv").group geo_model.surface_points.df["group"] = surf_groups orient_groups = pd.read_csv(input_path + "/filtered_orientations.csv").group geo_model.orientations.df["group"] = orient_groups geo_model.surface_points.df.reset_index(inplace=True, drop=True) geo_model.orientations.df.reset_index(inplace=True, drop=True) gp.set_interpolator(geo_model, verbose=['mask_matrix_loop', 'mask_e', 'nsle']) gp.compute_model(geo_model) gp.plot.plot_section(geo_model, cell_number=25, direction='y', show_data=True) from gempy.plot.plot_api import plot_2d p = plot_2d(geo_model, cell_number=[25]) plt.savefig(os.path.dirname(__file__) + '/../figs/test_pile_lith_block') return geo_model
def interpolator_islith_isfault(): geo_model = gp.create_model('interpolator_islith_isfault') # Importing the data from CSV-files and setting extent and resolution gp.init_data(geo_model, path_o=input_path + "/simple_fault_model_orientations.csv", path_i=input_path + "/simple_fault_model_points.csv", default_values=True) gp.map_series_to_surfaces(geo_model, { "Fault_Series": 'Main_Fault', "Strat_Series": ('Sandstone_2', 'Siltstone', 'Shale', 'Sandstone_1', 'basement') }, remove_unused_series=True) geo_model.set_is_fault(['Fault_Series']) gp.set_interpolation_data(geo_model, compile_theano=True, theano_optimizer='fast_compile', verbose=[]) return geo_model.interpolator
def map_sequential_pile(load_model): geo_model = load_model # TODO decide what I do with the layer order gp.map_series_to_surfaces(geo_model, {"Fault_Series": 'Main_Fault', "Strat_Series": ('Sandstone_2', 'Siltstone', 'Shale', 'Sandstone_1', 'basement')}, remove_unused_series=True) geo_model.set_is_fault(['Fault_Series']) return geo_model
def test_add_point(): extend = [0.0, 1.0, 0.0, 1.0, 0.0, 1.1] discretization = [5, 20, 20] x, y, z, f = 0.0, 0.0, 0.5, 'surface2' # %% geo_model = gp.create_model('test') gp.init_data(geo_model, extend, discretization) geo_model.set_default_surfaces() geo_model.set_default_orientation() strats = ['surface1', 'surface2', 'basement'] gp.map_series_to_surfaces(geo_model, {'Strat_Series': strats}) geo_model.add_surface_points(x, y, z, f) geo_model.add_orientations(x, y, z, f, pole_vector=(1, 0, 0))
def geo_model(): geo_model = gp.create_model('Test_uncomformities') # Importing the data from CSV-files and setting extent and resolution gp.init_data( geo_model, [0, 10., 0, 2., 0, 5.], [100, 3, 100], path_o=input_path + '/05_toy_fold_unconformity_orientations.csv', path_i=input_path + '/05_toy_fold_unconformity_interfaces.csv', default_values=True) gp.map_series_to_surfaces( geo_model, { "Flat_Series": 'Flat', "Inclined_Series": 'Inclined', "Fold_Series": ('Basefold', 'Topfold', 'basement') }) # Create the theano model gp.set_interpolator(geo_model, theano_optimizer='fast_compile') return geo_model
def topology_jan_unconf(): geo_model = gp.create_data( [0, 1000, 0, 1000, 0, 1000], resolution=[50, 50, 50], path_o=data_path / "jan_models/model6_orientations.csv", path_i=data_path / "jan_models/model6_surface_points.csv") gp.map_series_to_surfaces( geo_model, { "Strat_Series1": ('rock3'), "Strat_Series2": ('rock2', 'rock1'), "Basement_Series": ('basement') }) # with open("input_data/geomodel_jan_sol.p", "rb") as f: # geo_model.solutions = load(f) gp.set_interpolator(geo_model) gp.compute_model(geo_model) edges, centroids = tp.compute_topology(geo_model, voxel_threshold=1) return edges, centroids
data_path= '../..' # Importing the data from CSV-files and setting extent and resolution gp.init_data( geo_model, [0, 2000., 0, 2000., 0, 2000.], [50, 50, 50], path_o = data_path+"/data/input_data/tut_chapter1/simple_fault_model_orientations.csv", path_i = data_path+"/data/input_data/tut_chapter1/simple_fault_model_points.csv", default_values=True ) geo_model.surfaces # gp.get_data(geo_model, 'surface_points').head() # gp.get_data(geo_model, 'orientations').head() gp.map_series_to_surfaces( geo_model, { "Fault_Series":'Main_Fault', "Strat_Series": ('Sandstone_2','Siltstone', 'Shale', 'Sandstone_1', 'basement') }, remove_unused_series=True) # geo_model.series geo_model.set_is_fault(['Fault_Series']) geo_model.faults.faults_relations_df # gp.plot.plot_data(geo_model, direction='y') # gp.plot.plot_3D(geo_model) gp.set_interpolation_data(geo_model, compile_theano=True, theano_optimizer='fast_compile', verbose=[])
def create_example(name_model, interpolator=None, save_pickle=False, plot_section=True): """ Create an inter_data from one of the examples data_set Attr: name_model (str): name of the model that you want to generate. It has to be in ['Model 1' ,'Model 2', 'Model 3', 'Model 4','Model 5' 'Model 6','Model 7', 'Model 8', 'Model 9'] save_pickle (bool, str): Save to a pickle the interp_data object. You can pass the path as a string otherwse the default name will be given plot_section (bool) """ name_list = np.array([ 'Model 1', 'Model 2', 'Model 3', 'Model 4', 'Model 5', 'Model 6', 'Model 7', 'Model 8', 'Model 9' ]) assert name_model in name_list, 'Name model must be in the following list: ' + str( name_list) # Extract number of the model n_model = name_model[-1] # Load right gempy geodata geo_data = gp.create_data( name_model, extent=[0, 2000, 0, 2000, 0, 1600], resolution=[50, 50, 50], path_o=data_path + "/data/input_data/lisa_models/foliations" + n_model + ".csv", path_i=data_path + "/data/input_data/lisa_models/interfaces" + n_model + ".csv") # Set the right sequential pile subset_list_1 = np.array(['Model 1']) subset_list_2 = np.array(['Model 5', 'Model 8']) subset_list_3 = np.array(['Model 2', 'Model 3', 'Model 9', 'Model 6']) subset_list_4 = np.array(['Model 7']) ### Model 1 - Discordant layering ### if name_model in subset_list_1: gp.map_series_to_surfaces( geo_data, { "Strat_Series_1": ('Sandstone', 'Siltstone', 'Shale'), "Strat_Series_2": ('Sandstone2', 'Siltstone2', 'Shale2') }, ) ### Model 5 - One normal Fault ### ### Model 8 - ### elif name_model in subset_list_2: gp.map_series_to_surfaces( geo_data, { "Fault_Series": 'Main_Fault', "Strat_Series": ('Sandstone', 'Siltstone', 'Shale', 'Sandstone_2', 'Schist', 'Gneiss') }, ) geo_data.set_is_fault(['Fault_Series']) elif name_model in subset_list_3: ### Model 2 - Aufwölbung (durch Salzstock?) ### ### Model 3+9 - Parallele NNE Schichtung ohne Verwerfung ### ### Model 6 - Mulde ### gp.map_series_to_surfaces( geo_data, { "Strat_Series": ('Sandstone', 'Siltstone', 'Shale', 'Sandstone_2', 'Schist', 'Gneiss') }, ) elif name_model in subset_list_4: ### Model 7 - Graben ### gp.map_series_to_surfaces( geo_data, { "Fault_1": 'Fault_1', "Fault_2": 'Fault_2', "Strat_Series": ('Sandstone', 'Siltstone', 'Shale', 'Sandstone_2', 'Schist', 'Gneiss') }, ) geo_data.set_is_fault(['Fault_1', 'Fault_2']) else: print('You would never reach this point. Look for the bug') # Interpolation and Computation if interpolator is None: interp_data = gp.set_interpolator(geo_data, theano_optimizer='fast_run') else: interp_data = interpolator geo_data.set_theano_function(interpolator) sol = gp.compute_model(geo_data) if plot_section is True: # 2D Plot gp.plot_2d(geo_data, cell_number=25, direction='y', show_data=True) gp.plot_3d(geo_data) if save_pickle is not False: if type(save_pickle) is str: gp.save_model_to_pickle(geo_data, save_pickle) else: gp.save_model_to_pickle(geo_data, 'lisa-' + str(n_model)) return interp_data
def loop2gempy(test_data_name: str, tmp_path: str, vtk_path: str, orientations_file: str, contacts_file: str, groups_file:str, bbox: tuple, model_base: float, model_top: float, vtk: bool, dtm_reproj_file:str = None, va=None, verbose: bool = False, compute: bool = True): """ :param test_data_name: :param tmp_path: :param vtk_path: :param orientations_file: :param contacts_file: :param groups_file: :param bbox: :param model_base: :param model_top: :param vtk: :param dtm_reproj_file: :param va: vertical anisotropy. Factor by which all Z coordinates are multiplied by :param verbose: :param compute: :return: """ import gempy as gp from gempy import plot geo_model = gp.create_model(test_data_name) # If depth coordinates are much smaller than XY the whole system of equations becomes very unstable. Until # I fix it properly in gempy this is a handcrafted hack if va is None: va = (float(bbox[0]) - float(bbox[2])) / (model_base - model_top)/2 if va < 3: va = 0 else: print('The vertical exageration is: ', va) gp.init_data(geo_model, extent=[bbox[0], bbox[2], bbox[1], bbox[3], model_base * va, model_top * va], resolution=(50, 50, 50), path_o=orientations_file, path_i=contacts_file) geo_model.modify_surface_points(geo_model.surface_points.df.index, Z=geo_model.surface_points.df['Z'] * va) if dtm_reproj_file is not None: # Load reprojected topography to model fp = dtm_reproj_file geo_model.set_topography(source='gdal', filepath=fp) # Rescaling topography: geo_model.grid.topography.values[:, 2] *= va geo_model.grid.update_grid_values() geo_model.update_from_grid() # Pile processing: contents = np.genfromtxt(groups_file, delimiter=',', dtype='U100') # Init dictionary Series:Surfaces map_series_to_surfaces = {} choice = 0 for group in contents: # Reading surfaces groups surfaces_g = np.atleast_2d(np.genfromtxt(tmp_path + group + '.csv', delimiter=',', dtype='U100')) # Check if there are several choices if surfaces_g.shape[1] > 1: surfaces_g = surfaces_g[choice] # Deleting the first element since it is not a surface surfaces_g = surfaces_g[1:] # Creating the mapping dictionary map_series_to_surfaces[group] = surfaces_g.tolist() if verbose is True: print(map_series_to_surfaces) # Setting pile to model gp.map_series_to_surfaces(geo_model, map_series_to_surfaces, remove_unused_series=False) # Removing related data del_surfaces = geo_model.surfaces.df.groupby('series').get_group('Default series')['surface'] geo_model.delete_surfaces(del_surfaces, remove_data=True) # Removing series that have not been mapped to any surface geo_model.delete_series('Default series') if compute is True: gp.set_interpolator(geo_model, theano_optimizer='fast_run', dtype='float64') gp.compute_model(geo_model) # Visualise Model gp.plot.plot_3D(geo_model, render_data=False) # Save model as vtk if vtk: gp.plot.export_to_vtk(geo_model, path=vtk_path, name=test_data_name + '.vtk', voxels=False, block=None, surfaces=True) return geo_model
# %% # Initiate the stratigraphies and faults, and add resistivities to lithology # -------------------------------------------------------------------------- # # %% # Add an air-layer: Horizontal layer at z=0m geo_model.add_surfaces('air') geo_model.add_surface_points(0, 0, 0, 'air') geo_model.add_surface_points(0, 0, 0, 'air') geo_model.add_orientations(0, 0, 0, 'air', [0, 0, 1]) # Add a Series for the air layer; this series will not be cut by the fault geo_model.add_series('Air_Series') geo_model.modify_order_series(2, 'Air_Series') gempy.map_series_to_surfaces(geo_model, {'Air_Series': 'air'}) # Map the different series gempy.map_series_to_surfaces(geo_model, { "Fault_Series": 'fault', "Air_Series": ('air'), "Strat_Series": ('seawater', 'overburden', 'target', 'underburden', 'basement') }, remove_unused_series=True) # %% geo_model.rename_series({'Main_Fault': 'Fault_Series'}) # %%
# Assign formations to series gp.map_series_to_surfaces( geo_model, { "Thrust_Mandach": 'Mandach', "Thrust_Jura": 'Jurathrust5', #"Thrust_Jura6": 'Jurathrust6', #('Jurathrust4', 'Jurathrust5', 'Jurathrust6'), "Fault_north_series": 'Fault_Basement_A', "Fault_south_series": 'Fault-south', "Vorwald_series": 'Vorwald_Basement', "BIH_series": 'BIH-Basement-N', "Fault_north_series": 'Fault_Basement_A', "Fault_south_series": 'Fault-south', "Post_graben_series": ('OMM', 'USM', 'Malm', 'Effinger-Schichten', 'Dogger', 'Opalinuston', 'Keuper', 'Oberer-Muschelkalk'), "Detachement": 'Mittlerer-Muschelkalk', "Graben_series": 'graben-fill' }, remove_unused_series=True) geo_model.surfaces
#%% # Show data gp.get_data(geo_model, 'surface_points').head() gp.plot.plot_data(geo_model, direction='y') #%% # Assign formations to series gp.map_series_to_surfaces(geo_model, {"Fault7_series": 'Fault7', "Fault1_series": 'Fault1', "Fault6_series": 'Fault6', "Fault2_series": 'Fault2', "Fault5_series": 'Fault5', "Fault3_series": 'Fault3', "Fault4_series": 'Fault4', "Post_tectonic_series": ('Quaternary', 'Tertiary', 'Mesozoic'), "Syn_tectonic_series": 'Upper-filling', "Pre_tectonic_series": ('Lower-filling','Middle-filling')}, remove_unused_series=True) geo_model.surfaces geo_model.set_is_fault(['Fault7_series', 'Fault1_series', 'Fault6_series', 'Fault2_series', 'Fault5_series', 'Fault3_series', 'Fault4_series']) #geo_model.set_is_finite_fault(series_fault=['Fault6_series', 'Fault5_series', 'Fault3_series', 'Fault4_series'], # toggle=True) geo_model.faults.faults_relations_df
geo_model.surfaces.colors.change_colors(col_dict) geo_model.surfaces #%% # Model Characteristics # --------------------- # Main features of the model is the asymetric graben system, with the major fault (denoted with **A**), and the graben fill, which is not present beyond the graben shoulders. This, as well as the stop of major faults beneath the mesozoic units (blue units) are important considerations for the modelling process. # These could be caught, for instance, in likelihood functions if we model the PCT as a Bayesian inference problem. # Assign formations to series gp.map_series_to_surfaces(geo_model, {"Thrust1_series": 'Thrust1_south', "Thrust2_series": 'Thrust2_south', "Fault2_series": 'Fault2', "Fault5_series": 'Fault5', "Fault6_series": 'Fault6', "Post_tectonic_series": ('Tertiary', 'Pink', 'Orange'), "Detachement": 'Unconformity', "Syn_tectonic_series2": 'Upper-filling', #"Syn_tectonic_series1": 'Middle-filling', "Pre_tectonic_series": 'Lower-filling'}, remove_unused_series=True) geo_model.surfaces #%% # After assigning units to stacks or series, we have so define which of those series is a fault. Here, we see that it is usually important to assign each fault its own series, as faults may have very different # scalar fields (in which the fault surfaces are interpolated). geo_model.set_is_fault(['Thrust1_series', 'Thrust2_series', 'Fault2_series', 'Fault5_series', 'Fault6_series'], change_color=False)
def test_complete_model(tmpdir, interpolator): # ### Initializing the model: compute = True geo_model = gp.create_model('Geological_Model1') geo_model = gp.init_data(geo_model, extent=[0, 4000, 0, 2775, 200, 1200], resolution=[100, 10, 100]) if compute is True: geo_model.set_theano_function(interpolator) from gempy.plot import visualization_2d_pro as vv # In this case perpendicular to the z axes p2d = vv.Plot2D(geo_model) p2d.create_figure((15, 8)) ax = p2d.add_section(direction='z', ax_pos=121) ax2 = p2d.add_section(direction='y', ax_pos=122) ax2.set_xlim(geo_model.grid.regular_grid.extent[0], geo_model.grid.regular_grid.extent[1]) ax2.set_ylim(geo_model.grid.regular_grid.extent[4], geo_model.grid.regular_grid.extent[5]) geo_model.add_surfaces(['D', 'C', 'B', 'A']) # surface B geo_model.add_surface_points(X=584, Y=285, Z=500, surface='B') geo_model.add_surface_points(X=494, Y=696, Z=500, surface='B') geo_model.add_surface_points(X=197, Y=1898, Z=500, surface='B') geo_model.add_surface_points(X=473, Y=2180, Z=400, surface='B') geo_model.add_surface_points(X=435, Y=2453, Z=400, surface='B') # surface C geo_model.add_surface_points(X=946, Y=188, Z=600, surface='C') geo_model.add_surface_points(X=853, Y=661, Z=600, surface='C') geo_model.add_surface_points(X=570, Y=1845, Z=600, surface='C') geo_model.add_surface_points(X=832, Y=2132, Z=500, surface='C') geo_model.add_surface_points(X=767, Y=2495, Z=500, surface='C') # Surface D geo_model.add_surface_points(X=967, Y=1638, Z=800, surface='D') geo_model.add_surface_points(X=1095, Y=996, Z=800, surface='D') geo_model.add_orientations(X=832, Y=2132, Z=500, surface='C', orientation=[98, 17.88, 1]) p2d.plot_data(ax, direction='z') p2d.plot_data(ax2, direction='y') gp.compute_model(geo_model) if compute else None p2d.plot_contacts(ax, direction='z', cell_number=-10) p2d.plot_lith(ax, direction='z', cell_number=-10) p2d.plot_contacts(ax2, direction='y', cell_number=5) p2d.plot_lith(ax2, direction='y', cell_number=5) plt.savefig(os.path.dirname(__file__) + '/../figs/test_pile_complete') # ----------- # Adding a fault geo_model.rename_series(['Cycle1']) geo_model.add_series(['Fault1']) geo_model.set_is_fault(['Fault1']) geo_model.modify_order_series(1, 'Fault1') geo_model.add_surfaces(['F1']) gp.map_series_to_surfaces(geo_model, {'Fault1': 'F1'}) # Add input data of the fault geo_model.add_surface_points(X=1203, Y=138, Z=600, surface='F1') geo_model.add_surface_points(X=1250, Y=1653, Z=800, surface='F1') # Add orientation geo_model.add_orientations(X=1280, Y=2525, Z=500, surface='F1', orientation=[272, 90, -1]) gp.compute_model(geo_model) p2d.remove(ax) p2d.plot_data(ax, direction='z', cell_number=-10) p2d.plot_contacts(ax, direction='z', cell_number=-10) p2d.plot_lith(ax, direction='z', cell_number=-10) p2d.remove(ax2) # Plot p2d.plot_data(ax2, cell_number=5) p2d.plot_lith(ax2, cell_number=5) p2d.plot_contacts(ax2, cell_number=5) # surface B geo_model.add_surface_points(X=1447, Y=2554, Z=500, surface='B') geo_model.add_surface_points(X=1511, Y=2200, Z=500, surface='B') geo_model.add_surface_points(X=1549, Y=629, Z=600, surface='B') geo_model.add_surface_points(X=1630, Y=287, Z=600, surface='B') # surface C geo_model.add_surface_points(X=1891, Y=2063, Z=600, surface='C') geo_model.add_surface_points(X=1605, Y=1846, Z=700, surface='C') geo_model.add_surface_points(X=1306, Y=1641, Z=800, surface='C') geo_model.add_surface_points(X=1476, Y=979, Z=800, surface='C') geo_model.add_surface_points(X=1839, Y=962, Z=700, surface='C') geo_model.add_surface_points(X=2185, Y=893, Z=600, surface='C') geo_model.add_surface_points(X=2245, Y=547, Z=600, surface='C') # Surface D geo_model.add_surface_points(X=2809, Y=2567, Z=600, surface='D') geo_model.add_surface_points(X=2843, Y=2448, Z=600, surface='D') geo_model.add_surface_points(X=2873, Y=876, Z=700, surface='D') # Compute gp.compute_model(geo_model) # Plot p2d.remove(ax) p2d.plot_data(ax, direction='z', cell_number=-10) p2d.plot_contacts(ax, direction='z', cell_number=-10) p2d.plot_lith(ax, direction='z', cell_number=-10) p2d.remove(ax2) p2d.plot_lith(ax2, cell_number=5) p2d.plot_data(ax2, cell_number=5) plt.savefig(os.path.dirname(__file__) + '/../figs/test_pile_complete') # ---------------- # Second cycle geo_model.add_series(['Cycle2']) geo_model.add_surfaces(['G', 'H']) gp.map_series_to_surfaces(geo_model, {'Cycle2': ['G', 'H']}) geo_model.reorder_series(['Cycle2', 'Fault1', 'Cycle1']) # Surface G geo_model.add_surface_points(X=1012, Y=1493, Z=900, surface='G') geo_model.add_surface_points(X=1002, Y=1224, Z=900, surface='G') geo_model.add_surface_points(X=1996, Y=47, Z=800, surface='G') geo_model.add_surface_points(X=300, Y=907, Z=700, surface='G') # Surface H geo_model.add_surface_points(X=3053, Y=727, Z=800, surface='G') # Orientation geo_model.add_orientations(X=1996, Y=47, Z=800, surface='G', orientation=[272, 5.54, 1]) # Compute gp.compute_model(geo_model) # Plot p2d.remove(ax) p2d.plot_data(ax, direction='z', cell_number=-10) p2d.plot_contacts(ax, direction='z', cell_number=-10) p2d.plot_lith(ax, direction='z', cell_number=-10) p2d.remove(ax2) p2d.plot_lith(ax2, cell_number=5) p2d.plot_data(ax2, cell_number=5) p2d.plot_contacts(ax2, cell_number=5) plt.savefig(os.path.dirname(__file__) + '/../figs/test_pile_complete') # ---------------- # Second Fault geo_model.add_series('Fault2') geo_model.set_is_fault('Fault2') geo_model.add_surfaces('F2') geo_model.reorder_series(['Cycle2', 'Fault1', 'Fault2', 'Cycle1']) gp.map_series_to_surfaces(geo_model, {'Fault2': 'F2'}) geo_model.add_surface_points(X=3232, Y=178, Z=1000, surface='F2') geo_model.add_surface_points(X=3132, Y=951, Z=700, surface='F2') # geo_model.add_surface_points(X=2962, Y=2184, Z=700, surface='F2') geo_model.add_orientations(X=3132, Y=951, Z=700, surface='F2', orientation=[95, 90, 1]) # Compute gp.compute_model(geo_model) # Plot p2d.remove(ax) p2d.plot_data(ax, direction='z', cell_number=5, legend='force') p2d.plot_lith(ax, direction='z', cell_number=5) p2d.plot_contacts(ax, direction='z', cell_number=5) p2d.remove(ax2) p2d.plot_lith(ax2, cell_number=5) p2d.plot_data(ax2, cell_number=5) p2d.plot_contacts(ax2, cell_number=5) plt.savefig(os.path.dirname(__file__) + '/../figs/test_pile_complete') geo_model.add_surface_points(X=3135, Y=1300, Z=700, surface='D') geo_model.add_surface_points(X=3190, Y=969, Z=700, surface='D') geo_model.add_surface_points(X=3031, Y=2725, Z=800, surface='G') geo_model.add_surface_points(X=3018, Y=1990, Z=800, surface='G') geo_model.add_surface_points(X=3194, Y=965, Z=700, surface='G') geo_model.add_surface_points(X=3218, Y=1818, Z=890, surface='H') geo_model.add_surface_points(X=3934, Y=1207, Z=810, surface='H') # Compute gp.compute_model(geo_model) # Plot p2d.remove(ax) p2d.plot_data(ax, direction='z', cell_number=5, legend='force') p2d.plot_lith(ax, direction='z', cell_number=5) p2d.plot_contacts(ax, direction='z', cell_number=5) p2d.remove(ax2) p2d.plot_lith(ax2, cell_number=5) p2d.plot_data(ax2, cell_number=5) p2d.plot_contacts(ax2, cell_number=5) plt.savefig(os.path.dirname(__file__) + '/../figs/test_pile_complete')