Geological modeling

Geological modeling software

Turn picked horizons and faults into a framework the rest of the project can stand on. g-Space builds the structural model as TIN surfaces under constraints you set per data type, cuts it into layers and fault blocks, and hands the result to geo-bodies, 3D grids and volumetrics — with an uncertainty ensemble available when one answer is not enough.

Download free trial How the framework is built Watch Demos

Soft or hard

Per data type, per horizon

Fault blocks

Generated with the layers

Up to 1000

Uncertainty realizations

Layered 3D geological model in the g-Space depth view, its coloured layers cut by a red fault surface, with seismic sections behind it

Geo-body drawn above an interpreted horizon in the g-Space 3D time view, between two seismic sections, with wells passing through it

In view

Layered model cut by a fault

Two wizards, and they are not the same wizard. Structural Modeling builds the framework — TIN surfaces from interpreted horizons or from the objects organised in the Conceptual Model, ordered stratigraphically, given conformity roles, honouring a fault model and a border, and cut into layer volumes and fault blocks. Create 3D geological model builds the bodies — layers defined by their top and bottom depth maps, cut by the faults you choose, emerging as geo-bodies you can slice open in 3D. One produces the surfaces everything else is hung on; the other produces the volumes you interrogate. Most projects want both, in that order.

The pieces

Six tools that build one subsurface architecture.

Interpretation goes in as objects, not as files. Each tool below takes what the previous one produced, and every result stays in the Data Manager where the rest of the project can reach it.

Organise

Conceptual Model

Links Data Manager objects into geological objects — a horizon, an unconformity, an intrusion — each carrying its conformity, direction and stratigraphy. It stores no new data, it is domain-independent, so one framework can reference both time and depth, and a project can hold several models and switch the active one.

Framework

Structural modeling

Builds TIN surfaces from the ordered inputs, honouring a fault model and a border polygon. Results appear under TIN Maps, with the modelled fault surfaces, the layer volumes generated between consecutive surfaces, and the fault blocks — ready for section and 3D views.

Faults

Fault model

3D fault-network models built from fault picking by the Fault Modeling wizard, then consumed by structural modelling, by geological modelling and by map interpolation. Fault data can also be extracted back out as a point set.

Bodies

Create 3D geological model

From the Reservoir bar: define the layers by name, top map, bottom map and geological age, choose the individual faults and the depth-domain fault models that cut them, and bound the model with a closed polygon. Each layer becomes a geo-body, and a layer split by a fault becomes several numbered objects.

Surfaces

Multi-Z surfaces

Multi-valued TIN surfaces carrying several Z values per XY, so overturned and faulted geometry can be represented. Built by picking sticks on sections in any order, rebuilt on demand, and converted between time and depth through the velocity model.

Risk

Structural uncertainty analysis

An ensemble of perturbed realizations from one finished depth model, each displacing horizons and faults by a random draw. The result is an uncertainty envelope you can look at rather than a single line that pretends to certainty.

What you control

The model does what you tell it, and says when it cannot.

Every input gets a role, every fault gets a treatment, and anything the wizard could not build is named in a warning after the run rather than quietly left out.

Soft, hard or not at all

Points, maps, multi-Z surfaces and well markers each get their own usage per horizon: no data, soft — used as a trend the surface may deviate from — or hard, which forces the surface exactly through them. The cells are colour-coded so the whole table reads at a glance.

Conformity and truncation

Each horizon is depositional, an unconformity or an intrusion, and an unconformity says whether it truncates from above or below. Order the stack from shallowest to deepest and the truncation rules follow it.

Faults as a real constraint

Choose a fault model or ignore faults entirely. With one selected, each modelled horizon is smoothed where it meets the fault surfaces over the fault clear radius, so it approaches the fault evenly rather than reproducing its small vertical steps — and a radius of zero leaves the split exactly as it came.

Fault surfaces from the picks

