Ocean for Petrel 2010.1 ReleaseNotes

Ocean for Petrel 2010.1

Release Notes

For Geoscientists and Software Developers

Published by Schlumberger Information Solutions, 5599 San Felipe, Houston Texas 77056

Copyright Notice Copyright © 2008-2010 Schlumberger. All rights reserved. No part of this manual may be reproduced, stored in a retrieval system, or translated in any form or by any means, electronic or mechanical, including photocopying and recording, without the prior written permission of Schlumberger Information Solutions, 5599 San Felipe, Suite 1700, Houston, TX 77056-2722. Disclaimer Use of this product is governed by the License Agreement. Schlumberger makes no warranties, express, implied, or statutory, with respect to the product described herein and disclaims without limitation any warranties of merchantability or fitness for a particular purpose. Schlumberger reserves the right to revise the information in this manual at any time without notice. Trademarks Petrel, Ocean and Ocean for Petrel are trademarks of Schlumberger. Microsoft® and Windows® are registered trademarks of Microsoft Corporation.

Table of Contents

Table of Contents .............................................................................................................. 3

What is Ocean for Petrel? ................................................................................................. 1

Ocean for Petrel Distribution ...................................................................................... 1 Product Licenses ....................................................................................................... 2 Ocean for Petrel Documentation ................................................................................ 2 Operating Environment .............................................................................................. 2 Petrel 2010.1 ............................................................................................................. 3 Ocean API Stability.................................................................................................... 3

Summary of Ocean Elements ........................................................................................... 4

Ocean Architecture .................................................................................................... 4 Ocean Core ............................................................................................................... 5 Ocean Services ......................................................................................................... 5 Ocean for Petrel ........................................................................................................ 7

New features in Ocean for Petrel 2010.1 .......................................................................... 9

Domain API ............................................................................................................... 9 Visualization ............................................................................................................ 17 Other ....................................................................................................................... 19 Other Changes ........................................................................................................ 20

Known Issues in Ocean for Petrel 2010.1 ...................................................................... 22

New features in Ocean for Petrel 2009.2 ........................................................................ 24

Domain API ............................................................................................................. 24 Visualization ............................................................................................................ 26 Other ....................................................................................................................... 26

New features in Ocean for Petrel 2009.1 ........................................................................ 27

Domain API ............................................................................................................. 27 UI and Look & Feel .................................................................................................. 36 Installation and Un-installation ................................................................................. 39

Appendix A: Migration to Simulation Results on the Petrel Results Tree ................... 40

Introduction ............................................................................................................. 40 Petrel Simulation Results......................................................................................... 40 Issues you may face ................................................................................................ 41

Appendix B: Use of IObservableElementEnumerable instead of

INotifyingEnumerable ................................................................................... 47

Appendix C: Third-party Components Deployed with Petrel: Avoiding Version Conflicts .............................................................................................................. 48

Contacting the Ocean Team ........................................................................................... 50

What is Ocean for Petrel?

Ocean is an open, proprietary application development framework targeted for E&P software. Ocean provides a powerful software development environment through the extensive API footprint, through the .NET based architecture and the associated .NET tools. The Petrel application is implemented on the Ocean framework, and is bundled with Ocean and Ocean for Petrel. Ocean for Petrel enables access to the key Petrel domain data types, as well as user interface and interaction features. It also enables extensions of Petrel, allowing addition of new domain data types with renderers, new windows, and new algorithmic and interactive processes. Ocean for Petrel offers the opportunity to extend, interoperate with, and re-use many of the features of Petrel in custom workflows. This expedites delivery of technological innovation and significantly reduces the time-to-market. This document contains the release notes of Ocean for Petrel 2010.1. The features that are new with this release are listed in the section New features in Ocean for Petrel 2010.1, page 9. For completeness, we have also integrated the summary of the news in the previous version over the one before that in the section New features in Ocean for Petrel 2009.2 (page24) and New features in Ocean for Petrel 2009.1 (page 27). A summary of known issues in Ocean for Petrel 2010.1 can be found on page 22.

Ocean for Petrel Distribution

All the elements necessary to develop Ocean for Petrel plug-ins are available through the Ocean Portal.

This consists mainly of:

Petrel 2010.1 (32bit and 64bit) and Ocean for Petrel 2010.1 API binaries

Demo Data Set (Gullfaks)

Ocean for Petrel 2010.1 SDK documentation integrated with Visual Studio and in stand-alone Ocean Help files (.chm).

Ocean for Petrel Wizards (Visual Studio 2008 Plug-in),

Sample Code and Reference Applications showing patterns for how to use the API


Product Licenses

Ocean is a licensed feature of Petrel. A developer‟s license is required to create new Ocean modules.

If you run Petrel 2010.1 with an Ocean for Petrel Developer‟s License, all licensable features of Petrel will be available. The license may be used for testing the interoperability of developed Ocean modules with Petrel. The enabled Petrel features may not be used for any other purpose, such as offer or perform commercial services and perform commercial or competitive analysis of Schlumberger‟s software. Furthermore, Petrel will configure itself to go into Developer‟s mode. This implies that the Petrel application shell and all hard-copies will be watermarked. Any projects saved whilst in Developer‟s mode will be tagged. Such projects will continue to be watermarked even if you load these into a fully featured version of Petrel at a later point.

Ocean for Petrel Documentation

The Ocean for Petrel help files (.chm and .HxS files) are generated from the source code at build time, and is the ultimate source of API documentation. Please refer to this for the definitive list of API features.

Operating Environment

Ocean for Petrel 2010.1 (3.2010.0.0) has been validated on Windows XP, Windows XP-64, and Windows Vista 64.

Ocean for Petrel 2010.1 is built on top of Ocean Core, version 3.2010.0.0, and on Ocean Services, version 3.2010.0.0.

The following 3rd party software is needed for developing Ocean for Petrel modules:

Windows XP SP2 (32 or 64 bits) or Windows Vista 64 operating system

Visual Studio 2008 Standard/Professional

.NET Framework 3.5

In addition OpenInventor (version 7.2) comes bundled with Ocean for Petrel 2010.1. Note that the OpenInventor (3D graphics) toolkit is an integral part of the Ocean for Petrel API. It is not separately licensed, but can only be used in the context of Ocean for Petrel. OpenInventor is provided by VSG (Visualization Sciences Group). If a stand-alone version of OpenInventor is required, you need to purchase a license directly from VSG. More information may be found at www.vsg3d.com.

http://www.vsg3d.com/


(See Appendix C for full list of third-party libraries deployed with Petrel.)

The Ocean for Petrel binaries were built with Visual Studio 2008 with Service Pack 1 installed. They target the .NET Framework version 3.5.

Petrel 2010.1 installs in parallel with earlier versions, so installers need to be updated for 2010.1 with the following environment variables:

- Ocean2010Home

- Petrel 2010.1 x32 = Ocean2010Home_win32

- Petrel 2010.1 x64 = Ocean2010Home_x64

The Petrel product codes for 2010.1 are:

- win32 = {D3723E01-35AB-4FD1-A496-07BB91C677D2}

- x64 = {05865F9E-7870-46F6-8E35-7168982452A1}

Petrel 2010.1

Please refer to Petrel 2010.1 documentation for information regarding the features shipped with Petrel 2010.1.

Ocean API Stability

We are committed to compile-time compatibility in the Ocean API for a minimum of two full yearly releases. This enables Ocean Applications to easily migrate to subsequent commercial versions of Ocean for Petrel. API‟s that will be replaced and phased out in the future are first deprecated for at least one full yearly release (included in the overall two years minimum stability). Deprecated APIs will be marked [Obsolete] in the SDK documentation and your compiler will give warnings if you continue to use them; but, we will continue to support and test them until they are removed.

There is an exception to this commitment, however: In some cases we expect changes in the underlying API implementation that may require changes in the API. In these cases we have tagged the API with the keyword [SubjectToChange] in the SDK documentation.

Ocean for Petrel 2010.1 is built on top of Petrel 2010.1.

Summary of Ocean Elements


Whilst the definitive documentation for API features is available in the help files, bundled in the Ocean for Petrel 2010.1 SDK installer, this section gives an overview of the fundamental building blocks of Ocean.

Ocean Architecture

The Ocean architecture is illustrated in Figure 1. The foundation of the overall system is Ocean Core. Ocean Core provides the essential features that are used by components at a higher level in the architecture, e.g. module lifecycle management and data source management.

The next level in the architectural hierarchy is the Ocean Services, comprising features such as coordinate transformations and unit conversions. Ocean Services can only have dependencies to Ocean Core or to other Services.

The third level introduces the product family, which in this case is Ocean for Petrel. It provides access to Petrel data types, the Petrel UI and Petrel workflow management.

Ocean Applications may use all of these API‟s, as illustrated in Figure 1.

Figure 1 Ocean API architecture

Ocean Core Ocean Core

Infrastructure: - Service locator - Messaging interface - Module lifecycle - Data source manager - Workspace - Event transaction mgr. - Licensing


Ocean Services Ocean Services

Application - independent services: - Domain object hosting - Unit system / conversions - Coordinate system /

conversions - Abstract data types - Geometry data types



Ocean Petrel Ocean Petrel

Product family: Application shell Domain objects Data sources / bulk access Processes Windows Toolbars Events Interaction


Application module Application module

Deployed as plug - in or extension module Deployed as plug - in or extension module

Public API Public API Public API

















Ocean Petrel Ocean Petrel



Ocean Petrel Ocean for Petrel



Application module Application module

Deployed as plug - in or extension module Deployed as plug - in or extension module Application module Application module

Deployed as plug - in or extension module Deployed as plug - in or extension module

Public API Public API Public API Public API Public API Public API Public API Public API Public API


Ocean Core

