In [2]:
# These two lines are necessary only if gempy is not installed
import sys, os
sys.path.append("../")
# Importing gempy
import gempy as gp
# Embedding matplotlib figures into the notebooks
%matplotlib inline
# Aux imports
import numpy as np
All data get stored in a python object InputData. Therefore we can use python serialization to save the input of the models. In the next chapter we will see different ways to create data but for this example we will use a stored one
In [3]:
geo_data = gp.read_pickle('NoFault.pickle')
geo_data.n_faults = 0
print(geo_data)
This geo_data object contains essential information that we can access through the correspondent getters. Such a the coordinates of the grid.
In [4]:
print(gp.get_grid(geo_data))
In [5]:
gp.get_raw_data(geo_data, 'interfaces').head()
Out[5]:
In [6]:
gp.get_raw_data(geo_data, 'foliations').head()
Out[6]:
It is important to notice the columns of each data frame. These not only contains the geometrical properties of the data but also the formation and series at which they belong. This division is fundamental in order to preserve the depositional ages of the setting to model.
A projection of the aforementioned data can be visualized in to 2D by the following function. It is possible to choose the direction of visualization as well as the series:
In [7]:
gp.plot_data(geo_data, direction='y')
Out[7]:
GemPy supports visualization in 3D as well trough vtk.
In [7]:
gp.visualize(geo_data)
As we have seen objects DataManagement.InputData (usually called geo_data in the tutorials) aim to have all the original geological properties, measurements and geological relations stored.
Once we have the data ready to generate a model, we will need to create the next object type towards the final geological model:
In [9]:
interp_data = gp.InterpolatorInput(geo_data, u_grade = [3])
print(interp_data)
By default (there is a flag in case you do not need) when we create a interp_data object we also compile the theano function that compute the model. That is the reason why takes long.
gempy.DataManagement.InterpolatorInput (usually called interp_data in the tutorials) prepares the original data to the interpolation algorithm by scaling the coordinates for better and adding all the mathematical parametrization needed.
In [10]:
gp.get_kriging_parameters(interp_data)
These later parameters have a default value computed from the original data or can be changed by the user (be careful of changing any of these if you do not fully understand their meaning).
At this point, we have all what we need to compute our model. By default everytime we compute a model we obtain 3 results:
In [11]:
sol = gp.compute_model(interp_data)
This solution can be plot with the correspondent plotting function. Blocks:
In [12]:
gp.plot_section(geo_data, sol[0], 25)
Out[12]:
Potential field:
In [13]:
gp.plot_potential_field(geo_data, sol[1], 25)