GemPy Documentation

GemPy can model various complex 3D geological scenarios, such as:

• Multiple conformal layers: Sequences of sedimentary layers.
• Layer sequences: Including conformal continuation or unconformities.
• Magmatic bodies: Of almost arbitrary shapes.
• Faults: With automatically calculated offsets based on affected geological objects.
• Fault networks: Complex networks where faults can affect other faults.
• Folds: Affecting single layers or entire layer stacks, including overturned and recumbent folds.

To maintain a single graph implementation while supporting different computational backends (Numpy, Aesara, TensorFlow), GemPy uses a GemPyTensor wrapper. This wrapper provides a unified syntax for common operations, even when the underlying package syntax differs (e.g., handling set_subtensor which behaves differently in Numpy vs Aesara).

class GemPyTensor:
    def __init__(package='numpy')
        if package=='numpy':
            _tt = np
        elif package=='aesara':
            _tt = aesara.tensor

        # Same numpy-aesara easy
        def sin(x):
            return _tt.sin(x)

        # Different
        def set_subtensor(x: slice, new_slice)
            if package=='numpy':
                x = new_slice
                return x
            if package == 'aesara':
                return _tt.set_subtensor(x , new_slice)

GemPy uses a universal cokriging method to interpolate a 3D scalar field, where geologically significant interfaces are represented as isosurfaces. The algorithm integrates two primary types of geological input data:

• Surface contact points: 3D coordinates marking boundaries between features (e.g., layer interfaces, fault planes, unconformities).
• Orientation measurements: The orientation of poles perpendicular to the dipping of surfaces at specific points in 3D space.

Users can also define topological elements, such as combining multiple stratigraphic sequences or complex fault networks, to guide the modeling process.

GemPy supports multiple visualization methods:

• 2D Visualization: Direct visualization of 2D model sections or geological maps using matplotlib. This includes support for hillshading and other intuitive representation options.
• 3D Visualization: Interactive 3D plots using Pyvista.

For 2-D and 3-D visualization, install the gempy-viewer package:

$ pip install gempy-viewer

Note on 3-D Visualization: 3-D visualization relies on pyvista, which must be installed separately. Refer to the PyVista installation guide for instructions.

GemPy documentation is built offline using Sphinx and Sphinx Gallery. To update and preview documentation locally:

1. Ensure sphinx and sphinx-gallery are installed.
2. Navigate to the documentation directory: cd docs.
3. Build the HTML documentation: make html.
4. Preview the output by opening docs/build/html/index.html in a web browser.

Install the latest stable release of GemPy using PyPI. It is highly recommended to use the [base] extra to ensure necessary dependencies are included.

Note: GemPy v3 is the current stable version. If you require workflows from previous versions, you must use gempy_legacy instead.

$ pip install gempy[base]