The Ocean Core consists of a set of basic principles and strategies, interfaces and implementations, all designed to guide the development of all Ocean applications such that they are all aligned to the same basic mold.

The Ocean Core APIs exposed are:

Module Lifecycle

Service Locator

Basic Logging

Data Source Manager and Data Source

Workspace

Event Transactions

The Ocean Core uses some of the Microsoft Enterprise Library‟s application blocks, namely Logging and Exception Handling. Logging is configurable.

Ocean Services

In this version of Ocean, six services are provided, namely Basics, Geometry, a Unit Service, Domain Object Hosting, Catalogs Service, and a Coordinate Service.

Basics

This service provides applications with basic types, representing concepts such as Extents, Indices and Index ranges, together with basic numerical algorithms.

Geometry

This service provides applications with fundamental definitions of geometry, e.g. basic types such as Angles, Points and Lines, Planes and Boxes.

Unit Service

The Unit Service consists of a catalog of unit measurements that is organized hierarchically. Unit measurements (e.g. “length”) are associated with units (e.g. “meters” or “feet”), also organized in a catalog. A third catalog keeps pairs of unit and unit measurements defining unit systems (e.g. “metric” or “imperial”). The unit conversion service provides converters between units


defined in the catalog to transform values.

In the Ocean domain API all data are delivered and received in base1 SI units. Note in particular that the base SI unit for seismic traveltime is seconds (not milliseconds) and for permeability is m2 (not Darcy or milli-Darcy; 1 Darcy = 0.9869233E-12m2).

Catalogs Service This service allows applications to look up log channels based on channel names or unit measurements.

Coordinates Service

This service provides the ability to create converters to transform data between coordinate reference systems.

As of 2010.1, the new Slb.Ocean.Coordinates service, based on the ESRI projection engine, is fully integrated with Petrel. The new service offers many new features, such as an API to create coordinate reference systems from “well known text” and APIs to navigate Petrel‟s coordinate system catalogs.2

The new service supports both the ESRI engine (integrated with Petrel) and the legacy Mentor engine. But, the Mentor engine is no longer loaded into Petrel by default.

The old Slb.Ocean.CoordinateSystems service works solely with the Mentor engine. This service is deprecated. The assembly is still available in the <petrel>\Public folder but it no longer appears in the “Additional reference” settings of the Ocean SDK Wizard. Again, the Mentor engine is no longer loaded by default into Petrel, so a plug-in that needs to use the old service must load the Mentor engine itself.

Domain Object Hosting

Ocean provides high-level data access to entities representing data, irrespective of the data source, called Domain Objects. The framework allows a developer to encapsulate application-specific validation or usage rules and hide location and complexities related to the data store.

Domain Objects typically act as intermediaries between a persistent data store and application code. They map from the data store representation to a format required (and desired) by applications. Their object model is often quite different from the model used by the underlying data store – they hide database implementation details and differences between database vendors from the application. Domain Objects do not require persistence

1 Base SI unit are defined as the SI unit, which has a scaling factor of 1.0 and an offset of 0.0. A

homogeneous unit system promotes cross-computation. Example: a product of two base SI units values yields a value in a base SI unit of a new measurement. 2 A new stand-alone component of Petrel – the Coordinate System Manager (CSM) – is available in

custom Petrel installations. This allows Petrel end-users to manage coordinates catalogs via a GUI.


– it is possible to have in-memory objects that contain business logic but do not save their state to a persistent data store.

Domain Object Hosting provides support for transaction management allowing the user to lock objects before they are modified and commit or abandon changes after modification. (Note that Ocean for Petrel native Domain Objects do not currently support abandoning transactions.)

Domain Object Hosting provides a notification event mechanism to which a module can subscribe. The object will then be notified when the object changes or is being changed. This means that domain object writers create new data types that follow the same usage pattern as the Petrel data exposed through the API.

Ocean for Petrel

Extending the Petrel User interface, the UI Infrastructure

The Petrel user interface (UI) uses MS WinForms. A set of API‟s have been exposed so that it can be tailored to the needs of new applications. Ocean for Petrel provides convenience classes in order to display messages, status information, and progress information. It also allows for examining the Petrel project state, and change and manage the different UI elements exposed from Petrel.

The UI Infrastructure API provides interfaces to access the various elements of the Petrel Explorer. You can add new objects to the trees, or customize existing ones. All tree interfaces provide current selection and selection change events, so the module can access the state of a particular tree or be notified whenever a change is produced (i.e. new object is select/deselected).

The content of display windows in Petrel are synchronized with objects and elements selected in the Petrel Explorer. The window manager interface handles the display window area by reporting its current state, notifying windows state changes with events, and managing collections of windows.

Ocean for Petrel provides APIs for custom rendering of new domain objects in selected 2D windows and in the 3D Petrel window, and for creating new windows. Objects rendered with 2D graphics use .NET Graphic Library (GDI+), while 3D rendering is done with OpenInventor.

Interoperating with Petrel data types, the Domain API

The Ocean for Petrel Domain API exposes and offers a number of data types and services to manage Petrel data. These services include the ability to navigate the data, to programmatically discover relationships between data types, to enable additions of new extension objects to existing Petrel objects, as well as a data event model. For a full overview of the current capabilities, please refer to the API documentation. A brief description of some of the data types follows:

PillarGrid: This API gives access to the 3D Grid model of Petrel. Grid geometry, properties, faults, horizons, segments and zones are accessed through this main class.


Shapes: provides support classes to manipulate points, polylines, and surfaces. The PointSet and Surfaces classes also provide access to properties associated with the shape.

Well: Borehole is the main class in this API, and gives access to Logs, Trajectory, Completions and Markers, from which it is possible to identify the relationships to zones, horizons and faults.

Seismic: SeismicCollection and InterpretationCollection act as the containers for seismic surveys and faults and horizons interpreted on seismic data, respectively. The API supports 2D and 3D seismic data and 2D and 3D interpretation. Traces can be accessed either through an enumerator or randomly from a relative positional index. In addition, it‟s possible to access sub-cubes of 3D data.

Simulation: provides interfaces to access reservoir simulation data in Petrel: Streamlines, Summary vectors, Grid results, Observed (production) data, simulation Cases, VFP tables, Black oil Fluid and saturation functions. ISimulationRoot acts as the container for all domain objects in the simulation domain. ISimulationManager and EclipseFormatSimulator allow to integrate a custom simulator into Petrel. The external simulator can access most static input data through the simulation Case, but it still needs to follow the Eclipse format for dynamic data and simulation output.

Petrel Processes and Workflows, the Workflow API

New processes can be created, and can be executed from Petrel‟s Process Diagram, or as part of a Petrel Workflow as defined in Petrel‟s Workflow Editor. The API essentially enables custom processes to take part seamlessly in Petrel‟s workflows. Furthermore; Samplers, Optimizers and Proxies can be implemented and integrated as algorithms in Petrel‟s uncertainty and optimization framework.

The process may have a UI auto-constructed by Ocean for Petrel from a set of arguments, but applications are also free to create their own custom UI‟s

New features in Ocean for Petrel 2010.1


Domain API

Reservoir Engineering – Plug-in Simulator

Ability to create cases for Native and Plugged-in Simulators

Namespace: Slb.Ocean.Petrel.Simulation

Create for WellKnownSimulator Create for an EclipseFormatSimulator

Note that Simulation Case was refactored and now only one simulator can belong to a Case. The case arguments/properties can be then set programmatically to define a simulation case.

Support for static reservoir data on simulation case


Get/Set on

Grid

Grid properties

Functions by regions: o Black oil fluid o Rock compaction o Rel. perm & capillary pressure

Development strategy

Grid export format

Various settings

Ability to query the simulator with Case as parameter

Namespace: Slb.Ocean.Petrel.DomainObject.Simulation

This enables an Ocean client to determine which simulator a Case object is associated with.


Full access (CRUD) to Rock Compaction Domain Object Namespace: Ocean.Petrel.DomainObject.Simulation.RockCompactionFunction

Ocean.Petrel.DomainObject.Simulation.RockPhysicsCollection

Create new rock compaction curves

Read the properties and records of existing curves

Access / assign to simulation case

Type Safe Eclipse Keyword API

Namespace: Slb.Ocean.Petrel.Simulation.EclipseKeywords

The enhanced keyword API features a C# code generated library for programmatic interaction with an ECLIPSE deck. Data is be accessed through classes, data records and typed data/value fields without the need to parse the deck file. It exposes more than 700 type safe read/write/update Keywords. This is a very useful API for convertor code for plugged-in simulators or for controlled manipulation of an ECLIPSE deck. ECLIPSE DECK Ocean Keyword

Access to Eclipse Native Keyword Editor


It is possible to allow the built in keyword editor to be used in the context of an EclipseFormatSimulator

Grid property results moved to results pane The simulation Grid (or 3D) results were moved from the models tree to the results tree in Petrel 2010.1. Hence Ocean has put in place an API to read the ”new” simulation results. One property, as we used to know it from the models tree, can now be visualized by selecting the property type, a simulation case and a timestep. The API follows the same ”paradigm” as Petrels visualization. This API now resembles the simulation results API for summary vectors. See appendix at the end of this document for more details about these changes.


Volume Calculation Results


Volume case and result type yields a volume result.

Results can be filtered to give partial volume results: a list of different filters of each type can be passed to the GetResult method to generate a partial result for the area specified by the filters.

Access proxy results for summary vectors and volume calculation This API reads summary vectors and volume calculation results that are generated by an Ocean plugged-in proxy. A proxy is a small mathematical model that tries to approximate a complex or large simulation. The example below shows how to read the first result (first reporting time step in the simulation) of all approximated proxy realizations, for all variables that are specified in the uncertainty workflow for a specific proxy summary result (for example: ”Water cut”) and result category (for example ”Field” or a certain well). Similar examples can be made for proxy volume calculation results, but without the time dimension."


