General Concepts in Flows

Because Flows will be a new concept to many of you it is important to understand the general concepts that flows are built upon. These concepts are:

• Many tasks are repetitive
• These tasks should be done consistently
• These tasks can often be split into small pieces.

What Are Flows?

Flows are essentially a series of steps used to perform batch/repetitive operations. Each flow consists of a series of steps that can basically be summarized in three parts:

1. Data input
2. Data processing
3. Data output

For additional discussion, including examples, see this help article.

Flows Don’t Replace Petrophysics

Flows are NOT a replacement for Petrophysics or CPI files. They are a compliment to the petrophysics interpretation capabilities that can be used both beforehand and afterwards. For example, Flows may be used to construct a set of grids based on one’s petrophysical interpretation. Or, a Flow may be used to perform some data management or pre-processing before starting an interpretation.

Flows Building Blocks

Flows are constructed using a series of pre-defined building blocks. These blocks stack on one another allowing you to perform more intricate operations along the way. There are essentially three types of blocks: Input blocks, manipulation or calculation blocks, and output blocks.

Input Blocks

Within Danomics data input types include:

• Well databases
• Log databases
• Tops databases
• Points databases

Within flows you have the ability to choose each of these as input types. For example, if you want to work with points, you choose the PointsInput block. If you want to work with well logs, you choose the LogsInput block. And so on.

Processing Blocks

Once you have selected the data to work with, you probably want to manipulate it in some way. For example, if working with points, you may want to perform some math operation on them. This could be summing the volume of kaolinite, smectite, and illite from an XRD analysis to calculate a total clay. Or, if working with well logs this could range from anything from renaming all of gamma ray curves to a common mnemonic prior to archiving it in a company database to despiking sonic curves to predicting missing curves via machine learning. In general, operations include:

• Math and filtering operations on points
• Math operations on grids
• Math operations on well logs
• Data management operations like database appends, curve renaming, etc.

Output Blocks

After you have performed an operation on your data, you will most likely want to save it out for future reference and work. This is accomplished via an output block. You can output items such as:

• Points
• Grids
• Logs
• Tops
• Well databases

A Simple Example: Points Math

Let’s imaging that we had a database of core points where the porosity was given in percent and we preferred it to be in decimal so that it is consistent with our petrophysical calculations. Instead of going back to Excel, performing the operation there, and then re-uploading the database we could make this simple fix quite quickly in flows

Remember from above that all flows basically require three building blocks: input, processing, and output. So we construct a flow with these three parts, as shown below.

The PointsInput is where we select our initial points database. PointsMath (which is what is active in the above) is where we perform the conversion and create the new column in our points database using the equation: PhiT_dec = Porosity/100. PointsOutput allows us to write out a new points database for future use.

This is a very minimal flow. We could expand on it in many ways. For example, we could add additional PointsMath blocks to perform additional calculations or we could stack a PointsToGrid and GridOutput onto it to then make a grid of the points values to give us a way to visually QC the results.

In Summary

The primary concept in Flows is that data is input, processed, and output. Each step of the flow utilizes a pre-defined building block. These blocks can be stack on top of one another to allow for increasingly complex operations to be performed. Flows both reduce the amount of manual interaction and button clicks required to generate work products and ensure consistency by creating a series of transparent steps along the way. Although there are numerous use cases, the most common operations can be summarized as:

• Points input, processing, and output
• Generating grids, performing operations on grids, and writing grids
• Log input, processing, and output