Structural geological models can be constructed with different approaches, and the choice of a specific modelling method directly depends on the model applications and the available input information.

The approach that we apply here is based on kinematic modelling concepts. The distinction between interpolation and kinematic methods is most apparent when considering the types of data and geological constraints that are honoured. The most common approach to construct structural models is based on surface and volume interpolation methods . An example of the general interpolation function is presented in Fig. a. Structural interpolations focus on honouring parameterised surface contact points , although secondary data like orientation measurements can also be taken into account . Constraints on the shape of geological surfaces, or the interaction with other units or faults, are then assigned to different surfaces, according to observations in the field or the expected geological settings. While these considerations are clearly based on geological reasoning, it is not guaranteed that an interpolated structural model matches all the known aspects of the geological evolution of an area. For example, it is easily possible that constraints on thickness of geological units are not consistent, for example across a fault, leading to a violation of mass conservation. Additionally, a wide range of structures observed in multiply deformed terranes, such as complex fault networks or refolded folds, are difficult to construct consistently using current interpolation methods.

Another endmember in the evaluation of the structural setting are simulations of physical processes e.g.. Instead of starting with geological observations, these methods are based on mathematical models capturing relevant physical processes that led to the formation of specific structures (Fig. b). For realistic simulations, meaningful constitutive models and boundary conditions are required. Multiple different methods exist, which capture different aspects of the mechanical deformation, and more and more commonly also the effect of coupled thermal, hydraulic, mechanical and chemical simulations. However, these types of simulations are not yet commonly applied to model the entire complexity of multiply deformed geological regions as simulations are computationally demanding and rock properties and boundary conditions are not always perfectly known. Furthermore, they require an initial distribution of rock properties in space as initial conditions, often determined from an explicit or implicit interpolation approach.

Kinematic modelling methods focus on major tectonic and metamorphic events in geological history and are therefore conceptually located between the previously described endmembers (Fig. c). In these models, the complexity of deformation is greatly reduced and captured in simplified kinematic functions as surrogate models. This means that direct geological observations of surface contacts and orientation measurements are not taken into account in the simulation step. However, the simulations are very fast and enable therefore a quick testing of different deformational scenarios, and the interaction of multiple events in geological history. Furthermore, rapid simulation makes direct (and ideally automated) comparisons between the model and observed structures feasible, allowing for the indirect incorporation of geological observations. We will present several examples in which this trade-off between physical realism and geological observations can lead to useful insights into the interaction and relevance of deformational events in geological history.

Noddy models begin as a layer cake stratigraphy, for which the heights of the stratigraphic contacts and geophysical rock properties are defined. A history of relevant events that affected the model region is then developed from a predefined set of events, including folds, faults, and shear zones; unconformities, dykes, and igneous plugs; regional tilting and homogeneous strain. In addition to modifying the initial stratigraphy, each event can define (geophysical) alteration halos, penetrative cleavages, and lineations.

Each Noddy event is defined by four classes of properties: form, position, orientation, and scale . For example, a fault is defined by its dip and dip direction, the pitch and magnitude of the slip vector, and the position of one point on its surface note that more complex definitions of the fault plane are also possible; cf.. The use of geological descriptions provides a natural and intuitive framework for geologists to build a model. Even though the structural events themselves are relatively simple, complex geometries quickly develop as two or three events are superimposed on one another (see examples in Sect. ).

Displacement equations are stored as a “history”, which provides parameterised definitions of the model kinematics and rock properties. A voxel model of any 3-D rectangular volume of interest can be calculated from this history by considering each voxel independently using the Eulerian (inverse) form of the defining Lagrangian displacement equations, and applying them in reverse chronological order (i.e. starting with the most recent deformation event). This operation transforms the x, y, and z position of each voxel into the x, y, z position at the time the associated volume of rock was created. The properties of this voxel can then be calculated directly from the base stratigraphy.