Limited access to Development Strategy Create


The new API provides support for creating only a limited number of rules in a development strategy:

- A rule can only be defined for one well. - Rules are applied at timesteps. - A development strategy is created with a name, type and a list of timesteps (which

incorporates rules and wells)

A handful of rules can be applied at timesteps - Reporting frequency - History rate control - Maximum ratio - Minimum production rate - Pressure production control - Rate production control - Water cut - Water injection control - Well status

Development strategies can also be deleted.

Vertical Flow Performance (VFP) Tables


Ability to have read access to pressure drop model / Vertical flow performance (VFP) table.

Case Variable Filters


Plug-in can have access to case variable filters

Aquifer DO

Namespace: Slb.Ocean.Petrel.DomainObject.Simulation Access to Identifiable Aquifer DO and get/set on Simulation Case.

Depth Varying Completions

Namespace: Slb.Ocean.Petrel.DomainObject.Well.Completion

Ability to access depth-varying tubing (special/new type of WellPetrelCompletions).


Shapes Domain

Index based access to Surface attributes Namespace: Slb.Ocean.Petrel.DomainObject.Shapes.[Dictionary]SurfaceProperty.

SurfaceProperty and DictionarySurfaceProperty domain objects now have an indexer to get or set the surface property sample value for a given i,j position in the grid. These domain objects now also have a way to get and set many samples in one go with the Samples and AllSamples properties. These methods have been added for increased usability and performance.

Polyline Attributes Namespace: Slb.Ocean.Petrel.DomainObject.Shapes.Polyline

Slb.Ocean.Petrel.DomainObject.Shapes.[Dictionary]PolylineProperty

Slb.Ocean.Petrel.DomainObject.Shapes.PolylinePropertyCollection

Provide access to polyline attributes.

Trimesh Patches Enhancement

Namespace: Slb.Ocean.Petrel.DomainObject.Shapes.TriangleMesh

TriangleMesh mesh geometry as an enumeration of IndexedTriangleMesh rather than one single IndexedTriangleMesh.

Seismic Domain

Change in Attribute Generator

Namespace: Slb.Ocean.Petrel.Seismic

The Seismic attribute generator API was refactored and is now exposed as an abstract class, and not an interface anymore. The attribute generator provides a mechanism to trigger the recalculation of the attribute when a parameter has changed and provides a way to validate inputs.

Pre-Stack Seismic

Namespace: Slb.Ocean.Petrel.DomainObject.Prestack

A façade for generic prestack seismic datasets The Ocean API exposes a façade to access prestack data and to allow interoperability between different providers. Provider developers can implement their own backend through the backend API. Petrel 2010.1 comes with a simple 3D renderer and a default SEGY backend.

Seismic Vintage Domain Object

Namespace: Slb.Ocean.Petrel.DomainObject.Seismic

Read/write access to seismic vintages.


Set Default Seismic Data Location

Namespace: Slb.Ocean.Petrel.DomainObject.Seismic.SeismicCollection

It is programmatically possible set the default location for Seismic data

Create SeismicCube in Given Location

Namespace: Slb.Ocean.Petrel.DomainObject.Seismic.SeismicCollection

Possibility to create a SeismicCube outside the Petrel project directory.

(Dictionary)HorizonProperty Faster Indexer Namespace: Slb.Ocean.Petrel.DomainObject.Seismic.HorizonProperty2D and 3D

Property access for HorizonInterpretation 2D and 3D has been enhanced for better performance and usability. Indexers have been added and many samples can be get or set in one go.

Property Modeling

Redesign of the Geometrical Property Modeling API

Namespace: Slb.Ocean.Petrel.PropertyModeling

Re-design of existing API to follow the same patterns used by the 2010.1 SeismicAttribute API and new Petrophysical/Facies Property Modeling APIs

Kriging Algorithm

Namespace: Slb.Ocean.Petrel.PropertyModeling. WellKnownPetrophysicalModelingAlgorithms

Expose the Petrel Kriging algorithm as a workstep accessible through an Ocean API

Sequential Gaussian Simulation Algorithm

Namespace: Slb.Ocean.Petrel.PropertyModeling. WellKnownPetrophysicalModelingAlgorithms

Expose the Petrel Sequential Gaussian Simulation property population algorithm.

Sequential Indicator Simulation Algorithm Namespace: Slb.Ocean.Petrel.PropertyModeling.WellKnownFaciesAlgorithms

Expose the Petrel Sequential Indicator Simulation algorithm as a workstep.

Gaussian Random Function Algorithm

Namespace: Slb.Ocean.Petrel.PropertyModeling.WellKnownPetrophysicalModelingAlgorit

hms

Expose the Petrel Gaussian Random Function property modeling algorithm.

Indicator Kriging Algorithm Namespace:

Slb.Ocean.Petrel.PropertyModeling.WellKnownFaciesModelingAlgorithms

Expose the Petrel Indicator Kriging property modeling algorithm.


Probability Curve


Programmatically set or get probability curve values for dictionary properties.

Vertical Probability


Programmatically set or get vertical probability values for dictionary properties.

Discrete Statistics Namespace: Slb.Ocean.Petrel.DomainObject.PillarGrid.

DictionaryProperty.GetPropertyStatistics(...)

Slb.Ocean.Petrel.DomainObject.PillarGrid.

DictionaryPropertyStatisticsInfo

Access statistics of dictionary property – i.e., the statistics that are displayed on the Disc. stat. of the Settings dialog for a DictionaryProperty.

Plug-in architecture for facies property modeling

Namespace: Slb.Ocean.Petrel.PropertyModeling Allow to add your own algorithm for facies property modeling

Plug-in architecture for petrophysical property modeling


Allows to add your own algorithm for petrophysical property modeling

Structural Modeling

Initial API in 2010.1

Petrel 2010.1 comes with a new Structural Modeling module. Ocean exposes an initial API for its objects.

- Fault model domain object. - Horizon model domain object. - Zone model domain object.

Well domain

Get Active Check Shot

Namespace: Slb.Ocean.Petrel.DomainObject.Well.Borehole

Ability to get the current active CheckShot.


Spatial

Data Transfer in Native Coordinate Reference System (CRS)

Namespace: Slb.Ocean.Petrel.DomainObject.DataTransfer

Starting with Petrel 2010.1, Petrel objects will support transformation between different coordinate systems. Ocean provides new APIs to create and update Petrel Objects with data in Native Coordinate Reference System (different than the project CRS).

For example, the following code sample imports a PointSet from an external CRS: using Slb.Ocean.Petrel.DomainObject.DataTransfer.Shapes;

SpatialContext context =

new SpatialContext(externalCRS, SpatialUnitsPolicy.ContextOverridesSI);

PointSet ps = collection.CreatePointSet("Imported PS");

Point3[] points = new Point3[] { /* … */ }; // fill with points in external CRS

PointSetSpatialAccess pssa = new PointSetSpatialAccess(context); pssa.SetPoints(ps, points); // points are converted to project CRS

ATTENTION: The Project CRS is much more important starting in Petrel 2010.1. When opening a new project or an old project where the CRS has not been set, end-users must explicitly select either a CRS or NULL. For projects with a non-NULL CRS, Petrel now performs conversions when transferring spatial data via File Import/Export and RPT to a destination with a different CRS. For this reason, plug-ins should rarely (if ever) change the Project.CoordinateReferenceSystem property – and if they do, must ensure that the end-user is aware of the change. Most native Petrel data are now “spatially-enabled” (support spatial conversions on transfer). This includes, 2D seismic and interpretation, Well Data (head, deviation, markers, check shots …), Point data, Polygons, Faults, Satellite images, etc. However, a few native Petrel data types (notably 3-D Seismic) are not spatially-enabled in 2010.1. Likewise, there is no way for Ocean Custom Domain Objects to declare themselves as spatially-enabled. Non-spatially-enabled objects will not appear in the Reference Project Tool GUI when the primary and reference projects have different CRSs. A new API in 2011.1 will allow Ocean Custom Domain Objects to participate in such conversions. Likewise, the current plan is that native 3-D Seismic objects will be spatially-enabled in 2011.1, and, these objects will be added to the Ocean Spatial Data Transfer API.

FaultModel domain

Namespace: Slb.Ocean.Petrel.DomainObject.FaultModel

2010.1exposes the fault model object, which can be found in the models tree.


Pillar Grid

Slice intersection service Namespace: Slb.Ocean.Petrel.DomainObject.PillarGrid.IPillarGridIntersectionService Slb.Ocean.Petrel.DomainObject.PillarGrid.IHorizonIntersectionService

Service to calculate intersections between Grid/Horizon and facet.

Visualization

“New Window” Menu Entry Positioning

Namespace: Slb.Ocean.Petrel.UI.Tools

Ensure custom "New Window" menu items are positioned correctly in the Windows menu

Support of workflow variables in Worksteps with Custom User Interface

Namespace: Slb.Ocean.Petrel.Workflow

Workstep with custom user interface (UI) supporting workflow value and reference variables. A complete walkthrough with detailed examples is available in the online help.

Performance improvement of IToggleWindow Namespace: Slb.Ocean.Petrel.UI.ToggleWindow

Slb.Ocean.Petrel.UI.MapWindow

Slb.Ocean.Petrel.UI.WellSectionWindow

Slb.Ocean.Petrel.UI.InterSectionWindow

Significant performance improvement over the IToggleWindow interface. Plug-in window implementations should no longer implement the IToggleWindow Interface directly, and should instead inherit from the new ToggleWindow base class. Through this API, windows can specify the types of domain objects they can visualize, thus leading to fewer API calls and significant performance improvements when opening custom windows in large Petrel projects.

New classes for well-known Petrel windows

Namespace: Slb.Ocean.Petrel.UI

