segmented fault zone models

[vincent1990-adongo]

I am building an accurate representation of 3D fault zone models using a numerical approach python to be precise. I have played on repeat to your transform tutorials on geological modelling using Gempy for some time now.

I am not an expert in python though I am trying to learn it now. However, I do understand your
tutorials in building 3D fault models. I watched both transform 21 and 22 posted on youtube.

I have used Petrel software to build some fault geometries in 3D, However, there are some few limitations (geometrical) to what the software can do due the grid structures currently available in Petrel.

The pillar grid in petrel has limited geometrical flexibility for building complicated geometries. The other techniques from structural framework models include these flexibilities but have limitations in accurately representing locations and juxtapositions. They also have a limitation of fault property distribution across the common branch-lines or join lines of the segments.

Here, I would like to build the geometry using triangular grid cells/mesh on fault surfaces and a hexahedral horizon mesh, i.e using 'custom' or 'irregular grid' cells rather than the default 'regular' in Gempy.

With the fault being finite rather than infinite, I would be able to define some common points (bifurcation point) and branch lines in the 3D geometry where segments meet. Gempy defines the fault as infinite, rather than a finite fault in my case.

This grid structure should accurately place two segments with varying dip exactly on each other stochastically. That is, I should be able to predict accurately where the horizontal line between two simple faults is. There should be a common line defining the two segment boundaries to ensure a smooth fault property distribution.

I am to avoid displacement partitioning issues and drag errors between the fault surfaces and the horizon (unit) surfaces. This means that a single horizon surface must be finite, defining the footwall and a separate surface defining the hanging wall. Interpolation should happen between the limits of the defined points. Gempy however, interpolates the entire 3D volume which makes it difficult for me to control.

The Petrel software has been able to produce the geometries ideally perceived. However, the horizontal branch line of segments as well as join lines are not clearly defined due to the limitation associated with the grid types in building the structural framework.

So I would like to use python to numerically predict a more precise juxtaposition of the fault planes in 3D. This will help in defining the branch and join lines of faults without any displacement partitioning on the faults.

The image below shows a neutral relay of two segments merging to produce a single fault at a deeper depth. The horizontal branch-line is not clearly defined due to over extrapolation of the segments by the software.

Secondly, the throw on the fault at the branch-line is not distributed uniformly across the branch-line. The boundary between the segments is not accurate. A typical example of what I want to produce in python using Gempy is in the second image attached, where only two segments are defined.

I would be grateful and ready for discussion on the possible ways of changing the Gempy source code to do this. I am ready to provide additional information on the problem.

Hope to hear from you. If you have any ideas or suggestions, we can arrange for a meeting as well.

These are images from petrel, and similar images are required but with a uniform branch line other that the one in petrel.