New lithologies can also be created during three specific event types: unconformities, dykes, and plugs. These events are assumed to be instantaneous, and are ordered relative to other events. In order to simplify the underlying kinematic equations, they are all defined in a standard reference frame that is orthogonal to the symmetry of the deformation event. The real world reference frame is rotated into the standard reference frame prior to the calculation of each event, and then subsequently rotated back to the real world reference frame using the variations in the z values as a continuous implicit field that can be iso-surfaced to produce stratigraphic horizons.

As well as the initial position of the point, a binary “discontinuity code” is stored, that records each time a voxel is affected by an event described by a discontinuous displacement equation (faults, unconformities, dykes, and plugs) but ignores events described by continuous displacement equations (folds, shear zones, strain, rotation, foliations, and lineations). This discontinuity code allows for the accurate transformation of the voxel data set to a vector data set, since only voxels that have exactly the same sequence of discontinuity codes are part of the same contiguous volume of rock. If two adjacent voxels have different codes, the difference in the discontinuity code that occurred most recently defines the discontinuity that separates them.

The orientations of specific features (bedding, foliation, fault planes, remanence vectors, etc.) are calculated using both the inverse and then the forward displacement equations. Starting with the current 3-D location of a point, the position of this point at the time of formation of the structural feature (which may or may not be the time of formation of the rock) is calculated. Three points are defined close to this position, which define a plane with the orientation of the feature prior to deformation. The positions of these three points at the final time are then calculated, from which the final orientation of the structural feature can be calculated.

Similarly, the orientation of a linear feature is calculated from the intersection of two planes. Thus, both the Eulerian (inverse) and Lagrangian (forward) descriptions of the displacements must be available for a new deformation event to be included in the modelling scheme. For this reason, the displacement equations governing each Noddy deformation event are kept as simple as possible, and superimposed deformation events are combined to produce structural complexity. A full description of the Noddy implementation is presented in .

Noddy histories are stored as ASCII files with a simple keyword-value ordering. These files can be written or adapted with any text editor, and the kinematic modelling result computed with a compiled command line version of the program and results visualized with other software.