The interfaces representing the well-known Petrel windows, have been replaced with class representations (MapWindow, Window3D, IntersectionWindow, WellSectionWindow, FunctionWindow). In addition to the previous functionality, each of these windows now provides a VisibleObjects property, representing a collection of domain objects currently set to visible in the window.


Control of the Drawing Order in an IMapRenderer Namespace: Slb.Ocean.Petrel.UI

Support drawing order for custom objects in multi-pass rendering of the Petrel Map Window, Intersection Window, and WellSection Window.

Synchronized Redraw Of 3D Windows

Namespace: Slb.Ocean.Petrel.UI

A redraw-method to force an immediate and synchronized redraw of the 3D window in Petrel.

InteractiveCompletionTrackEditing Namespace: Slb.Ocean.Petrel.UI.WellSectionPickedPoints

Slb.Ocean.Petrel.UI.WellSectionRendererContext

In the Well Section Window, the mouse action-related methods overridden in custom window modes are invoked only when there are mouse actions on log tracks. These methods are not invoked when there are mouse actions on completions tracks. Ocean should be extended to cover interaction events also in the completions tracks

Windows are IIdentifiable

Namespace: Slb.Ocean.Petrel.UI Petrel windows are now IIdentifiable

Custom Advanced Toolbar Controls

Namespace: Slb.Ocean.Petrel.UI.Tools

The API provides a mechanism to add custom advanced control in toolbars.

Standard Petrel Windows.Forms Controls

Namespace: Slb.Ocean.Petrel.UI.Controls

This API exposes many of the Windows.Forms controls used in the Petrel GUI for use by plug-ins. Examples include, ColorPicker and ColorPickerPanel, ToolTip controls, etc.


Other

Time Playable Cross Plot And Function Domain Objects Namespace: Slb.Ocean.Petrel.DomainObject.Analysis.Function.Date Slb.Ocean.Petrel.DomainObject.Analysis.Function.UseDate Slb.Ocean.Petrel.DomainObject.Analysis.CorrelationData2D.Date Slb.Ocean.Petrel.DomainObject.Analysis.CorrelationData2D.UseDate

Correlation data (cross plot) and function domain objects are now time playable

Import Multi File

Namespace: Slb.Ocean.Petrel.IO It is now possible to import of multiple files

Ocean Store Licensing A white paper with examples is provided in the on line help of the SDK to describe how to implement licensing to participate in the Ocean Store.

PetrelLicenseCheck Namespace: Slb.Ocean.Petrel.Basics.PetrelLicenseAttribute

Slb.Ocean.Petrel.Basics.PetrelLicense

Slb.Ocean.Petrel.Licensing.LicensingService

Ocean-based modules can check if certain Petrel module licenses are available

DataManagement The framework now offers a way with which a plug-in effectively can add a data source to

the data source manager of both the primary and the reference project. This in turn means

that the custom data source no longer has to be Serializable. The mechanism to do that is

to make a class that derives from Slb.Ocean.Petrel.Data.DataSourceFactory

and to register it with Slb.Ocean.Petrel.PetrelSystem.

The framework invokes the GetDataSource() method of the factory for each project,

including the reference project. Data sources returned from the factory will be added to a

data source manager by the framework and should not be Serializable.

Please consult the (enhanced) Slb.Ocean.Petrel.Data Namespace documentation for

more information and code samples.


Other Changes

The well section window will be completely replaced in 2011.1. Well Section Window

related APIs are tagged obsolete in Ocean for Petrel 2010.1 , but there is no

alternate API at the moment. The new Window and the new API will be available in

pre-commercial snapshots of Ocean for Petrel 2011.1.

Petrel‟s color table behavior has changed in 2010.1. Ocean supports these changes (1) Custom Domain Objects now only have a color table tab in the Settings dialog if they support private color tables. (2) Custom Domain Object private color tables now have an opacity curve. (3) Inline documentation describing the old Petrel color table behavior was removed.

The Ocean for Petrel inline documentation is now built using Sandcastle. You should notice usability improvements.

Since Petrel 2009.2, the ESRI coordinate service engine is now a standard feature of

Petrel. ESRI coordinate systems are now available in the Coordinate reference

system selection dialog accessed through Project Settings -> Units and coordinates -

> Coordinates. This dialog now also allows entry of custom coordinate systems

expressed as well-known-text. To use the new ESRI engine features

programmatically, you must use the new Coordinates service delivered in the new

version of Ocean Core and Services – namespace Slb.Ocean.Coordinates.

The WorkspaceOpened event happens now later when project loads. This means

that the Ocean for Petrel API is now fully functional when the event is raised.

The fracture model has changed in Petrel 2010.1. The Create fracture network

process is creating fracture networks under Grid objects; the output object, called

“Fracture network” in the Models tree is a new container not yet accessible through

the Ocean API. Under this container, resides the Ocean FractureNetwork, called

"Discrete fractures", together with another set of fractures, "Implicit fractures", not

accessible from the Ocean API. The Ocean API still supports editing and creating

FractureNetworks under ModelCollection and Project, but only support editing

FractureNetworks under Grid (with restrictions, see Petrel documentation , fractures

sets are read-only, discrete fractures cannot be deleted directly) .

The generated Installer Project no longes uses Custom Actions to register and handle the modules in the setup package. Instead there is a new InstallModules.xml file generated into the project, which handles everything which is related to the module registration, probing paths, trusts, etc. For more details on this, please see the UsingTheWizard.pdf installed by the SDK.

The Ocean Wizard no longer supports Visual Studio 2005. Only Visual Studio 2008.

Known Issues in Ocean for Petrel 2010.1

The OceanSDK installer now installs the Ocean for Petrel controls to the Visual Studio control Toolbox.


Known Issues in Ocean for Petrel 2010.1 In all Petrel versions up to and including Petrel 2009.2, the WorkspaceOpened

event of the Slb.Ocean.DataManager class was raised before Petrel was actually

finished loading and converting (old) project data. This did lead to a number of issues, one of them being that some domain data obtained through the API in a handler of this event was incorrect and that unit conversions could fail. In Petrel 2010, this has been fixed; the event is now raised later in time. But this also means that the framework now can call into a plug-in before this event has been raised. A plug-in which initializes its internal state in an handler of this event might fail to function if this state is needed during these early calls from the. Typically these are Process.OnActivateCore, IOpenInventorFactory.Create,

IPresentation.Text and

IObservableElementEnumerable.GetEnumerator. For a plug-in which has its

own custom data source, a workaround for this can be to move the initialization code

to the implementation of IDataSource.Open or IDataSource.Resolve. The

Ocean for Petrel API is functional in the latter, but not in the first.

In all Petrel versions up to and including Petrel 2009.2 an Ocean module could add a

non serializable custom data source (IDataSource instance) to the global data

source manager in a handler of the WorkspaceOpened event and add

Identifyable objects from that data source to Petrel. The droids of these objects

then were correctly resolved when the project was reloaded. However this made it impossible to resolve droids in a reference project and adding a non serializable data source in this way must be considered a bug. With Petrel 2010 it is no longer possible to both add a non serializable data source

in a handler of the WorkspaceOpened event and have the droids be resolved at the

same time. With Petrel 2010 data sources should be added to the system indirectly by

registering a DataSourceFactory. A data source which is added this way is

opened early and this restricts what can be done in the IDataSource.Open.

Petrel doesn‟t support License Borrowing, and there will be issues starting Petrel with expired borrowed plug-in licenses. It is therefore strongly discouraged to do License Borrowing for plug-ins.

Custom Domain Objects cannot be copied (via copy-paste) to a HorizonInterpretation.

If the PillarGridPlayer toolbar is visible and the Petrel end user activates an Ocean process that does not explicitly set the toolbar to visible, the toolbar will disappear until another process is activated.

The Ocean Core and Services Coordinates service erroneously selects a datum transform (sometimes randomly from among several compatible transforms) when asked to create a conversion operation between two late bound CRSs based on different datums. In this case, the service should refuse to create an operation unless the caller explicitly specifies the datum transform. The service will be changed in the


2011 timeframe to behave that way. To protect against this future behavior change, plug-ins should always specify the transform explicitly.

Petrel ships with a Coordinate System Catalog that includes CRSs from several authorities: EPSG, ESRI, SIS, and SLB. When Petrel is started, only the EPSG and ERSI CRSs are loaded into the Coordinates service by default. The SIS and SLB systems are only loaded when the Petrel end-user opens the CRS selection dialog (in Project Settings). If a plug-in requests a CRS using a SIS or SLB code before the end-user has opened the selection dialog, the request will fail – even if it exists in the catalog. The workaround is for the developer to find the WKT for the desired SLB or SIS CRS using the Coordinate System Manager utility and request the CRS by WKT rather than by code.

It is not possible to use a custom FileFormat to import/export spatially-enabled native Petrel domain objects to/from a project with a non-NULL CRS.

The property SegmentationSpec.MaxInclinationChange had incorrect unit conversion prior to 2010.1. The behavior of this API has changed to correctly use radians (SI). Please make sure this change is handled correctly in your application.

Error! Reference source not found.


Domain API


Support to copy custom simulation cases Namespace: Slb.Ocean.Petrel.Simulation.EclipseFormatSimulator.CaseManipulationH

andler.PostCopy

The new API provides a method for a post copy operation that allows custom simulation cases to do the necessary work to allow their simulation case to participate in copy and paste workflows.

Access to the simulation case version Namespace: Slb.Ocean.Petrel.Simulation.ISimulationManager.GetSimulatorVersion

The new API provides access to the simulator version field of the simulation case.

Support to modify the restart time of a simulation case Namespace: Slb.Ocean.Petrel.Simulation.EclipseFormatSimulator.CaseManipulationH

andler.GetRestartDates