The Fault Modeling wizard treats each fault's points, sticks, maps and markers separately. Soft sticks let the surface follow the fitted trend so noisy picks stop pulling it out of shape; hard sticks make it follow the picks as closely as it can, and hard markers make it intersect the fault picks in the wells.

Vertical limits, when you want them

Optional top and bottom planes extend the model beyond the selected horizons, each adding an interval of its own. They are build artefacts — rebuilt from the current values on every run rather than accumulating — and off by default, so the model spans the data unless you say otherwise.

Resolution you can iterate on

Grid steps in X and Y set the output resolution and smoothing runs from nought to a hundred; layers between consecutive surfaces and fault blocks are generated by default. Start coarse for a preview, refine once the framework is right.

Mesh quality, measured

Mesh optimization smooths, decimates, re-meshes and repairs holes in a triangulated surface, always writing a new object rather than overwriting the source. Its metrics tab reports the watertight flag, edge-length spread, dihedral angles and an aspect-ratio histogram, so the fix is chosen from evidence.

Warnings that name names

If an object cannot be built from the inputs it was given, the model is still created and a warning identifies exactly which object failed after the run — along with any horizon, fault or layer left out because a cut could not be completed reliably.

Workflow

Six steps from interpretation to a model you can grid.

Organise the interpretation

Drag horizons, maps, multi-Z surfaces, attribute maps and well picks onto geological objects in the Conceptual Model, and set each object's conformity and direction there once rather than in every wizard.

Model the faults first

Build a fault model from the picked faults, deciding per fault whether its sticks are followed exactly or fitted to a trend, and whether well markers are a hard constraint on the surface.

Build the structural model

Select the domain, the fault model and the border, add the objects in stratigraphic order, set each input to soft or hard, and run — coarse at first, to see whether the framework hangs together.

Check it in 3D

Review the TIN surfaces, the layers and the fault blocks in the 3D view and on sections, read the warnings from the run, and repair or regularise any mesh whose quality metrics say it needs it.

Build the geological model

Define the layers from the depth maps with their names and ages, choose the faults that cut them, bound the model with a closed polygon and run it. Each layer arrives as a geo-body, sliceable in 3D.

Hand it downstream

A tetrahedral 3D grid can be built straight from a structural model, honouring its surfaces and staying inside its fault blocks — and from there property modelling, grid QC and volumetrics take over.

Maps & visualisation

The surfaces the model is made of, and the maps you make from them.

Interpolation settings on the Modelling bar govern every action that builds or rebuilds a map from horizons, points or markers, so the fault treatment you set once is the fault treatment the whole project uses.

Building maps

From a horizon, from well markers or from a point set

Three algorithms

ABOS, kriging with a spherical, Gaussian or exponential covariance and its range, or Adaptive Snap — a coarse-to-fine method that converges and then snaps the surface onto the control points, so the map honours the picks.

Maps from markers

Choose a marker of the active set and the value to map — measured depth, true vertical depth, depth below sea level or the marker's own attributes — and build the map straight from the wells.

Faults as barriers

Ignore faults, use selected faults, use a fault model or use fault polygons. With any of them the map is interpolated separately on each side, and a clear radius discards noisy input near the trace and rebuilds the strip from data further away.

Trends

Build on top of a regional surface: the trend map is subtracted from the input, the difference is interpolated, and the trend is added back. Input points the trend map does not cover are reported rather than silently dropped.

Extent and cell size

Step X and Step Y in the project's own distance unit, and a map box that follows the input points, the whole survey or a polygon you name.

Data density

Adaptive Snap is told whether its control data is sparse, as well markers are, or dense, as an interpreted horizon grid is — or left to work it out from the spacing and the grid step.

Editing and viewing

The Map Editor, the sections and the 3D view

Map Editor

Smooth away interpolation noise, remove an isolated spurious peak, set a value over an area, or add and subtract a constant — each tool undoable from the same menu it is invoked from.

Contours that read

