{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Wellbore Paths in PyVista "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I just learned about PyVista a few weeks ago, and I finally had some time to sit down with it and see some of the things it can do. So for an example I decided to plot up a few well pads with horizontal wells from the Denver Basin. I spent some time cleaning and organizing the data so it would be easier to deal with and I could focus on learning `PyVista` and `PVGeo`. To install `PyVista`, `PVGeo`, and `panel` run the first cell"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"#!pip install pyvista\n",
"#!pip install panel\n",
"#!pip install PVGeo"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we are going to import `pandas` for reading in our well data, `numpy` for making stratigraphic surfaces, `pyvista` and `PVGeo` for visualization. Also we are going to set the `panel.extension` to `'vtk'` and set the `pyvista` theme to `document"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"import pyvista as pv\n",
"import panel\n",
"import PVGeo\n",
"\n",
"panel.extension(\"vtk\")\n",
"pv.set_plot_theme(\"document\")\n",
"import warnings\n",
"\n",
"warnings.filterwarnings(\"ignore\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's read in the data using `pandas` and get a quick look at it"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"data = pd.read_csv(\"wellbore_and_gamma.csv\", index_col=[0])\n",
"data.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's get the names of the wells from the data and assign them to a variable"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"wells = data.name.unique()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we want to go through the data and build a `dict` for each well"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# split out the wells into a dictionary\n",
"well_dict = {}\n",
"for well in wells:\n",
" well_dict[\"{0}\".format(well)] = data[data.name == well]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next let's take each well in the `well_dict` and get the points referenced to one another so they all plot up in real space relative to one another. We are then creating a `numpy` array with the `'easting'` (x-value), the `'northing'` (y-value), and the `depth` which is our true vertical depth. We now have each entry in the `points_dict` with an x, y, and z value."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now turn the wells into points\n",
"points_dict = {}\n",
"for points in well_dict:\n",
" points_dict[\"{0}\".format(points)] = np.array(\n",
" list(\n",
" zip(\n",
" well_dict[points].easting + well_dict[points].x,\n",
" well_dict[points].northing + well_dict[points].y,\n",
" -well_dict[points].depth,\n",
" )\n",
" )\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"From the points we want to create `PolyData` to plot in `PyVista`. To create this `PolyData` we use `PVGeo.points_to_poly_data()` on each entry in the `points_dict`. Then we use `PVGeo.filters.AddCellConnToPoints` to create cells connecting the points. At this point we have everything we need to plot up wellbore trajectories. But let's have some fun!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# now turn points into polydata\n",
"lines_dict = {}\n",
"for lines in points_dict:\n",
" poly = PVGeo.points_to_poly_data(points_dict[lines])\n",
" lines_dict[\n",
" \"{0}\".format(lines)\n",
" ] = PVGeo.filters.AddCellConnToPoints().apply(poly)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To color and size the `PolyData` by a value we use the `GR` column from the original dataset. We assigne the `GR` gamma-ray values to each `PolyData` object meaning we now have `DataArrays` for each well that we can use to color our wellbore. Finally, we use `.tube()` to create tubes at each point with radius 10 that scale with the `GR` gamma-ray values. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for path in lines_dict:\n",
" lines_dict[path][\"GR\"] = data[data.name == path].GR.values\n",
" lines_dict[path].tube(radius=10, scalars=\"GR\", inplace=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We could plot up the wellbores at this point and have a great plot, but let's make some stratigraphic surfaces. I grabbed some tops from the [COGCC](https://cogcc.state.co.us) website for one of these wells. To make surfaces we need `x` and `y` values spanning the area we are interested in. So I use the minimum and maximum from the dataset and then add 1,000 feet in the x and y direction for the surfaces. Next we use `meshgrid` and create our grid. Then for each surface I create an empty array using `np.empty()` and `.fill` it with the depth to each top. For the last step for each surface we use `StructuredGrid` to create a structured `PolyData` grid. Here we have the Niobrara, Shannon, Sussex, Parkman, and Pierre formation tops."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = np.arange(\n",
" data.x.min() - data.easting.min() - 1000,\n",
" data.x.max() + data.easting.max() + 1000,\n",
" 200,\n",
")\n",
"y = np.arange(\n",
" data.y.min() - data.northing.min() - 1000,\n",
" data.y.max() + data.northing.max() + 1000,\n",
" 200,\n",
")\n",
"x, y = np.meshgrid(x, y)\n",
"r = np.sqrt(x ** 2 + y ** 2)\n",
"\n",
"nio = np.empty(r.shape)\n",
"nio.fill(-5930)\n",
"niobraragrid = pv.StructuredGrid(x, y, nio)\n",
"\n",
"shn = np.empty(r.shape)\n",
"shn.fill(-4454)\n",
"shannongrid = pv.StructuredGrid(x, y, shn)\n",
"\n",
"ssx = np.empty(r.shape)\n",
"ssx.fill(-4009)\n",
"sussexgrid = pv.StructuredGrid(x, y, ssx)\n",
"\n",
"prk = np.empty(r.shape)\n",
"prk.fill(-3332)\n",
"parkmangrid = pv.StructuredGrid(x, y, prk)\n",
"\n",
"pie = np.empty(r.shape)\n",
"pie.fill(-2267)\n",
"pierregrid = pv.StructuredGrid(x, y, pie)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"All that work and now we get so see how it turned out! We start by creating our `Plotter` and then `add_mesh` for each pice of `PolyData` that we have created so far. Lastly, we call `.show()` and we have an interactive set of wells!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"plotter = pv.Plotter()\n",
"for well in lines_dict:\n",
" plotter.add_mesh(lines_dict[well])\n",
"plotter.add_mesh(niobraragrid, opacity=0.5, color=\"white\")\n",
"plotter.add_mesh(shannongrid, opacity=0.5, color=\"black\")\n",
"plotter.add_mesh(sussexgrid, opacity=0.5, color=\"purple\")\n",
"plotter.add_mesh(parkmangrid, opacity=0.5, color=\"orange\")\n",
"plotter.add_mesh(pierregrid, opacity=0.5, color=\"green\")\n",
"\n",
"plotter.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This notebook is licensed as CC-BY, use and share to your hearts content."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Py3 ELA",
"language": "python",
"name": "ela"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}