The new API provides a method that is called during the restart case insert process. The plug-in simulator can then manipulate the expected restart time steps based on the original one.

Support to rename a simulation case Namespace: Slb.Ocean.Petrel.Simulation.EclipseFormatSimulator.CaseManipulationH

andler.PostRename


The new API provides a method for a post rename operation that allows custom simulation cases to do the necessary work to allow their simulation case to be renamed. Please note that this method will only be called on a successful Petrel Case rename.

Seismic Domain

Updates to Fault Interpretation Polyline Access

Namespace: Slb.Ocean.Petrel.DomainObject.Seismic.FaultInterpretation

The API has been updated to allow API users to access fault interpretation polylines with or without seismic context. The API has been updated to as follows: Obsoleted Methods:

public void SetPolylines(IEnumerable<Polyline3> polylines)

public IEnumerable<Polyline3> GetPolylines(SeismicLine2D

seismicLine)

public IEnumerable<Polyline3> GetPolylines(SeismicCube

seismicCube)

public void SetPolylines(SeismicLine2D seismicLine,

IEnumerable<Polyline3> polylines)

public void SetPolylines(SeismicCube seismicCube,

IEnumerable<Polyline3> polylines)

Note: The above methods are deprecated and not fixed (see SMR:2358805) New Methods

public void SetPolylines (

IEnumerable<FaultInterpretationPolyline> polylines)

public IEnumerable <FaultInterpretationPolyline >

GetPolylines()

Users will need to use the new API to edit and access the seismic context of the fault interpretation, meaning that Ocean plug-ins need to be modified for 2009.2.

Pillar Grid

Contacts Visible in Petrel Editor

Namespace: Slb.Ocean.Petrel.DomainObject.PillarGrid.Contact

This API provides the following capabilities: 1. Ability to create Contact via Ocean for Petrel API and set a flag on the Contact to

indicate if all zones or all segments have the same constant value. 2. Ability to create a Contact via Ocean for Petrel and set a constant value on the

Contact [SetZValue(Zone, Segment, double) or SetZValue(Zone,

double)] and to view/edit this contact in the 'make contact' process. (Also need

SetZValue(Segment, double), SetZValue(double))

3. A behavior such that after a creation of Contact via Ocean API and setting the value

on Contact via the fine level API [SetZValue(Zone, Index2, Corner,

double)], this 'fine level' contact cannot be viewed/edited by the 'make contact'

process, and if I apply this process on its parent ContactSet, this Contact will lost.


Visualization

OpenInventor Node interaction detail

Namespace: Slb.Ocean.Petrel.UI.Window3DPickedPoint.PickDetails

Ocean provides an OpenInventor SoPickedPoint object describing the pick in the scenegraph. This object can be queried for more detailed pick information such as the SoDetail of the picked node in the OpenInventor scenegraph.

Other

New Command Line Options (-exec) Petrel's command line now has a "-exec" option to execute a custom method requiring no user interaction. All Ocean API can be used in "-exec" mode. Particularly, some API can only be used when the "-exec" option is specified in the command line. These API exclusive to the "-exec" mode are:

- PetrelProject.NewProject

- PetrelProject.LoadProject

- PetrelProject.SaveProject

- PetrelProject.SaveProjectAs

Typical "-exec" option usages include: - using Petrel data, - performing computations, - fetching data from other sources, - storing data in Petrel. Syntax of the "-exec" option: petrel.exe -exec assemblyQualifiedTypeName methodName [projectName]

The command line parameters are: - assemblyQualifiedTypeName: Assembly qualified name of the class containing the method to be executed. - methodName: Name of the custom method to be executed. - projectName: Name of the project to be opened. This parameter is optional. BUT the "-licensePackage" option should be specified at the same time. Otherwise, the custom method can only execute if there is user interaction to manually select the license package. Please refer to the Petrel.chm help manual for more information about other Petrel command line options, and the white paper “Petrel Command Line Exec Option” in the Ocean for Petrel chm.

http://msdn.microsoft.com/en-us/library/system.type.assemblyqualifiedname.aspx



Domain API


UI extensibility for simulator plug-ins Namespace: Slb.Ocean.Petrel.Simulation.SimulatorPageUIFactory, Slb.Ocean.Petrel.Simulation.SimulatorPageLogic

MySimPage : SimulatorPageLogic<TArgPack>

PageList.Add(new MySimPage())

MySimPageFact : SimulatorPageUIFactory<TArgPack>

CoreSystem.Services.AddService(typeof(TArgPack),

MySimPageFact.ServiceType,

new MySimPageFact())

For more detailed information, please consult section “Error! Reference source not found.” on page Error! Bookmark not defined..

Programmatically run a simulation case Namespace: Slb.Ocean.Petrel.Simulation. This feature allows to programmatically execute the same operations a Petrel user can trigger by clicking the Run button on the Define simulation case process dialog. How to use the API:

1. Define the class that will run simulation 2. Derive custom CaseRunnerMonitor class. (Optional. But necessary when user wants

to capture the finish events from Simulation process) 3. Get an instance of CaseRunner through PetrelSystem.SimulationManager, and run

the Simulation.

Simulation.CaseRunner.Export()

Simulation.CaseRunner.Run()

Simulation.CaseRunnerMonitor.RunAborted()

Simulation.CaseRunnerMonitor.RunCompleted()

New property to access exported sections of an Eclipse Deck

The EclipseFormatSimulator provides a new property RequestedExportSections to

specify which sections of the Deck need to be exported when Petrel does the export.


Interface to use keywords of an Eclipse Deck Namespace: Slb.Ocean.Petrel.Simulation The API allows accessing the individual sections of an Eclipse deck such as GRID, SCHEDULE etc. to add, insert or remove keywords from each section. It is possible to get an EclipseKeywordEditor from ISimulationManager by passing the relevent Simulation domain object. Then the KeywordDeckSections object allows access to a desired section. The API provides access to a Keywords IEnumerable and CreateKeyword() methods to create and edit keywords.

EclipseKeywordEditor

EclipseKeywordSection.CreateKeyword(…)

EclipseKeywordSection[i]

EclipseKeyword.Name – EclipseKeyword.FreeText

Access to segmentation borehole‟s flow paths Namespace: Slb.Ocean.Petrel.DomainObject.Simulation.SimulationRoot The multi-segmented well model in Petrel and ECLIPSE divides the whole well bore into segments with different physical properties to allow ECLIPSE to accurately model the fluid physics throughout the well bore. The SegmentationSpec object represents the segmentation of a borehole‟s flow paths. The API allows creating and accessing SegmentationSpec.

SimulationRoot.SegmentationSpecCollection

Simulation.SegmentationSpec.Spec

.SegmentLength

.UseFriction

Simulation case $variables ISimulationManager.GetCaseVariables(…)

Liners (completions type) Namespace: Slb.Ocean.Petrel.DomainObject.Well.Completion The type LinerString is added to the Completions API and can be created via Borehole.Completions.CreateLinerString. In previous versions liners had to be modeled as CasingString instances with the StartMD set greater than zero, and as such would show in the Petrel UI with the casing icon rather than the liner icon.


Uncertainty Workflow API Namespace: Slb.Ocean.Petrel.Uncertainty The Uncertainty API enables extensibility of the Petrel Uncertainty process. This is done by registering user-defined algorithms via PetrelSystem.UncertaintyManager. The benefit is that the algorithm may focus directly on the parameter tuning of the optimization loop, and can leave to Petrel the logistics and machinery of updating models, re-gridding, creating simulation decks and running the simulation. For more detailed information, please consult section “Error! Reference source not found.” on page Error! Bookmark not defined.. Distribution functions A distribution exposes an operation over an argument package containing all the distribution settings. Custom distribution functions

MyDistr : Distribution<TArgPack>.NextSample(…)

Sampler Provides parameter values to the Uncertainty process. This can be either random values (e.g. Monte-Carlo sampling) or following some sort of methodology (e.g. experimental design). Custom samplers

MySampler : Sampler<TArgPack>.Validate(…)

.CreateExecutor(…)

SamplerExecutor.SampleValues(k,output)

Proxy (Emulator) Computes an approximation to simulation output. Usually, an emulator is calibrated with a small number of actual simulations before it can provide approximated results (e.g. neural network). Custom simulator proxies

MyProxy : Proxy<TArgPack>.CreateExecutor(…) etc.

ProxyExecutor.Evaluate(input,output)

Optimizer Finds an optimal set of control parameters of a given objective. This usually involves evaluation of the simulator for a large number of input configurations

Custom optimizers MyOpt : Optimizer<TArgPack>.CreateExecutor(…) etc.

OptimizerExecutor.SampleValues(k,output)

OptimizerExecutor.ReportOptimums(…)


Data Analysis

Selection Filters Namespace: Slb.Ocean.Petrel.DomainObject.Analysis A LogicalFilter is defined by an association of logical operation on the result of other filters. A PropertyVersionFilter is defined by an association of regions in the property space [FirstProperty, SecondProperty], each region including or excluding a range of values (1D filters) or a set of points (2D filters).

The DataSelectionFilterRoot allows getting PropertyVersionFilter and LogicalFilter objects in the context of a Project.A DataSelectionFilterRegion is defining a set of values or points to be included by a PropertyVersionFilter object. SelectionFilterRegion can define a 2D or 1D region: a 2D region will be represented by a polygon, whereas a 1D region will be a value range with a lower and upper limit.

1D property (selection) filters DataSelectionFilterRoot.CreatePropertyDataFilter()

PropertyDataFilter1D.Add/Get/Set/RemoveRegion()

PropertyDataFilter1D.Property

PropertyDataFilter1D.IsIncluded(...)

myWindow.SetVisible(PropertyDataFilter1D/2D)

2D property (selection) filters – extras/special wrt. 1D DataSelectionFilterRoot.CreatePropertyDataFilter()