Label no contours, the major ones or all of them; set the spacing at which labels repeat, their size, colour and rotation, and which side of the contour the label faces — smaller values for depth and time maps, larger for isochore and isopach.

Geo-bodies in 3D

Each body draws as solid, transparent, outline, points or surface mesh, and the slicer cuts the whole set open interactively along a plane you drag through the volume.

Sections and cross-sections

Structural surfaces, geo-bodies and multi-Z surfaces project onto inline, crossline and arbitrary-line sections in both time and depth, alongside the seismic they were picked on.

Points out of bodies

Extract points turns a geo-body's mesh nodes into a point set with a depth attribute already assigned, so it plots correctly on sections and in 3D without further setup.

Model exchange

Multi-Z surfaces import from and export to GOCAD TSurf and RESQML EPC, so a framework can be moved between packages rather than rebuilt.

Tools in this group

The parts of g-Space this topic is built from

Conceptual Model Structural modeling Create 3D geological model Fault Modeling wizard Structural models Geo-bodies Multi-Z surfaces Mesh optimization Structural uncertainty analysis Modelling bar Map building Map editor Slicer

More g-Space capabilities

The framework is where the reservoir work begins.

Lithofacies and petrophysical properties are populated into grids built on this framework — see reservoir characterization for that half. These are the other topics in the g-Space workflow.

g-Space overview Geological interpretation Horizon picking Fault picking Well tie Seismic mis-tie Velocity modeling Petrophysics Attribute analysis & AVO Reservoir characterization

FAQ

Questions, answered.

What is the difference between structural modeling and geological modeling in g-Space?

They are two separate wizards that do two separate jobs. Structural Modeling builds the framework: it takes interpreted horizons, or the geological objects organised in the Conceptual Model, assigns them a stratigraphic order and conformity relationships, honours a fault model and a border polygon, and produces a consistent set of TIN surfaces along with layer volumes and fault blocks. Create 3D geological model works the other way round, from depth maps: you define the layers by their top, bottom, name and age, choose which faults cut them, and it produces geo-bodies, one object per layer and a numbered object for each faulted segment.

How do faults constrain a structural model?

First they are built into a fault model of their own. The Fault Modeling wizard takes the picked faults and decides per data type how each is used — points, sticks, maps and well markers each set to no data, a soft guiding constraint or a hard one the surface must pass through. That model then feeds the structural model, which builds separate fault blocks and smooths each horizon where it meets a fault surface, over a fault clear radius, so the surface approaches the fault evenly instead of reproducing its small vertical steps. The same fault handling is available when maps are interpolated, where faults act as barriers and values are not smoothed across them.

Can the uncertainty of a structural model be quantified?

Yes. Structural Uncertainty Analysis generates an ensemble of perturbed realizations from a finished depth-domain model. Each realization displaces the horizons and faults by a random amount drawn from a distribution you choose per element — uniform, triangular or Gaussian — inside a symmetric displacement envelope you set, and elements that are well constrained can be held fixed. Where well markers exist, a perturbed surface can be clamped to stay on its base-case side of them. Ten realizations is the default and up to a thousand can be run; the ensemble draws in the 3D view colour-coded by realization, which is the uncertainty envelope, and on cross-sections as well.

How are maps built and edited around the model?

Map building creates a map from a horizon, from well markers or from a point set in one dialog, with ABOS, kriging or the coarse-to-fine Adaptive Snap as the algorithm, a cell size and a map extent, fault handling, optional post-mapping smoothing, and a trend option that subtracts a regional surface, interpolates the difference and adds the trend back. Once built, the Map Editor refines the result: smoothing to take out interpolation noise, removing isolated spurious peaks, setting a value over an area, and adding or subtracting a constant, with contour labelling controlled down to spacing, size, rotation and which side of the contour the label faces.

Get started

Build the framework on your own interpretation.

Bring your horizons and faults, set the constraints per data type and see how the surfaces hang together — take g-Space for a trial run, or talk to Geomage about a demo on your data.

Download free trial See pricing