HueSpace Architecture & Technology
HueSpace is implemented in C++ and achieves its flexibility and high-performance through a combination of architectural features. You can extend your existing E&P applications with HueSpace and leverage the advantages of HueSpace, or if you develop a framework/application from scratch, you can benefit from significant reductions in development time in addition to all the other benefits of HueSpace.
The HueSpace Core Engine defines a scalable Object Model, which it then uses to implement an event-driven, multi-threaded dataflow architecture. It does this by efficiently managing the interaction between the Data, Compute, and Visualization systems to deliver exceptional application and system performance.
Core Engine responsibilities include tasks such as problem partitioning, I/O, and marshaling data across the various CPUs and GPUs connected to the host system. It handles all of this complexity so client software developers don't need to—they can instead focus on application functionality.
All HueSpace objects are defined in terms of its internal Object Model, which is then reflected in the API exposed to client applications. Internally, the Object Model provides a framework for object state management, serialization, and more. The Object Model also provides great flexibility to client applications, and it may be used to auto-generate components that are derivable from its contents and structure, including code documentation, code samples, graphical user interfaces (GUIs), etc.
The Object Model is specifically tailored for rapid development of robust, high-performance applications, and provides many tools to foster productivity—both for software developers using HueSpace and internal Hue development.
Two sets of APIs are available to developers:
- C++ (Windows/Linux)
- .NET (Windows)
- Java (Windows/Linux)
- C++ / OpenMP (CPU)
- C++ / CUDA (GPU)
Advanced processing capabilities are vital, but if the data management can't keep up, then application throughput and performance will suffer. HueSpace has variety of mechanisms to access external data & systems as well as highly optimized internal storage methods which incorporate real-time data compression.
"Out-of-the-box" data support:
- Volume data
- Seismic (prestack as well as poststack)
- Geometry data
- Geologic models
- Fully unstructured reservoir grids
- Interpretation data (horizons, faults, etc)
- Points, pointsets
- Lines, polylines
- Well data
HueSpace can access, or request, data in many ways.
- File importers (e.g. SEG-Y, Voxet, ZGY, etc) and exporters
- In-memory access
- Custom implementations / extensions
HueSpace data can be broadly divided into volume data (Volume Data Source - VDS) data and geometry data (Shape). Volume data is represented as multi-dimensional (2D to 6D) grid with up to 10 named channels of data, which can each have a different data format and mapping (direct or per trace) to the full volume. The VDS system has been optimized for extremely large (terabyte & petabyte-sized) data sets. Each VDS is multi-dimensional and data can be represented as e.g. a collection of "bricks", inlines, cross lines, and time slices, which are individually requested on-the-fly by the Core Engine, for compute, visualization, or direct client access. VDSs respond to requests asynchronously as data is produced or cached in from disk. The HueSpace data pipeline provides all required functionality for data marshalling, see separate section.
The HueSpace Shape type is used to define objects without completely regular data, whose geometry must be explicitly defined, at least in part. Most Shapes begin with a collection of vertex positions, with topological primitives built up from them. The exception is the height map shape, which is defined with regular spacing in two dimensions (usually XY), along with explicit height values for the third dimension (usually Z).
The HueSpace compute system is a framework for acceleration of computations based on Direct Acyclic Graph Model. A unique plug-in system allows researchers and developers to plug in geoscience algorithms and execute these on CPUs and GPUs in parallel. HueSpace handles data management, domain decomposition and partitioning. Computations can be entirely interactive, driven by the visualization or used for batch execution.
The compute system allows developers to achieve full parallelism from CPUs and GPUs. The compute pipeline is defined by directed acyclic graphs (DAG) that connect together data and operations. This system can be used in two ways:
- A "pull" model for data production that drives data through processing pipelines on demand; that is, only as it is needed for computation, visualization, or direct client access.
- A "push" model for data invalidation, made possible by dependency tracking in the processing pipelines.
A HueSpace object can be understood as a black-box that takes some set of parameters and data objects as its inputs, and produces a single output, to create a processing pipeline. For example, because an output of one object can be set as input of one or more objects, and because HueSpace prevents cyclical dependencies between objects, input-output relations form a directed acyclic graph (DAG).
Using HueSpace VDS plug-ins, you can quickly and easily implement your own algorithms for volume data that take advantage of all the power and efficiency of the HueSpace Compute system, which includes:
- Optimized data flow through the HueSpace demand-driven pipelines.
- Forced decomposition of algorithms for scalability.
- Dependency tracking between VDSs for invalidation, cycle prevention, and sane handling where algorithm data access pattern is a mismatch to input data production pattern.
- Interval analysis (e.g., only producing data where input volumes overlap).
- Transparently taking advantage of optimizations built into the HueSpace compute engine (e.g., identifying and managing new processors, etc.).
DIfferences from other vendor plug-in systems
Extensibility through a plug-in system is a very common approach, but no other plug-in system offers the complete core integration that HueSpace does.
For example, the plug-in system of an earth modeling application/platform really only allows you to add your capabilities to it and connect to its data. You do not have access to the host application's core capabilities and there is no coordination of resources between the host application and the plug-ins—this is not true integration, so it limits performance and efficiency of plug-ins.
In HueSpace, your plug-ins are integrated with and have access to all the capabilities of the Core Engine. Also, with HueSpace you can use plug-ins from other languages and platforms such as CUDA and others.
HueSpace has fast and powerful capabilities for visualization and user interactivity, so that geoscientists and engineers can iteratively probe and analyze huge data sets for better decisions. HueSpace renders volumes by rendering scalar or vector fields that are suspended in space and permeate the volume with varying values.
HueSpace offers out-of-the-box, state-of-the-art domain specific visualization of
- Seismic (prestack, poststack, velocities, attributes, and more)
- Interpretation data (horizons, faults, structural models, and more)
- Geologic models
- Reservoir models (fully unstructured)
- Well data
Additionally, a full API is available for custom visualizations.
HueSpace leads the industry in Shape rendering techniques for performance and quality and offers these capabilities particularly useful for oil and gas.
- Grids/Models: With the High Polycount module, the HueSpace data model and Rendering system provide support for rendering of and interaction with both structured and unstructured grids. Structured grids of hundreds of millions of cells can be rendered interactively. The HueSpace implementation of unstructured grids supports filtering and rendering on the basis of vertex, node, cell, and face properties. In contrast to competitor products, HueSpace unstructured grids can be edited interactively and do not rely on level-of-detail- approaches to achieve high interactivity. The amount of video memory used is only the amount of geometry in the visible shell.
- Wells: HueSpace supports rendering thousands of wells with logs using view-dependent level of detail (LOD) to give interactive performance. The Rendering system natively understands well path geometry data, which consists of Properties that define positions, measured depths, inclinations and azimuths. Each well path can then be rendered as one or more path log rendering segments that cover a given measured depth range along the well path. A path log rendering segment may be rendered using a number of different styles (3D tube, 2D strip, lines, etc..
- Annotations: Annotations—high quality text, charts, coordinate systems, markers—can be rendered with view-dependent size and orientation. 2D and 3D crossplots can be generated from any set of Properties.