PropertyDataFilter2D.SecondProperty

Logical filters not=new LogicalDataFilterNot(f1);

and=new LogicalDataFilterAnd(f2,f3);

comb=new LogicalDataFilterOr(and,not);

DataSelectionFilterRoot

.CreateLogicalDataFilter(comb)

Variogram Domain Object Namespace: Slb.Ocean.Petrel.DomainObject.PillarGrid A variogram describes the natural variation in a property (surface property, model property, etc.) and is used as input to both discrete and continuous property modeling. The Ocean for Petrel API exposes the Petrel model variogram defined in the Property modelling -> Data Analysis process, from the Variograms tab. The PillarGrid.DataAnalysis is used to create and get PillarGrid.ModelVariogram and PillarGrid.DictionaryModelVariogram instances. In addition to a continuous property, a model variogram instance will have associations with a PillarGrid.Zone or with all zones. In addition to a dictionary property, a DictionaryModelVariogram instance will have associations with one or all PillarGrid.Zone and facies.

DataAnalysis.Create/Get…(…)

Grid.DataAnalysis.Create/Get…(…)

PillarGrid.ModelVariogram .Dip

.MajorRange

.Nugget


etc.

PillarGrid.DictionaryModelVariogram …

Correlation data (cross plot) Domain Object Namespace: Slb.Ocean.Petrel.DomainObject.Analysis Ocean for Petrel 2009.2 exposes the cross plot domain object, used in property modeling in Petrel. A crossplot domain object describes a bivariate distribution. The bivariate distribution values are contained in a collection of Point2 values.

CorrelationData2D[k].X/Y

Function Domain Object Namespace: Slb.Ocean.Petrel.DomainObject. Analysis Ocean for Petrel 2009.2 exposes the function domain object, used in property modeling in Petrel. This requirement relates to the function domain object, not the function window/renderer. A Function domain object describes a linear regression function. The data are contained in a collection of Point2 values.

Function[k].X/Y

LaunchDataAnalysisDialog Namespace: Slb.Ocean.Petrel.PetrelSystem.ProcessDiagram Programmatically launch the data analysis tool / dialog of Petrel

ProcessDiagram.ShowDataAnalysisProcess(…)


Seismic Performance

Improved bulk access speed Namespace: Slb.Ocean.Petrel.DomainObject.Seismic Performances of access to seismic data have been improved. Both ISubCube and ITrace access have been optimized and should now be limited by the disk access. No API change. On a default developer machine, initial measurements show the following performance improvements: ~28MB/s to 180MB/s for 32-bit data sample by sample access (fully cached) ~24MB/s to 120MB/s for 8-bit data sample by sample access (fully cached, slower due to byte to float conversion) ~60MB/s to 260MB/s for 32-bit data using the ToArray () (fully cached) ~60MB/s to 270MB/s for 8-bit data sample by sample access (fully cached) For large cubes, the machine yields a sustained throughput of 70MB/s or so from disk. (Note that these numbers are measured for a best-case scenario, where the cube is accessed in the most efficient way: access has been designed to minimize cache misses, looping through all samples in each 64x64x64 brick in the zgy file).

Regular Height Fields Surface Performance Improvement Namespace: DomainObject.Shapes

A new method: SurfaceProperty.SetRecordValues(…)has been implemented to set

Surface properties in a bulk fashion. Performances using this method are much better than the random access.

Multi-Threading - Attribute computation Namespace: Slb.Ocean.Petrel.SeismicAttribute This requirement was already available in Ocean for Petrel 2008.1 with the new IAttributeVersion2 interface. It now supports multiple seismic cubes and additional testing has been provided for 2009.2. The interface IAttributeVersion2 inherits Iattribute, it influences performance, threading, API access and persistence. Performance:

The generator's Calculate method is now called with subcubes tailored to what is required to fulfill the user interaction that caused the computation. For example visualization of a horizontal slice triggers thin subcubes to be passed for calculation. The original IAttribute always got called with sub cubes of one seismic trace.

IAttributeVersion2 uses a more optimized code path to provide improvement in computation speed of around an order of magnitude for simple algorithms. With complex algorithm the performance improvement might not be as noticeable.

IAttributeVersion2 implementations with large computational footprints run faster because they are called fewer times than before (with larger subcubes).

Threading and API access:

IAttributeVersion2 computes in one of two thread modes: SingleWorkerThread or MultipleWorkerThreads.


SingleWorkerThread means computation is carried out in one single thread which is not the main (UI) thread. Only a small cross-thread-safe subset of the Ocean for Petrel API is available, only the „reading‟ part of the Domain API can be used. Any code path which changes data up in the GUI (forms) technology will throw an exception as it is considered an illegal cross thread operation.

MultipleWorkerThreads means the calculate method is called in parallel on several threads (possibly one to four). The generator implementation must use only thread safe (.Net) components in its implementation, and cannot use any Ocean resources (like domain objects).

Persistence

IAttributeVersion2 can optionally be persisted (if it is serializable). This will in effect make it a singleton and just its identity will be persisted. Any state should be persisted with the argument package. Note that it is recommended to implement your own serialization logic rather than using .NET Serialization. The generator of a IAttributeVersion2 is *not* persisted. This was mandatory with the old version.

Multi-Threading - Generic seismic bulk access Namespace: Slb.Ocean.Petrel.DomainObject.Seismic

The IAsyncSubCube GetAsyncSubCube(…) method provides random asynchronous

read and write access to the data. The implementation is not thread safe, but multiple sub cubes can be processed in parallel in separate threads. The GetAsyncSubCube can only be called in the main thread, but the returned handle can be used in any thread. Instances of ISubCube must not be used in the main thread when there are active IAsyncSubCube instances. In the main thread:

IAsyncSubCube subCubeIn = cubeIn.GetAsyncSubCube(...);

IAsyncSubCube subCubeOut = cubeOut.GetAsyncSubCube(...);

In a worker thread: foreach (Index3 index in subCubeOut)

{

subCubeOut[index] = subCubeIn[index];

}

subCubeIn.Dispose();

subCubeOut.Dispose();


Seismic Domain

Fault (Ant Tracking) patches

Namespace: Ocean.Petrel.DomainObject.Seismic.FaultPatchSet FaultPatchSet represents a set of fault surfaces, whose geometry is a set of indexed triangles, with properties attached to each fault. A fault patch is an individual Fault in a FaultPatchSet object. This fault is usually computed from seismic data and requires a seismic survey definition on creation, vertices are snapped to the nearest index position.

Fracture patches

Namespace: Ocean.Petrel.DomainObject.Shapes.FractureNetwork FractureNetwork represents a Petrel fracture network with properties. Individual fractures are represented by the FracturePatch object, and can be accessed through FractureNetwork.FracturePatches and FractureNetwork.PatchAtIndex. A FracturePatch is an individual Fracture in a FractureNetwork object. The fracture can be expressed as a triangulated surface, through IndexedTriangleMesh.

Multiple input seismic attributes Namespace: Slb.Ocean.Petrel.SeismicAttribute.IAttribute Ocean for Petrel now supports multiple seismic input cubes. The API is unchanged, but now

the Slb.Ocean.Petrel.SeismicAttribute.IAttribute.NumInputs

can be greater than 1.

Data Management

Reference project tool awareness and Copy/Paste of Custom domain objects Namespace: Slb.Ocean.Petrel.Basics.ICopyable Slb.Ocean.Petrel.Basics.ISyncable The API allows custom domain objects or extensions to native domain objects to do the roundtrip between an opened Petrel project and a reference project using the Reference Project Tool and to participate in copy-paste actions in Petrel, including cascading copies.

ICopyable to handle duplication

IPropertyComparable to provide object-to-object

comparisons of e.g. identity or version

IObservableElementCollection,

IObservableElementCollectionFactory,

IObservableElementEnumerable,

IObservableElementEnumerableFactory

to allow handling of children items in a custom domain object

Custom Extensions can be managed using the IO.AttributeContainer

IO.ICustomAttributeService


SurfaceAsIExtensionSource Namespace: Slb.Ocean.Petrel.DomainObject.Shapes RegularHeightFieldSurface implements IExtensionSource, so it can be extended with custom extensions.

WellMarkersIIdentifiable Namespace: Slb.Ocean.Petrel.DomainObject.Well.Marker Well markers are now IIdentifiable enabling data management solutions.

Data Fidelity: Attributes of Petrel Domain Objects The API now provides access to native (WellKnown) attributes – attributes with ”special meaning”. Each attribute is identifiable and String, Boolean and DateTime properties are now supported.

Surfaces/horizons Surface.GetWellKnownProperty()

Surface.Properties

WellKnownSurfacePropertyTypes.Velocity etc.

SurfaceProperty.IsGeometryProperty

HorizonProperty2D/3D.IsGeometryProperty

Point sets PointSet.Create/GetWellKnown[Dictionary]Property()

WellKnownPointSetPropertyTypes.DipAzimuth etc.

PointProperty.IsGeometryProperty

Boreholes BoreholePropertyCollection

Borehole.PropertyAccess.Get/SetPropertyValue()

WellKnownBoreholePropertyTypes.SpudDate etc.

Point well data General: WellPointPropertyCollection

Well markers

Marker.PropertyAccess.Get/SetPropertyValue()

WellKnownMarkerPropertyTypes.Interpreter etc.

Checkshots

WellKnownBoreholePropertyTypes.TWTPicked etc.

CheckShot.GetPropertyAccess()

Point well logs

PointWellLog.GetPropertyAccess()

WellKnownPointWellLogPropertyTypes.MD etc.


UI and Look & Feel

Interaction Events Extension Namespace: Slb.Ocean.Petrel.UI.WindowMode Provides extensions in the interaction events to cater for keyboard events.

WindowMode.OnKeyDown()

WindowMode.OnKeyUp()

