Ocean for Petrel Plugin Creation - Ocean - Schlumberger

Ocean 2006
Petrel Product Family
Module Developer’s Getting Started
Guide

Copyright Notice
Copyright © 2006 Schlumberger. All rights reserved.
The information in this document is subject to change without notice. The software
described in this document is furnished under a license agreement. This software may be
used or copied only in accordance with the terms of such agreement. It is against the law
to copy the software on any medium except as specifically allowed in the license
agreement. No part of this document may be reproduced or transmitted in any form, or by
any means, electronic or mechanical, including photocopying and recording, for any
purpose without the express written permission of Schlumberger.
Trademarks
TM
TM
Petrel and Ocean are trademarks of Schlumberger.
Microsoft® and Windows® are registered trademarks of Microsoft Corporation.
2

Table of Contents
Table of Contents ...................................................................................................... 3
1. Introduction ............................................................................................................ 4
1.1. Access to Petrel Data Domain...............................................................5
1.2. Ocean User Interface Infrastructure ......................................................5
1.3. Prerequisite............................................................................................6
2. Ocean Module Wizard.......................................................................................... 7
2.1. Installing the Ocean Module Wizard......................................................7
2.2. Running the Ocean Module Wizard.......................................................7
2.2.1. Hello World Example specification.................................................8
2.2.2. Starting the Wizard.........................................................................8
2.2.3. Wizard Step 1 Dialog......................................................................10
2.2.4. Wizard Step 2 Dialog......................................................................12
2.2.5. Wizard Step 3 Dialog......................................................................15
2.2.6. Wizard Step 4 Dialog......................................................................19
2.2.7. Modifying the Module Source.........................................................20
2.2.7.1. Displaying “Hello World Loaded” ................................................ 21
2.2.7.2. Process Code Changes ............................................................... 22
2.2.7.3. Display “Hello World” in Status Bar............................................ 22
2.2.7.4. Using the Input Arguments.......................................................... 24
2.2.7.5. Transactions .................................................................................. 25
2.2.7.6. Menu Code Changes ................................................................... 26
3. Domain Examples................................................................................................. 28
3.1. Creating a Well Path from a Point Set...................................................28
3.1.1. Create the CreateWellFromPoints project .....................................28
3.2. Upscale a Well Log................................................................................35
3.2.1. Create the Upscale Well Log Example ..........................................35
3.3. Running the Examples...........................................................................42
4. Help Resources and Debugging Hints............................................................... 51
4.1. Online Documentation ...........................................................................51
4.2. Hardcopy Documentation ......................................................................53
4.3. Training..................................................................................................53
4.4. Debugging Hints ....................................................................................54
4.4.1. Build Failed.....................................................................................54
4.4.2. Process Not Appearing in Process Diagram..................................54
3

1. Introduction
Ocean is an application framework with the capability to work across data
domains. It provides services, components, and a common graphical user
interface that enables applications to better integrate. It also allows application
developers to interact with other Ocean Model-Centric applications such as
Petrel.
Ocean Model-Centric applications are loaded dynamically as .NET assemblies.
These assemblies, the building blocks of Ocean, contain Modules.
Ocean is architectured in three levels: The Core, the Services and the Product
Family. For Model-centric applications, the Product Family is Petrel. Ocean
Modules are managed by the Core layer. They interact with all levels of the
framework, as shown below:
Ocean Module
Petrel Product Family
Ocean Services
Ocean Core
Figure 1-1. Ocean architecture with Ocean Module.
An Ocean Module is managed by the Core level. Modules are built with Visual
Studio 2005 for .NET with the help of the Ocean wizard which takes care of the
interaction with the Core and some low-level access to functionality provided by
the Product Family.
4

1.1. Access to Petrel Data Domain
The access to the Petrel data domain is the responsibility of the application.
Ocean for Petrel 2006 covers a variety of data domains:
• Well (for Petrophysics and Geology applications)
• Seismic (for Geophysics)
• Shapes (for Structural modeling)
• PillarGrid (for Geomodeling)
• Simulation (for Reservoir Evaluation)
Figure 1-2. Surface with fault model and seismic data.
1.2. Ocean User Interface Infrastructure
Ocean provides the capability to extend Petrel’s user interface functionality. The
Ocean Application Programming Interface (API) supports:
5