A graphical user interface (GUI) has previously been created to simplify this model set-up, combining convenient input file generation directly with computation and visualization of the results. This GUI is freely available (http://tinyurl.com/noddy-site), though currently only runs on Windows operating systems. The GUI version of Noddy is also limited to user-driven workflows, restricting further automation or extension of the methods for scientific experiments.

In order to overcome the problem of either having to work with a direct text input file, or being restricted by the limitations of a GUI, we have developed flexible modules in the programming language Python that enable scripted access to the kinematic modelling functionality and enable the extension to uncertainty estimations.

Python is an object-oriented scripting language that is widely used in scientific computation e.g.. It is highly flexible language, and contains a variety of programming and visualization libraries ideal for scientific purposes. Python also runs on virtually every operating system that is available, meaning that python wrappers retain the platform independence of C applications.

The pynoddy module described here contains a set of classes and functions for managing Noddy input files, passing them to the Noddy command-line application, and processing the results. This approach has many advantages, as it allows automatic generation and analysis of kinematic models in a Python environment, while retaining the performance of Noddy itself (which is written in C).

We start here with an example that is conceptually simple, but can quickly lead to complex structural settings: the interaction of a sequence of fault events on a predefined stratigraphy (Fig. a). A more detailed description and interactive version is available as an IPython notebook as part of the repository and as Supplement for this manuscript (see section on “Code availability” and Appendix B).

This model is constructed from a stratigraphic sequence containing five units, each 1000 m thick. We consider a model domain of 10 000 × 7000 × 5000 m in x, y, and z directions. In the following descriptions, we define points with respect to an origin in the model at the top, SW corner (i.e.: the point (0,0,-1000) is at a depth of 1000 m at the south-west corner). A representation of the model in a (x,z) section is given in Fig. a.

The second event in the model is a fault that affects the eastern part of the model. We define the fault at the top of the model at position (2000, 3500, 0) dipping 60 → 090 and a fault slip of 1000 m. The effect of this fault on the previous stratigraphic pile is visualized in Fig. b. The third event is also a fault, defined with a surface at position (8000, 3500, 0), dipping 60 → 270 and a slip of 1000 m (Fig. c).

In terms of this definition of kinematic equations, the two fault events are symmetrical. However, the combination of both events leads, as can be expected, to a non-symmetrical interaction pattern, here clearly visible in the central part of the model (Fig. d).

The previous example is included to present the possibilities for the simple construction of a kinematic model from start. The model itself is mostly interesting from an instruction or teaching perspective and we will move to more complex models in the following.

One motivation for the development of Noddy was to provide a method to explain and teach the effect of subsequent geological events, as we presented an example above. The capability of Noddy to calculate geophysical fields can furthermore be used to provide insights for the interpretation of geophysical potential field data. We can, for example, quickly evaluate how changing the properties of a geological event (for example the dip angle of a fault) influences a simulated potential field.

In fact, this capability of Noddy has been a main driver to develop the Atlas of Structural Geophysics, an online collection of geological models with their simulated corresponding potential fields for a wide variety of typical structural geological settings (http://tectonique.net/asg).

We provide in pynoddy the functionality to directly load models from this atlas into python objects, for further testing and manipulation. In addition, the pynoddy.output module also contains a class definition to read in the calculated potential field responses (NoddyGeophysics). In combination, these methods enable us to quickly test the effect of different event properties on calculated potential fields.

As an example, we evaluate here how changing properties of deformational events affects the forward calculated gravity field with a model of a fold and thrust belt (Fig. ). The required commands to download a model from the web page, to adjust cube size (for better representation), to write it to a file, and to run the model, are combined in a tutorial notebook for detailed reference (see Appendix ). The 3-D visualization in Fig. c was generated through the pynoddy export to VTK and visualized in Paraview (see Sect. ).

We calculate the gravity field for this model with the spectral scheme (Sect. ) by calling pynoddy.compute in the geophysics simulation mode. The resulting z-component of the gravity field is visualized in Fig. a.

As a next step, we evaluate how the effect of a different wavelength in the folding event, as the latest event in the model history, affects the calculated gravity field. This adaptation, as well as the recalculation and visualization of the geophysical field (Fig. b), can be performed with a few lines of Python code (see tutorial notebook for details). In addition, we use simple Python commands to calculate and visualize the difference between the gravity fields of the original and the changed model (Fig. c).

With the previous examples, we showed the application of pynoddy to perform simple kinematical modelling experiments. These types of experiments could also be performed with the already existing GUI of Noddy, or even on the basis of the ASCII input files, only. The use of pynoddy does, however, provide a simple and direct way to adjust models, and to directly perform additional calculations (e.g. for the difference of the gravity fields), and to generate high-quality visualizations with additional Python tools.

With the following example, we now want to highlight an essential advantage of our new implementation in pynoddy: the high-level definition of scientific experiments with kinematic models.

One main motivation for the definition of a python package to access the functionality of kinematic modelling is the increased level of flexibility that it offers when performing scientific studies with kinematic models. Specifically, we can automate the entire model construction processes and can hence easily perform multiple simulations with different parameter settings. This possibility enables a whole new range of applications, from simple scenario testing (as shown above), to the analysis of model uncertainties due to the propagation of errors in input parameter and model settings. In this sense, pynoddy is ideally suited to perform scientific experiments on the basis of kinematic modelling concepts.

If all steps of a pynoddy experiment are automated properly, they can be integrated into one script for model set-up and analysis. If implemented properly, this method enables a complete reproduction of results. As described in Sect. , we provide a high-level object-oriented method for classes of full kinematic experiments, combining Noddy input and output, automatic computation when required, and the additional integration of further methods from external Python packages.

In the following example, we show how we use the pynoddy.experiment methods to investigate error propagation with a Monte Carlo experiment for a complex geological model of the Gippsland Basin. The tectonic history input to Noddy is shown in Fig. a. This simplified but representative geological history has been primarily derived from , , , and . Each event shown in Fig. a corresponds to an event interpreted from the Gippsland Basin, a Mesozoic to Cenozoic oil and gas field in southeastern Australia . Our model basement is Ordovician rocks and the cover sequences include the Oligocene Seaspray and Pliocene Angler sequences. Of particular interest for oil and gas prospectivity is the Paleocene to late Miocene Latrobe Group, which includes the Cobia, Golden Beach, and Emperor subgroups . The basin is cross-cut by a number of transfer and normal faults; however, we only model the most pervasive fault sets for this example. These include the north-northeast to north-east-trending Lucas Point Fault, Spinnaker Fault, and Cape Everard Fault systems, and the east–west-trending Wron Wron/Rosedale Fault systems. Some large-scale (10 s km wavelength) folding is observed; however, the basin retains an overall layer-cake stratigraphy.

We now want to evaluate how uncertainties in the kinematic parameters of the different tectonic events (Fig. a) propagate to the final constructed model (Fig. b). The general procedure is briefly outlined here, for more details please see the IPython notebook with the complete example and more thorough descriptions (see documentation and tutorial, Sect. ).

We use here the class UncertaintyAnalysis, which contains methods for Monte Carlo-type error propagation and subsequent uncertainty analyses. As a first step, we consider relevant kinematic modelling parameters now as random variables, instead of deterministic variables. The properties of these random variables can be described as probability distributions in several ways. We use here a simple definition in a table, stored in a comma separated file, that can be loaded directly into the object.

We assign normal distributions to location points and layer thicknesses, with a mean value according to the prior mean, and a standard deviation of 100 m, to reflect the overall uncertainty in defining representative thickness and location values on the large scale of the model. The wavelength of the late folding event (Fig. a) has a mean of 15 km and we assign a standard deviation of 2.5 km, assuming a high uncertainty in determining a wavelength for this event. Uncertainties in orientation measures are defined with a von Mises distribution. We provide details on the parameter distributions in a table in the Appendix ().

With the parameters of the random variables stored in an external file, we can instantiate the uncertainty analysis object with the history file of the kinematic model and the name of the parameter file as arguments:

ua = UncertaintyAnalysis(history_file, params)

We can now directly generate n random samples from this model with

ua.estimate_uncertainty(n)

The set of results is, by default, saved directly within the object, and can be extracted in the form of Python numpy arrays for further processing. In addition, a set of standard post-processing methods and utility functions is already implemented in the class definition. For example, it is directly possible to generate analyses and visualizations for the probability of outcomes for a specific geological lithology per voxel , and for the analysis of voxel-based information entropy measures .

In this example of the Gippsland Basin, we perform Monte Carlo error propagation for a set of 32 parameters of all kinematic events in the model, and generate 100 random realizations of the model (see tutorial notebook in documentation). For post-processing, we analyse and visualize results in a 3-D plot of cell information entropies (Fig. c). The estimated uncertain areas in the model are clearly visible, and the highest uncertainties exist in areas where the effect of uncertainties in different events overlaps (see Fig. c).

The previous experiment is a typical example of Monte Carlo sampling methods . One characteristic of the sampling is that all realizations are drawn independently. Therefore, a parallel implementation of the sampling is directly possible. As one possibility, we provide a parallel sampling scheme implemented in the class, based on the Python threading module, and we used this scheme successfully on a supercomputer. For more information on this possibility, see documentation (Appendix ) and the source code of the monte_carlo.py module.

The information provided here is reflecting the current state of the repository at the time of manuscript preparation. In case you find information outdated, please contact the corresponding author.

pynoddy is free open-source software. It is currently hosted on:https://github.com/flohorovicic/pynoddy.