Toolbars and Tools associated with a Process Namespace: Slb.Ocean.Petrel.Workflow.Process,

Slb.Ocean.Petrel.UI.Tools.WellKnownTools The new ToolbarsCore and ToolsCore properties are called by the framework whenever it needs to know respectively the list of PetrelToolbars and PetrelTools associated with a Process. An implementation of this method typically returns different PetrelToolbar or PetrelTool configurations based on e.g. the active IToggleWindow.

UI.WellknownWindowModes

Process.Tool[bar]sCore

Process Insensitive Namespace: Slb.Ocean.Petrel.Workflow.Process Enables Ocean for Petrel processes to be set as disabled (grayed out) if e.g. a license can not be obtained or if the required input data isn‟t present.

Process.Enabled = true/false

Process.EnabledChanged/OnEnabledChanged() event

Custom windows tree extensions for Petrel windows Namespace: Slb.Ocean.Petrel.Basics.IExtensionsSource Native Petrel window interfaces (IWindow3D, IMapWindow, IWellSectionWindow, IIntersectionWindow, IFunctionWindow) now extend Slb.Ocean.Petrel.Basics.IExtensionsSource, giving them an Extensions property. Like other native domain objects, this allows Ocean for Petrel applications to add and remove custom domain objects as children of the trees in the Petrel tree hierarchy.

AutoLegendProgrammaticShowHide Namespace: Slb.Ocean.Petrel.UI.IWindow3D Support for programmatically showing/hiding Petrel‟s AutoLegend

bool IWindow3D.ShowAutoLegend


Cursor tracking independent of IToggleWindow, with proper domain handling Namespace: Slb.Ocean.Petrel.UI.IWorldCursor The new World Cursor API allows applications to participate in cursor tracking without explicitly needing to implement a custom toggle window.

UI.IWorldCursor

Petrel Task Manager Namespace: Slb.Ocean.Petrel The PetrelLogger.NewAsyncProgress(..) allows displaying progress of separate-threaded processes in the Petrel task manager.

using (IProgress pr = PetrelLogger.NewAsyncProgress(

"test", ProgressType.Cancelable))

{

for (int i = 0; i < 100; i++)

{

pr.ProgressStatus = i;

}

}

Launching Dialogs and Controlling Visual Content Namespace: Slb.Ocean.Petrel.UI Programmatically launch settings dialogs

UI.DialogBuilder.Show/HideSettings(obj,...)

UI.DialogBuilder.ActivateSettingsTab(obj,...)

Namespace: Slb.Ocean.Petrel.IO It is now possible to programmatically launch an import or export dialog.

IFileFormatCollection.ShowExportDialog(fmt,path,...)

IFileFormatCollection.ShowImportDialog(fmt,path,...)

Select active explorer tree Namespace: Slb.Ocean.Petrel.PetrelProject Gets or sets the active tree in Petrel explorer. PetrelProject.ActiveTree = PetrelProject.Models


Expand/collapse branches in the explorer trees Namespace: Slb.Ocean.Petrel.PetrelProject Enable programmatic expansion of data tree nodes PetrelProject.TreeOperations.SetExpanded(obj,

TreeElementState.Expanded)

Workflow editor folders

Namespace: Slb.Ocean.Petrel.Workflow.IWorkflowEditor Provides a mechanism to place a workstep under a given workstep folder (in the workflow editor). IWorkflowEditor.Add(wkstp,wkstpGroup)

Provides a mechanism to add new folders for worksteps in the workflow editor Processes.FindOrCreateWorkstepGroup("My new folder")

Infragistics dependencies have been removed Namespace: Slb.Ocean.Petrel.PetrelSystem, Slb.Ocean.Petrel.UI.Tools.IToolService Infragistics dependencies have been removed from the Ocean for Petrel API. A new PetrelSystem.ToolService can be used to

Create new toolbars/access native Petrel toolbars

Create new menus/access native Petrel menus

Register context menu handlers

Add tools to toolbars, menus

Template Hierarchy Namespace: Slb.Ocean.Petrel.UI.DictionaryColorTableEntry The Slb.Ocean.Petrel.UI.DictionaryColorTableEntry class now has a Parent property to support hierarchies.

Retrieving Measurement for its name NameSpace: Ocean.Petrel.PetrelUnitSystem a new method has been added to get the measurement from a measurement name: public static IUnitMeasurement GetUnitMeasurement(string

unitMeasurementName)


Other Development

A document describing Module Deployment Best Practices has been released recently and is available from the Ocean Portal: Developer Center > Best Practices > Module Deployment.

The Ocean for Petrel 2009.1 SDK now installs even if a previous version (Ocean for Petrel 2008.1 SDK) is installed. It allows keeping the documentation of previous Ocean for Petrel SDK releases.

64bits support: The Ocean for Petrel 2009.1 SDK supports Petrel 2009.1 x32 on Windows XP32 and XP64, and Petrel 2009.1 x64 on Windows Vista 64

Ocean for Petrel Wizards The wizards now install on top of Visual Studio 2005 and Visual Studio 2008. It is now possible to create projects targeting Petrel 2008 or Petrel 2009 (if installed on the computer). The installer wizard allows choosing the targeted version of Petrel: Petrel 2008, Petrel 2009 x32 or Petrel 2009 64 bits (providing warnings in case of incompatibilities).

Installation and Un-installation

To improve the Petrel awareness of plug-ins installed we have developed new Ocean for Petrel plug-in install and uninstall procedures. This is mainly to help the Petrel and plug-ins un-installation. When a plug-in is installed on top of Petrel it registers itself to inform Petrel it exists, then as Petrel knows which plug-ins are installed on top of itself it can, when it is uninstalled, selectively un-install (or not) these plug-ins. When Petrel is uninstalled it checks if plug-ins are installed and asks the user if and which plug-ins need to be un-installed. In case the user wants to uninstall plug-ins the Petrel uninstaller gets the list of registered plug-ins for Petrel and asks the user which registered plug-ins should be uninstalled. It then launches successively the uninstaller of all selected plug-ins (using the option to not check for dependencies). Petrel un-installation needs to be restarted manually then

Appendix A

Appendix A: Migration to Simulation Results on the Petrel Results Tree

Introduction

In Petrel 2010 the simulation results have been moved from the Models tree to the Results tree. This document details issues an Ocean client may face due to this change and suggests potential ways to solve those issues.

Petrel Simulation Results

When the user opens an older project in Petrel 2010 the simulation results on the Models tree will be automatically converted to results on the Results tree. An example of the results on Petrel 2009 is shown below:

An example of the same result on Petrel 2010 is shown below:

Appendix A

Important differences to note:

In the Petrel 2009 version the user can simply select the data they are interested in

directly from the models tree (here the water saturation for Case HOR-1-

STD_ECLIPSE_100).

In Petrel 2010 the user must select the simulation from the Cases tree and then the

identifier of the result they are interested in from the Results tree.

Individual time steps can be selected by the user in the Petrel 2009 version. In Petrel

2010 the individual time steps are not selectable and the user must use the

timeplayer.

Issues you may face

Drop target In previous versions of Ocean and Petrel, you could create a drop target on your dialog and simply drop in the property you wished. In version 2010 you will no longer be able to do this as that property will no longer be selectable in the Models tree and will not be displayed in the same manner in the Results tree.

Appendix A

There is no direct equivalent and instead, to achieve the same behavior, you would have to provide the Case, the GridResult type and a timestep. You can then use the Ocean API to retrieve the property data. The image below shows a possible solution whereby the user may drop a case and the GridResult (in this case „Water saturation‟). Your Ocean plug-in can then retrieve a list of all timesteps and populate the combo box as shown with those timesteps. The user can then select the timestep of interest.

Appendix A

The following are some code snippets of how you could achieve this:

Case Droptarget private void dropCase_DragDrop(object sender, DragEventArgs e)

{

Case c = e.Data.GetData(typeof(Case)) as Case;

if (c != null)

{

textCase.Text = c.Name;

textCase.Tag = c;

RefreshTimesteps();

}

}

GridResult Droptarget private void dropResult_DragDrop(object sender, DragEventArgs e)

{

GridResult gr = e.Data.GetData(typeof(GridResult)) as GridResult;

if (gr != null)

{

textResult.Text = gr.Name;

textResult.Tag = gr;

RefreshTimesteps();

}

}

Updating of the timesteps Combo box private void RefreshTimesteps()