1. Adding custom UI windows,
2. Adding processes to the Petrel Process diagram,
3. Adding processes to the Workflow editor,
4. Adding custom menus to the Petrel window,
5. Adding buttons to existing menus,
6. Adding toolbars,
7. Adding tools to existing toolbars,
8. Adding objects to the Petrel Explorer window,
9. Creating custom objects (domain objects),
10. Extending the Petrel renderers.
Programmers create modules that behave as if they are a standard part of
Petrel. The modules are compiled into assemblies that are placed in the Petrel
installation directory and registered with the application through a configuration
file. The assemblies are IL, or Intermediate Language, code that is processor
independent. It provides a common layer, similar to assembly language, that all
.Net languages (C#, C++, VB, etc.) compile to. At runtime it is further compiled
and executed by the .Net Common Language Runtime, or CLR, engine.
1.3. Prerequisite
This document presents the information necessary for a programmer to create
and use modules in Ocean for Petrel. It assumes the following:
1. Knowledge of the Microsoft .NET Framework,
2. The use of Visual Studio, and the C# programming language,
3. A basic understanding of using Petrel as described in the “Petrel
Introduction Course” manual,
4. An available Ocean API development license and a base Petrel license.
6

2. Ocean Module Wizard
Ocean modules have many characteristics that are essentially the same from
module to module. Therefore, Ocean provides a wizard to simplify the creation
and installation of modules. This chapter provides an overview of the Ocean
Module Wizard and an example of its use. The example adds a process to the
Process diagram window and a menu, with a button, to the menu bar.
2.1. Installing the Ocean Module Wizard
The Ocean Module Wizard is not installed as part of the Ocean installation
process. It must be installed separately on each instance of Visual Studio used
to develop Ocean Modules. Install the wizard using the following steps:
1. Locate the wizard installation file (VSPluginInstaller.msi) in the Ocean
2006 installation directory using Windows Explorer.
2. Right click on VSPluginInstaller.msi in Explorer and select “Install”
from the popup menu.
3. Select “Next” in the installation window when requested to complete the
installation.
4. Close the last window at the end of the installation. The Ocean Module
Wizard will now be available in Visual Studio.
2.2. Running the Ocean Module Wizard
Once installed the Ocean Module Wizard is available in Visual Studio as
Templates in dialogs where new projects or items are being added. It can be
used to create a new solution with a new project or extend an existing solution
or project. In our example we’ll create a new solution and project. The templates
for the Ocean wizard include:
1. Ocean Module – Add a new module to a solution.
2. Ocean Menu Extension – Extend the Petrel main menu.
3. Ocean Process – Add a process to the Process diagram tree.
7

4. Ocean Settings Page – Add a page to the Settings dialog for an item in
the Petrel Explorer tree.
5. Ocean Tree Extension – Extend the Petrel Explorer input tree.
6. Ocean Window – Add a window that accepts graphics.
7. Ocean Datasource – Add a class implementing the IDataSource
interface.
2.2.1. Hello World Example specification
The example for using the wizard will be a simple Hello World module. The
module specifications are as follows:
1. Display “Hello World Loaded” in the Petrel message window when the
module is loaded. The class PetrelLogger is used to output messages
through the Ocean CoreLogger class to a window, a log file, or standard
output.
2. Add a Hello World process to the Petrel Process window.
3. Display “Hello World” in the status bar. The status bar is part of the
Petrel main window.
4. Define a string as an argument to the Hello World process.
5. Write “Hello World” and the contents of the string to the Petrel message
window when the process is executed.
6. Add a menu to the menu bar after the “Help” menu.
7. Add a button to the new menu.
8. Display “Hello World” in the Petrel message window when the menu bar
button is selected.
9. Add the module to the application configuration file (petrel.exe.config)
during the wizard execution.
2.2.2. Starting the Wizard
The Ocean Module Wizard is started from the “New Project” dialog in Visual
Studio. From the Visual Studio “File” pulldown menu select “New...” and then
“Project...”. This will bring up the “New Project” dialog shown in Figure 2-1
8

Ocean Wizard
Project Name
Figure 2-1 Visual Studio New Project dialog
To start creating the HelloWorld module perform the following tasks in the dialog
as indicated in Figure 2-1:
1. Select the “Ocean Module” template from the template frame,
2. Change the project name that appears when the template is selected
from “OceanModule1” to “HelloWorld” in the “Name” text field. This will
also modify the “Solution Name” text field with a matching name.
3. Check the “Location” text field for the name of the directory where you
want the solution to be created. Use the “Browse...” button to select a
different directory if desired, or simply enter it in the field.
4. Leaving “Create directory for solution” checked will add an additional
directory that contains only the solution. Uncheck it to have the solution
and project in the same directory.
5. Select OK to create the HelloWorld solution and project and start the
wizard.
9

2.2.3. Wizard Step 1 Dialog
When the Ocean Module Wizard starts the Step 1 dialog will appear as shown in
Figure 2- 2. In this step you will choose the components you would like to include
in your module.
10
Figure 2-2 Step 1 for Ocean Module creation.
The Step 1 dialog appears with the module name in the top text field and a
default namespace using the same name just below. Either or both text fields
may be changed to suit your naming convention. The namespace field has been
changed for our example as shown Figure 2- 3.
The Name field defines the module name for our project. The wizard will create
a class with this name that will implement the IModule interface. This class will
be in a c# file of the same name. Our example will create the class “HelloWorld”
in the source file HelloWorld.cs.
The Namespace field defines the namespace for our projects class. It is a
common practice when defining namespaces to incorporate the company name
and product name into the namespace to help avoid conflict. This has been
done in Figure 2- 3 with the namespace Slb.Ocean.GettingStarted. The resulting

namespace for the project will be the combination of the name space field and
the project name. For the example in Figure 2- 3 the namespace in the source files
will be “Slb.Ocean.GettingStarted.HelloWorld”.
You now need to select the components that you would like in your module. For
the HelloWorld example a process and a menu item are being demonstrated.
These items are included by turning on the “New Process” and “New Menu item”
check boxes. When this is done the corresponding text fields will be populated
with “Process1” and “Menu1” respectively. We have changed the names in
these fields as shown in Figure 2- 3. You should also note that the title of the
wizard dialog will change based on the items you have selected to indicate the
new number of steps that must be performed.
The name in the New Process text field is used to define the name of the class
that is created for the process. This class is a subclass of Workstep, a generic
class that includes the description of the Process arguments. It also implements
two interfaces, IPresentation (for its appearance in the Process Diagram) and
IDescriptionSource (to display information in the Process dialog). The example,
as shown in Figure 2- 3, will create the classes “HelloWorldProcess” and
“HelloWorldProcess.Arguments”. The second class is used to publish the type of
the argument package that is passed to the process by the process dialog. It is a
subclass of DescribedArgumentsByReflection.
The name in the New Menu text field is used to define the source file name for
the menu source code. The file name is derived from the menu name. In our
example the menu name we’ll add is “HelloWorldMenu”. Therefore the resulting
source file name will be “HelloWorldMenu.cs”.
The wizard allows also the user to generate workspace events, which will
register delegates at session startup and shutdown.
The wizard can update the application configuration file, petrel.exe.config, in the
installation directory. This action is controlled by the “Add the module to the
Petrel config” check box. The check box is turned on by default.
To perform the config file update the wizard must know the location of the Petrel
2006 installation. Check the location indicated in the text field to be sure it is
correct (see Figure 2- 3).
The configuration file will be updated to include the module definition for the
module created by the example. It will contain “” for the example.
The first part of the definition, “Slb.Ocean.GettingStarted.HelloWorld” is the full
Module name, including its namespace. The second part, “HelloWorld” is the
name of the assembly file (.dll) that is created when the project is compiled. The
assembly file will have to be moved or copied to the installation directory before
the module can be used. This will be explained in detail later.
11

Once you have modified the fields in the Step 1 select the “Next” button to move
on to the next step.
Figure 2-3 Step 1 dialog for module creation modified for example.
2.2.4. Wizard Step 2 Dialog
The example is adding a new process to the Process manager. The wizards’
second step is to gather information for the process. A process can have a UI
that is built from an argument list, or it may use a custom UI provided by the
developer. For our example the standard UI built by Ocean will be used. The
standard UI will be built from the table of argument names and fields that contain
the associated value. The argument list supports basic data types (int, float,
double, string, bool), or Ocean Domain Object types (Grid, Well, Property, etc.).
Each argument in the argument list is identified by its name and the name will
appear in the UI that is built by Ocean. The arguments also have descriptions,
default values, and a role as input and/or output data. When the wizard moves
to the Process details step the dialog will change to accept the information
defined above for the Process (see Figure 2-4).
12

turn off checkbox
set long and short
descriptions
add argument to
list
set argument
info
Figure 2-4 Step 2 defining Process parameters.
The first step in Step 2 is to turn off the custom UI checkbox since there will not
be a custom UI in this example. The checkbox appears at the top of the window
with the text, “Generate UI”.
Next you provide short and long descriptions for your process. The short
description is a brief explanation of the purpose of the process. The long
description provides more detail and might include some description of the type
of data provided for each of the arguments.
Arguments are added to the argument list by selecting the button at the top
of the list. The information for the argument selected in the list is filled in using
the controls on the right side of the dialog. Here you define the arguments name,
type, description, default value (if any), and role as input and/or output data. The
name, as mentioned earlier, will appear in the UI for the process and will be
associated with a field that will contain the arguments input and/or output data.
The description and default value are not required, but may help the users of
your process (see Figure 2- 5).
You can change parameters for an argument by selecting the argument from the
list and then modifying the argument information.
13

An argument may be deleted by selecting it in the list and then clicking the
delete icon.
Figure 2-5 Step 2 dialog with argument parameters filled in.
When you have defined all the arguments that you require and provided their
parameters you have completed the process item definition. Select Next to
proceed onto the next step in the wizard process.
14

2.2.5. Wizard Step 3 Dialog
The example adds a pulldown menu to the menu bar and a button to the
pulldown menu. The third step in the wizard defines the pulldown menu and the
button (see Figure 2- 6).
add new
item
shift item position
set parameters
expand menu
Figure 2-6 Step 3 dialog for adding menus and buttons.
The menu may only be added at the end. We’ll call the pulldown menu
“HelloWorld” and name the button “Do it”. We’ll use the controls indicated in
Figure 2- 6 to create, name, and provide parameters for our menu.
To add the new menu to the menu bar perform the following steps:
1. Start by selecting “Petrel Main Menu” from the menu list.
2. Select the “Add new item” icon to add a new item at the bottom of the
menu list (see Figure 2-7).
15

Figure 2-7 Menu added to menu bar
3. Define the new item as a popup menu using the combo box at the right
side of the dialog
4. Change the name of the menu to HelloWorld by entering the new name
in the Name field.
16

set to
Popup
set name
Figure 2-8 Setting parameters
After the menu is added you need to add the button to it. The procedure for
adding the button is basically the same as that for adding the menu.
1. Select the HelloWorld menu in the menu bar items list.
2. Click the “+” icon to add a new item under the HelloWorld menu.
3. Make the new item a button by setting the combo box to “Button”.
4. Set the new button name by entering the name “Do it” in the Name text
field.
5. Add a click event handler to the button by turning on the “Add Click
Event” button. This is requires so selecting the button can trigger the
display of the message in the message window and status bar (see
Figure 2- 9).
17

set to
Button
set button
name
add new
item
event
is on
Figure 2-9 Step 3 adding button to new menu.
After the new menu is added, its parameters set, the new button added, and its
parameters set you can select the “Next” button to proceed to the final wizard
step for the example.
18

2.2.6. Wizard Step 4 Dialog
The final step in the execution of the Ocean Module Wizard is always a review
of the settings you provided to the wizard steps. You should carefully read the
contents of the dialog and use the “Back” button if something is incorrect to
return to the corresponding step to make repairs (see Figure 2- 10).
If you are satisfied with your settings click “Finish”. The wizard will create the
Visual Studio solution, project, and source files as defined by the settings you
have provided.
Figure 2-10 Step 4 Final review of module wizard parameters.
19

2.2.7. Modifying the Module Source
When the Ocean Module Wizard for the example finishes there will be a solution
named HelloWorld with a project named HelloWorld in the Visual Studio Solution
Explorer. The project will contain source files for the HelloWorld module that was
created, the HelloWorld menu that is added to the menu bar, and the HelloWorld
process that is added to the Process Manager (see Figure 2- 11).
module source file
menu source file
process source file
Figure 2-11 Example project source files in Solution Explorer
The HelloWorld project in the solution is configured by the wizard to help
debugging. The assembly built by the compiler is output to the Petrel installation
directory. The project command line property is set up to start Petrel. So
debugging is simply a matter of performing the build and starting the debugger.
The files contain the basic code needed for the HelloWorld module. For the
module perform as defined by the specifications there is still a small amount of
code that must be added manually. From the original specifications code must
be added to:
1. Display “Hello World Loaded” in the message window when the module
is loaded.
2. Display “Hello World” in the status bar when the process is started.
3. Write “Hello World” and the contents of the string to the message
window when the process is executed.
4. Display “Hello World” in the message window when the menu bar button
is selected.
20

2.2.7.1. Displaying “Hello World Loaded”
When Petrel is started the configuration file will be read and the modules defined
in it will be loaded. The module loading process has several steps that are
performed for each module. These are defined in more detail in the Ocean
training materials. For the purpose of the example here it is sufficient to know
that the first step performed is the “Initialize” method of the IModule
implementation. The code for our example implementation of Initialize for
IModule is found in HelloWorld.cs (see Figure 2- 12).
public void Initialize()
{
// TODO: Add HelloWorld.Initialize implementation
}
Figure 2-12 Initialize method for IModule.
To make the example display “Hello World Loaded” when the module loads we
modify the Initialize method to use PetrelLogger to output an information
message using its Info method. The information message is displayed in the
message window that pops up when the message is sent. The “// TODO:”
comment is replaced with the code to send the message (see Figure 2- 13).
public void Initialize()
{
PetrelLogger.InfoOutputWindow(“Hello World Loaded.”);
}
Figure 2-13 Modified IModule Initialize method.
Build the solution and start Petrel. When the module is loaded the CoreLogger
message window will appear with the “Hello World Loaded” message (see Figure
2- 14). Exit Petrel.
Figure 2-14 Message window displayed during module loading.
21

2.2.7.2. Process Code Changes
The Process code that is constructed by the Ocean Module Wizard has a
Workstep class that implements IPresentation and IDescriptionSource. It also
contains an Arguments class, subclass of the Slb.Ocean.Petrel.Workflow class
DescribedArgumentsByReflection. That specialized Workstep class is named
HelloWorldProcess, after our process name, and it overrides the method
InvokeSimpleCore, which is the entry point for process execution. Open the file
HelloWorldProcess.cs. To execute your custom code, you will have to add it to
the body of the InvokeSimpleCore method.
The code for the InvokeSimpleCore method that is created by the wizard is
shown in Figure 2-15. You can see that the arguments defined for the wizard are
passed to the method. The structure is defined in the specialized class
HelloWorldProcess.Arguments.
protected override void InvokeSimpleCore
(HelloWorldProcess.Arguments argumentPackage)
{
// TODO: finish the Invoke method implementation
}
return;
Figure 2-15 Invoke method original code.
2.2.7.3. Display “Hello World” in Status Bar
The status bar is located at the bottom of the Petrel window. It is accessed by
calling the static methods of the PetrelLogger convenience class. PetrelLogger
is a layer on top of CoreLogger and is defined in the Slb.Ocean.Petrel
namespace. In the example the “SuccessStatus” method will be used to display
the message and set the icon to the right of the status bar to indicate that the
message posted marks a successful operation. Other methods (Error, Warning,
Status) can also be used depending on the message target (log file, log window,
modal dialog or status bar) and the type of information that needs to be
displayed. The message presentation will be consistent with the way the Product
Family (Petrel) displays its messages.
To place a message in the status bar, add the PetrelLogger call to the body of
the InvokeSimpleCore method, as shown in Figure 2-16.
protected override void InvokeSimpleCore
(HelloWorldProcess.Arguments argumentPackage)
{
PetrelLogger.SuccessStatus(“Hello World Process started.”);
}
return;
Figure 2-16 InvokeSimpleCore with status bar message.
22

After modifying the Invoke method, build the solution and start Petrel. When the
Petrel window is displayed go to the Process diagram window and look for
“HelloWorldProcess” (see Figure 2-17).
Figure 2-17 HelloWorldProcess selected in Process diagram.
Double click on it to start the process and display the HelloWorldProcess dialog
(see Figure 2-18). You’ll see that the argument you defined in the Ocean Module
Wizard is present with its default value. The long description is displayed in the
top section of the dialog. If you pause the cursor over the text field the tooltip for
the argument will appear.
23

Figure 2-18 HelloWorldProcess dialog.
Select Apply in the dialog to run the process. Doing so should display a
successful message in the status bar, at the bottom of the Petrel window (see
Figure 2- 19 ). Exit Petrel.
Figure 2-19 Message displayed in status bar.
2.2.7.4. Using the Input Arguments
The InvokeSimpleCore method will receive the argument list for the process as
its argument. Individual arguments are named members of the specialized
HelloWorldProcess.Arguments class included with the Workstep that
implements IDescribedArgumentSource.
The example process will perform a very simple, and familiar, operation on the
input argument. It will write its contents to the message window after “Hello
World”. See Figure 2- 20.
24

public static bool InvokeSimpleCore(object argumentPackage)
{
...
string name = argumentPackage.YourName;
// Write message and input argument value.
PetrelLogger.InfoOutputWindow(“Hello World!”);
PetrelLogger.InfoOutputWindow(“Your name is ” + name);
}
return true;
Figure 2-20 Modified InvokeSimpleCore method code.
When the method has been modified to take care of the process arguments, rebuild
your project and start Petrel. You can start the HelloWorldProcess again
from the Process diagram.
You can now edit your process arguments and observe the result during
process execution. Press the Apply button. It should display the Petrel message
window with the messages previously defined in the InvokeSimpleCore method
(see Figure 2- 21). Exit Petrel.
Figure 2-21 HelloWorldProcess output messages.
2.2.7.5. Transactions
Processes that create, update, or delete domain object require transactions to
control when the change is committed to the database. The general flow in the
code is to
1. start the transaction,
2. lock the object,
3. make changes to the object,
4. commit the transaction, and dispose (see Figure 2- 22).
25

If no transaction is used and data is updated then an Update exception will be
raised. Transactions must be started and committed in the same thread. When
domain object for Petrel data are used the transaction should be in the main
thread.
// Start the transaction in the Main thread to update a Petrel object.
using (ITransaction trans = DataManager.NewTransaction())
{
...
// Get the well log to update from somewhere.
WellLog log = ...;
// Lock the well log to change its description.
if (trans.Lock(log))
{
// Modify the short desctiption of the well log.
log.Description.ShortDescription = “Porosity – December 2005”;
}
// Commit the changes to the data store.
trans.Commit();
}
// Dispose of the transaction
...
Figure 2-22 Example code for using an example.
26
2.2.7.6. Menu Code Changes
The source code for the menu bar is contained in the file HelloWorldMenu.cs.
The first part of the filename, “HelloWorldMenu”, is the name entered for the
New Menu field in step 1 of the wizard. The second part of the name,
“HelloWorld”, is the name given to the pulldown menu in step 3 of the wizard.
The wizard will create a separate source file for each pulldown menu we add to
the module.
In the wizard the “Add Click Event” button was turned on for the “Do It” button
that was added to the menu. This caused the wizard to create a method with
“_ToolClick” appended to the button name with its white space removed. The
result is a method called “DoIt_ToolClick”. By default, the method is set up by
the wizard to show a message box containing a message indicating that the
button has been selected.
private void DoIt_ToolClick(object sender, ToolClickEventArgs e)
{
// Add eventhandler implementation here for the menuitem
MessageBox.Show("Click event of your new Do It MenuItem.",
"Information", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
Figure 2-23 Original Doit_ToolClick method code.
To output a message to the message window the method has to be changed
(see Figure 2- 24).

private void DoIt_ToolClick(object sender, ToolClickEventArgs e)
{
// Add eventhandler implementation here for the menuitem
String message = “HelloWorld menu DoIt button clicked.”;
PetrelLogger.InfoOutputWindow(message);
}
Figure 2-24 Modified DoIt_ToolClick method code.
Build the solution and start Petrel. When the Petrel window is displayed the
HelloWorld menu should appear in the menu bar to the left of the Help menu
(see Figure 2- 25).
new menu
Figure 2-25 HelloWorld pulldown menu in menu bar.
Clicking the HelloWorld menu will expand it to show the “Do It” button (see Figure
2- 26).
new menu
Figure 2-26 HelloWorld pulldown menu with Do it button.
When the “Do It” button is selected from the HelloWorld pulldown menu the
message window will be displayed with the message provided in the
DoIt_ToolClick method (see Figure 2- 27).
Figure 2-27 Output from selection of DoIt button.
27

3. Domain Examples
Now that you’ve learned how the Ocean Module Wizard works in the previous
chapter we’ll use it to create some real world examples that access data from
the Petrel data model. These examples will
1. Create a well with a path defined by a point set
2. Upscale a well log
These examples will expose you to the Ocean domain object API for several
types of data. We’ll create them in one Visual Studio solution, but use different
projects for each.
3.1. Creating a Well Path from a Point Set
This example creates a new well in a well collection with a path defined by a set
of coordinates defined by an object called a Point Set. The Point Set object may
be provided in the demo project, or, if it is not present, it may be created by
using the Petrel Draw Polygon utility. Draw Polygon is found in the Process
diagram Utilities folder. Point Set objects in the project are found in the Input tab
of the Petrel Explorer window.
The Create Well Path example will be a process added to the Process diagram.
Its process will have three arguments. These are:
1. Input Points – the points defining the well path contained in a PointSet
object.
2. Result – the Borehole object that is created from the points.
3. Name – a string to hold the name of the Borehole that will be created.
4. Borehole Collection – an object from Petrel Explorer that contains a set
of boreholes.
28
3.1.1. Create the CreateWellFromPoints project
Create the project for creating a well from a Point Set by performing the
following:
1. Start Visual Studio and create a new project (File > New > Project...)

2. Select Ocean Module from the Templates
3. Set the Name to CreateWellFromPointSet and the Solution Name to
GettingStarted. Check the location where the solution will reside. Make
sure the Create directory for solution button is on.
4. Once the settings are verified select OK to start the Ocean Module
Wizard.
5. Set the project Name and Namespace to CreateWellFromPointSet
6. Turn on the Process button and enter the name WellFromPoints in the
text field. Make sure the “Add module to Petrel config” button is checked
(See Figure 3- 1).
Figure 3-1 WellFromPoints project setup in wizard.
7. Select Next to proceed to the next step to set up the process
descriptions and arguments.
8. Choose whether you want to use the standard process dialog or to
create your own, as it is done here. Creating your own dialog will give
you more flexibility, but you have to handle the WinForms part. Turn the
29

checkbox “Generate custom UI” only if you want to create your own
dialog (seeFigure 3- 2).
9. Define the arguments for the process (seeFigure 3- 2). You will need the
following:
a. Input Points – Input argument that is a PointSet type (a Petrel
domain object).
b. Result – Input / Output argument that is a Borehole type.
c. Name – a String Input argument to hold the name of the
Borehole to be created, if needed.
d. Borehole Collection – Input argument specifying where the
Borehole will eventually be created.
Figure 3-2 Arguments for WellFromPoints process
10. Select Next to go to the next wizard step where the contents of the
solution are reviewed.
11. Check the solution contents that will be created by the wizard and go to
last step (see Figure 3- 3).
30

Figure 3-3 Review solution contents.
The next step allows you to add reference settings to your project (include
.dll references in Visual Studio to get more definitions). The wizard will
include a number of references, like Basics, Core, Data, Geometry, Petrel
and Petrel.DomainObject.
Step 4 will allow you to browse through the Ocean libraries and check
additional services (see Figure 3- 4).
31

Figure 3-4 Addition of references.
12. When the wizard finishes you will have a new solution and project in
your Visual Studio Solution Explorer (see Figure 3-5).
Figure 3-5 Solution Explorer with GettingStarted project containing
CreateWellFromPointSet module.
13. If you have chosen to design a custom dialog for your process, you will
have to add all the controls needed to let the user specify the arguments
that you have specified for your process (see Figure 3- 6). Ocean will just
32

add the “Apply”, “OK” and “Cancel” buttons that will initiate the Workstep
execution.
Figure 3-6 Custom dialog design.
14. Implement the contents of the InvokeSimpleCore method to perform the
processing (see Figure 3- 7).
33

Protected override void
InvokeSimpleCore(WellFromPoints.Arguments argumentPackage)
{
// Set up input argument variables from argumentPackage
PointSet pointset = argumentPackage.InputPoints;
Borehole result = argumentPackage.Result;
String boreholename = argumentPackage.Name;
BoreholeCollection folder = argumentPackage.BoreholeCollection;
// Start a transaction for the process
using (ITransaction trans = DataManager.NewTransaction())
{
// If a not specified, create a new Borehole
if (result == null)
{
if (folder == null)
{
Project p = PetrelProject.PrimaryProject;
folder = BoreholeCollection.GetRootBoreholeCollection(p);
}
trans.Lock(folder);
// if not supplied, set Borehole name to “wildcat”
if (boreholename == null) boreholename = "wildcat";
result = folder.CreateBorehole(boreholename);
// New Borehole is locked implicitly.
}
else {
// Lock the Borehole since we’ll be modifying it
trans.Lock(result);
}
// Set the Kelly Bushing value for the well.
result.KellyBushing = 100.0f;
// Set the location of the well as the first point in the set
foreach (Point3 p in pointset.Points)
{
result.WellHead = new Point2(p.X, p.Y);
}
break;
}
}
// Make a polyline from the points and append it to the well.
// Note that this is an append, so executing the workstep twice
// on the same well will loop and duplicate the trajectory.
// When replacing the trajectory of an existing Borehole,
// set Trajectory.Polyline, instead of calling AppendPolyline
IPolyline3 polyline = new Polyline3(pointset.Points);
result.Trajectory.AppendPolyline(polyline);
wildCat.AppendPolylineTrajectory(polyline);
// Commit the data created in the transaction to the data store.
trans.Commit();
// Set the output argument to the new borehole.
argumentPackage.Result = result;
Figure 3-7 WellsFromPoints InvokeSimpleCore method code.
15. Build the solution to make sure it compiles. We’ll describe the running of
the process later.
34

3.2. Upscale a Well Log
This example will create a simple upscale log property for a grid. The well log
selected by the user is intersected with the grid selected by the user. The output
is a property for the grid in which each cell intersected by the well contains an
average value for the log samples falling within the cell.
This example is also a process added to the Process Manager. It has three
arguments. These include:
1. Well Log – input argument for well log to upscale.
2. Grid – input argument for grid to intersect with the well log.
3. Property – output argument for the property to create.
3.2.1. Create the Upscale Well Log Example
The Upscale Well Log example will be added as another project in the same
GettingStarted solution. Perform the following steps to create this example:
1. Make sure the GettingStarted solution from the previous example is
loaded in Visual Studio.
35

2. Highlight the solution in the Solution Explorer window and add a new
project (see Figure 3- 8).
add new project to existing
solution
Figure 3-8 Adding new project to GettingStarted solution.
36

3. When the Add New Project dialog appears select the Ocean Module
template from the Templates panel. Enter the Name UpscaleWell.
Check the location and modify it, if necessary, to reference the directory
for the solution. This should be GettingStarted from the previous
example (seeFigure 3- 9). Select OK to start the Ocean Module wizard.
select Ocean module
set name
set location
Figure 3-9 New project definition.
37

4. The wizard will now start and present its first window where the items
for the project are defined. Turn on the New Process check box and
enter “PropertyFromLog” in the corresponding text field (See Figure
3- 10). Select the Next button to proceed to the following step.
Figure 3-10 Project options for UpscaleLog.
5. Turn off the custom UI implementation check box.
38

6. Define the four arguments for the process in this step (see Figure 3- 11).
a. Well Log – Input argument with a type of WellLog defining the
log to process.
b. Grid – Input argument with a type of Grid defining the grid to
intersect and contain the output property.
c. Cells processed – Output argument that will show the number
of grid cells intersected by the log.
d. Output Property – Ouput argument that will contain the property
object created by the process.
Figure 3-11 Argument definition for the Upscale Log process.
39

7. Select Next to proceed to the next step which reviews the information
for the project. If the information is correct, then select Finish to
complete the wizard and add the project to the solution (see Figure 3- 12).
Figure 3-12 Upscale Log final project settings.
8. The project is added to the solution with the previous one (See Figure
3- 13).
Figure 3-13 Solution with UpscaleWell project added.
40

9. You now have to change the project source to implement the process.
The InvokeSimpleCore method will be found in PropertyFromLog.cs.
Replace the “// TODO:” comment with the code in Figure 3- 14.
public void InvokeSimpleCore(PropertyFromLog.Arguments argumentPackage)
{
WellLog log = argumentPackage.WellLog;
Grid grid = argumentPackage.Grid;
Property prop = argumentPackage.OutputProperty;
// Create the property and return the number of cells intersected.
argumentPackage.CellsProcessed = UpscaleLog(log, grid, ref prop);
}
// Put the created property in the output argument.
argumentPackage.OutputProperty = prop;
Figure 3-14 Modified Invoke method.
10. There is a separate method called UpscaleLog that performs the
processing for this Workstep. The code for this method must be added
to the source file. It can be placed immediately after the code for the
InvokeSimpleCore method (see Figure 3- 15). Note that the output
Property variable “prop” is passed by reference to UpscaleLog.
private static int UpscaleLog(WellLog log, Grid grid, ref Property prop)
{
// Initialize counter for cells intersected.
int count = 0;
// Start a transaction for this process and lock the grid
ITransaction trans = DataManager.NewTransaction();
using (trans)
{
If (prop == null)
{
trans.Lock(grid);
// get log property version
PropertyVersion logpv = log.WellLogVersion;
// create the property and add it to the grid
// Construct its name from the well containing the log
prop = grid.CreateProperty(logpv);
// new property is locked implicitly.
prop. Name = "Upscale Prop " + log.Borehole.Name;
grid.AddProperty(prop);
}
else {
// lock the property so we can update it
trans.Lock(prop);
}
// create a hash table of the log samples in measured depth
Hashtable logLUT = new Hashtable();
// Dump the log values and MD values in the hash table
PetrelLogger.InfoOutputWindow("Log Values MD
Value");
foreach(WellLogSample sample in log.Samples)
{
logLUT[sample.MD] = sample.Value;
PetrelLogger.InfoOutputWindow(" " + sample.MD +
" " + sample.Value);
41

}
// intersect the log with the grid and return cells traversed
IEnumerable logInCells = log.GetLogInCells(grid);
// find the average value of the log in the cell
PetrelLogger.Info("******* Log in cells ********");
foreach(LogInCell lic in logInCells)
{
// get first and last log points in the cell and cell index
double MDIn = lic.MD_In;
double MDOut = lic.MD_Out;
Index3 ind = lic.Index;
// compute average of points entering and leaving cell
float avg = ((float)logLUT[MDIn] + (float)logLUT[MDOut])/2;
prop[ind] = avg;
}
// dump the result an increment the counter
PetrelLogger.InfoOutputWindow(MDIn + " " + logLUT[MDIn] +
" " + MDOut + " " + logLUT[MDOut] + " " +
ind.I + " " + ind.J + " " + ind.K + " " + avg );
count++;
}
// commit the transaction to save the data
trans.Commit();
}
return count;
11. Build the solution.
Figure 3-15 Code for private method UpscaleLog
3.3. Running the Examples
When the example projects were created the petrel.exe.config file was updated
by the wizard with the module name and assembly. The wizard also set up the
projects in Visual Studio to start Petrel when you start debugging. Perform the
following tasks to run the examples:
1. Start debugging from Visual Studio after building the solution. If you
prefer not to debug you may start Petrel outside Visual Studio.
2. Open a project in Petrel that has a Point set object in the Petrel
Explorer Input tab (see Figure 3- 16). If no Point set object is available,
then use the Process diagram Utilities folder Make/Edit polygons
process to create one. Use a 3D object to place your points in space.
42

Figure 3-16 Point set object in Petrel Explorer.
43

3. Start the WellFromPoints process by double clicking on it in the Petrel
Process manager. It will start and its user interface dialog will be
displayed (see Figure 3-17).
double-click to start
Figure 3-17 WellFromPoints in Process Manager and its UI dialog.
44

4. Fill in the arguments in the dialog by selecting the well collection in
Petrel Explorer and dropping it into the Borehole Collection field by
clicking the blue arrow next to the field. Repeat this for the Points object
and Input Points field. Then enter a name for the new Borehole (see
Figure 3- 18).
drag
drag
enter
name
Figure 3-18 Input arguments filled in for WellFromPoints
45

5. Select Apply to run the process and the well “Wildcat” will be created.
You may display it in a 3D window by turning on its checkbox. Turning
on the checkbox for the point set allows you to verify the borehole path
corresponds to the points in the point set (see Figure 3- 19).
Figure 3-19 WellFromPoints results displayed in 3D window.
46

6. Close the WellFromPoints dialog and open the PropertyFromLog dialog
by double clicking on it in the Process Manager window. It will start and
its interface will be displayed.
Figure 3-20 PropertyFromLog process startup and user interface.
47

7. Select a well log from one of the wells in the Petrel Explorer Input tab
and use the blue arrow drop icon to deposit it in the Well Log argument
field. Use the same procedure to drop a grid from the Petrel Explorer
Models tab into the Grid argument field.
Figure 3-21 Well log and grid inputs to PropertyFromLog.
48

8. Select Apply to run the process. It will produce output to the Message
window dumping the contents of the well log and values from the cells
in the output property. The Number of cells in the output property and
the Output Property name are displayed in the dialog (see Figure 3- 22).
Figure 3-22 Results of processing in PropertyFromLog.
49

9. The property created from the well log has the name “Upscale Prop
xxx” where “xxx” is the name of the borehole that contains the well log
used by the process. The property can be displayed by locating it in the
Petrel Explorer Models tab and turning on its check box when a 3D
window is active (see Figure 3- 23).
Figure 3-23 Property created in cells intersected by well log.
50

4. Help Resources and Debugging Hints
Ocean for Petrel provides resources to help the module developer in a variety of
forms. These range from online documentation to hardcopy books and training
classes.
4.1. Online Documentation
The online documentation for Ocean for Petrel is available from the Help menu
in the Petrel main window (see Figure 4- 1).
Figure 4-1 Accessing help for Ocean for Petrel.
51

Figure 4-2 Location of Ocean for Petrel online help file.
OceanPetrel Help will open the Ocean.chm file that is found in the “/Help”
subdirectory of the Ocean for Petrel installation directory (see Figure 4-2). You
can place a shortcut to this file on your desktop so you may view its contents
without having to first start Petrel.
Figure 4-3 Ocean for Petrel online help shown in browser.
52

When the Ocean for Petrel help is opened the contents of the compiled html
(.chm) file will be displayed in a browser window (see Figure 4- 3). The left side of
the window contains the hierarchy of topics in the file. There are four main topics
including an introduction, Ocean Core, Ocean Services, and Ocean Petrel. The
information for the topic that is selected in the left side of the window will be
displayed in the right side of the window.
The topics Ocean Core and Ocean Services contain information on the
infrastructure provided by Ocean that is available to all product families. The
Ocean Petrel topic contains information on the Petrel domain objects and user
interface components that are provided by Ocean Petrel.
The left side of the window has tabs for Contents, Index, Search, and Favorites.
Items listed in the Contents tab may be expanded or contracted by selecting the
“+” or “-“ respectively to the left of the item.
The Index tab provides an alphabetized list of major topics with subtopics where
available. Double clicking on an item in the Index will display the information for
that item.
The Search tab allows the user to search Ocean for Petrel Help for topics
matching the contents of the text field. You may use wildcards (*) in your search.
Hitting the Enter key or the List Topics button will trigger the search for the text
you’ve provided. Double clicking on a topic in the resulting list will display its
contents in the right side of the window.
The Favorites tab gives you the ability to save pointers to topics that you want to
return to later without having to work through the hierarchy. Display the topic you
want to save and select the Favorites tab. The current topic will be indicated at
the bottom of the left side of the window. Select the Add button to insert it in the
list of favorite topics. You can also remove topics from your Favorites list if
desired by selecting the topic and clicking the Remove button.
4.2. Hardcopy Documentation
Hardcopy documentation for Ocean for Petrel is available in the form of the
Ocean for Petrel Application Programmers Reference Guide.
4.3. Training
Training for Ocean for Petrel is available through the Schlumberger Information
Solutions Ocean Support team. The training class has as pre-requisites an
53

understanding of the Microsoft .Net environment, Visual Studio 2003, and the
C# language. It is also recommended that the Introduction to Petrel course be
taken first to provide a basic understanding of Petrel capabilities and use.
4.4. Debugging Hints
Congratulations! You have run the wizard and created your module. You are
adding your code and attempting to build, but the build is failing. Or, you have
built successfully but your new module is not appearing in the menu or Process
Diagram. Perhaps the process runs, but when you click the Apply button you
always get a bad argument error. What happened? Here are a few hints to help
you determine the source of your problem.
4.4.1. Build Failed
The build may fail for an infinite number of reasons. The most common is a
missing reference. While the wizard will add required references to your project
you may find it necessary to add more references based on the objects you are
using in the Ocean API. Refer to the OceanPetrel Help for the object in question
to determine its assembly. All Ocean assemblies start with “Slb.Ocean”. Domain
objects are found under “Slb.Ocean.Petrel...”.
4.4.2. Process Not Appearing in Process Diagram
The wizard will add your module to the petrel.exe.config file so you shouldn’t see
this problem with a module created by the wizard. However, it is common to
have multiple modules in an assembly and you must make sure that each
module is specified in the config file as a separate entry. If you used cut and
paste to create another module in your project (another implementation of
IModule), then you have to edit the config file by hand to add the module.
54