{

comboTimesteps.Items.Clear(); // comboTimesteps is the timesteps Combo box

Case c = textCase.Tag as Case;

if (c != null)

{

GridResult gr = textResult.Tag as GridResult;

if (gr != null)

{

GridPropertyTimeSeries gpts = c.Results.GetGridPropertyTimeSeries(gr);

textGrid.Text = gpts.Grid.Name; // textGrid is the Grid text box

if (gpts.IsGood)

{

if (gpts.SampleCount > 0)

{

foreach (DateTime dt in gpts.TimeSamples)

comboTimesteps.Items.Add(dt);

comboTimesteps.SelectedIndex = 0;

comboTimesteps.Enabled = true;

return;

}

}

PetrelLogger.WarnStatus(string.Format("Case '{0}' does not have results

for '{1}'.", c.Name, gr.Name));

}

}

comboTimesteps.Enabled = false;

return;

}

Appendix A

Retrieval of the property private void PrintGridProperty(Case c, GridResult gr, DateTime timestep)

{


if (gpts.IsGood)

{

GridProperty gp = gpts[timestep];

Index3 num = gp.NumCellsIJK;

PetrelLogger.InfoOutputWindow(String.Format("Printing property '{0}' value at

'{1}'.", gp.Name, gp.Date));

for (int i = 0; i < num.I; ++i)

{

for (int j = 0; j < num.J; ++j)

{

for (int k = 0; k < num.K; ++k)

{

PetrelLogger.InfoOutputWindow(String.Format("{0} [i {1}, j {1}, k

{3}] at {4} => {5}", gp.Name, i, j, k, gp.Date, gp[i, j,

k]));

}

}

}

return;

}

}

Sample Output

Water saturation (SWAT) [i 0, j 0, k 1] at 01/01/2012 00:00:00 => 0.9999998








Pushing back properties to the „Models‟ tree For your workflow it may make sense to push back properties from the Results tree to the Models tree. Please note that there would be some issues with this approach in that these „Models‟ tree results would not be updated on a subsequent simulation run (you would need to push them back again). In addition this would also require more resources and memory to effectively duplicate the properties. Thus this approach is only recommended as an interim solution until you have migrated fully to the new Results tree based API. Here is a sample routine for pushing back 3D grid properties to the „Models‟ tree:

void pushBackGridResultForAllTimeSteps(Case c, GridResult gr)

{

if (c == null || gr == null)

return;


if (gpts.IsGood)

{

PropertyCollection pc = gpts.Grid.PropertyCollection;

using (ITransaction trn = DataManager.NewTransaction())

{

trn.Lock(pc);

foreach (GridProperty gp in gpts.Samples)

{


using (IProgress x =

Appendix A

PetrelLogger.NewProgress(0, num.I * num.J))

{

x.SetProgressText(

String.Format(

"Copying property '{0}' at '{1}' to grid '{2}'.",

gp.Name, gp.Date, gp.Grid.Name

)

);

Property p = pc.CreateProperty(gr.PropertyVersion);

p.Name = gp.Name;

p.UseDate = true;

p.Date = gp.Date;


{


{

x.ProgressStatus = i * num.J + j;


p[i, j, k] = gp[i, j, k];

}

}

}

}

trn.Commit();

}

PetrelLogger.Status("Finished copying properties.");

}

}

Here is another routine for pushing back grid property for a specific time step value:

void pushBackGridResultForTimeStep(Case c, GridResult gr, DateTime ts)

{

if (c == null || gr == null)

return;


if (gpts.IsGood)

{

PropertyCollection pc = gpts.Grid.PropertyCollection;

using (ITransaction trn = DataManager.NewTransaction())

{

trn.Lock(pcr);

GridProperty gp = gpts[ts];


using (IProgress x = PetrelLogger.NewProgress(0, num.I * num.J))

{

x.SetProgressText(

String.Format(

"Copying property '{0}' at '{1}' to grid '{2}'.",

gp.Name, gp.Date, gp.Grid.Name

)

);

Property p = pc.CreateProperty(gr.PropertyVersion);

p.Name = gp.Name;

p.UseDate = true;

p.Date = gp.Date;


{


{

x.ProgressStatus = i * num.J + j;


p[i, j, k] = gp[i, j, k];

}

}

}

Appendix A

trn.Commit();

}

PetrelLogger.Status("Finished copying properties.");

}

}

DROID issues If in your Ocean plug-in you have saved a DROID for a property that has moved from the Models tree to the Results tree, then unfortunately that DROID will not be resolvable. In the code snippet shown below DataManager.Resolve() would return null. Please note that no exception would be thrown here. // A droid for a Property that has moved from the 'Models' tree to

// the 'Results' tree will not be resolvable.

// The following will return null.

Property resolvedProperty = DataManager.Resolve(droid) as Property;

If you have a workstep in which you displayed a drop target for that property, then as you would be unable to resolve that DROID then you would thus be unable to show the property in that drop target. For the scenario where you have used the default grid control for a workstep (i.e. where you have not made a custom UI) then again those drop targets would be empty as the DROID would not be resolvable.

The Ocean team would be interested in receiving feedback from clients who feel that this would present a problem for them. If you have a use case that involves resolving a DROID for a moved property then please contact the Ocean Product Champion and provide details.

Appendix B

Appendix B:

Use of IObservableElementEnumerable

instead of INotifyingEnumerable

From Ocean for Petrel 2010.1 Slb.Ocean.Basics.INotifyingEnumerable is

obsoleted. Please use IObservableElementEnumerable instead of

INotifyingEnumerable. The factory for it (INotifyingEnumerableFactory) was

made obsolete in Ocean for Petrel 2009.1. This new interface allows a plug-in to notify Petrel that multiple elements have been added

or removed by raising the EnumerableChanged event only once.

The code fragment below shows how the new interface can be implemented: using System.Collections;

using System.Collections.Generic;

using Slb.Ocean.Petrel.Basics;

public class Folder : IObservableElementEnumerable

{

List<object> m_Children = new List<object>();

public void Add(object child)

{

m_Children.Add(child);

if (EnumerableChanged == null)

return;

EnumerableChanged(this, new ElementEnumerableChangeEventArgs(

new object[1] { child }, new object[0] { }));

}

public event EventHandler

<Slb.Ocean.Petrel.Basics.ElementEnumerableChangeEventArgs>

EnumerableChanged;

IEnumerator IEnumerable.GetEnumerator()

{

return m_Children.GetEnumerator();

}

//...

}

Appendix C

Appendix C:

Third-party Components Deployed with Petrel:

Avoiding Version Conflicts

The table below lists third-party components that are used and deployed by Petrel as dynamic-link libraries (DLLs). Plug-ins that use third-party libraries should review this table for possible version conflicts. For plug-ins that use native third-party DLLs, the best way to avoid version conflicts is to statically link against the library. (Note, however, that the Intel OpenMP library is an exception to this rule – see the Intel MKL in the table below.) Using DLLs with version-specific file names or using the same version as Petrel are other options for avoiding conflicts. See the document Ocean Module Deployment on the Ocean Portal (http://www.ocean.slb.com/Secure/developers-best-practices.aspx) for more information. These libraries are not part of the Ocean API and plug-ins are responsible for obtaining the appropriate licenses required to use them.

Component Name Version Number

Component Vendor Name

Description

.NET Framework 3.5 SP1 Microsoft http://msdn.microsoft.com/en-gb/netframework/default.aspx

Boost 1.39 Boost Community

http://www.boost.org/

ChartFX 7.0 Software FX http://www.componentsource.com/features/software-fx/index.html Charting package (used for tornado plots)

Geostat/GSLib July 31 2003 Statios http://www.statios.com Industry standard geostatistics.

ESRI Projection Engine (pe.dll)

9.3.1.1632 ESRI http://www.esri.com Used by the Ocean Core and Services Coordinates service to execute coordinate systems operations.

FlexLM V11 .3 Flexera http://www.flexerasoftware.com/

FreeImage 3.11.0 SourceForge http://freeimage.sourceforge.net FreeImage is not used directly by Petrel. It is used by ImageConversion, which is run as a separate process from Petrel. FreeImage is only deployed in 32-bit version.

GeoToolkit.NET 2.3.2987.0 INT http://www.int.com/products/geotoolkit/geotoolkitnet/geotoolkit_net.htm

HueSpace 2.0 Hue Volume Visualization

Infragistics NetAdvantage

7.3.20073.38 Infragistics http://www.infragistics.com UI controls or toolbars and tree.

Intel MKL (with Intel OpenMP)

10.2.2.025 (5.0.2009.623)

Intel http://software.intel.com/en-us/intel-mkl/ NOTE: MKL includes the Intel OpenMP library libiomp5md.dll, version 5.0.2009.623. This library is an exception to the rule that plug-ins can avoid version conflicts by can linking statically. On the contrary, this library will throw an exception if more than one instance is initialized in a single executable.

http://www.ocean.slb.com/Secure/developers-best-practices.aspx

Appendix C

Therefore, if a plug-in uses libiomp5md.dll, it must use the DLL (not link statically) and it must use this same version as Petrel.

Intel Fortran RTL 9.1.101.101 Intel http://software.intel.com/en-us/intel-compilers/

MicroscribeSDK(32) 2.2.0.0 RevWare http://www.revware.net A middleware library that Petrel uses to communicate with Microscribe input devices produced by Immersion.

Microsoft Enterprise Libraries

4.1.0.0 Microsoft http://msdn.microsoft.com/en-us/library/dd203099.aspx

NMath Core 4.0* CenterSpace Software

http://www.centerspace.net/products/nmath/core/ * The build of NMath 4.0 deployed with Petrel is a SLB specific build. Plug-ins that wish to use NMath should contact Ocean for Petrel support for further instructions.

OpenInventor 7.2 VSG, Visualization Science Group

http://www.vsg3d.com/vsg_prod_openinventor.php 3D visualization

OpenMP - - See Intel MKL.

Oracle Instant Client 11.1.0.x Oracle http://www.oracle.com

Qt4 4.4.3 Nokia http://qt.nokia.com/ Used by the Seismic Server Administration Tool.

Qt4 4.6.2 Nokia http://qt.nokia.com/ Used by the Petroleum Quick Look Plug-in

SDI APS 1.52 System Development, Inc.

http://www.sdicgm.com/ Paper, CGM and PDF output from Petrel

SyncFusion 7.303.0.20 SyncFusion http://www.syncfusion.com

TDxInput 1.1.0.0 3Dconnexion http://www.3dconnexion.com A middleware library that Petrel uses to communicate with input devices produced by 3DConnexion.

trackdAPI 1.10.0.0 Mechdyne http://www.mechdyne.com A middleware library that Petrel uses to communicate with the trackd server from VRCO.

Xerces-C++ XML Parser

2.7.0 Apache Software Foundation

http://xerces.apache.org/xerces-c/

Appendix C

Contacting the Ocean Team

Please refer to the following resources for Ocean information:

www.ocean.slb.com.

http://www.ocean.slb.com/

Date post:	25-Oct-2015
Category:	Documents
Upload:	aawararahi
View:	350 times
Download:	15 times

Ocean for Petrel 2010.1 ReleaseNotes

Documents