Prefix and Property options for Plugins

Referencing cell and connection properties in plugins

Fault permeability and fault rock thickness, which are essential to the transmissibility calculations performed by TransGen, MUST be calculated in the PERM and THICK plugins respectively. Other properties can also be calculated in plugins, but there is no obligation to do so.

Cell and connection properties must be referred to in plugins using the correct format.
This is:-
prefix.property

The prefix identifies which internally stored array within TransGen to access.
The property tells C++ which of the internally stored values associated with a particular cell or connection is being referenced.

C++ is a case sensitive language. All prefix and property names should be used in lower-case.

NOTE:- Two-Phase plugins do NOT use variable prefixes at all - see Two-Phase documentation. Only trace properties are available for use in DRAG and FZONE plugins (see Table of trace properties) and must be referred to using the "t." prefix.

Prefixes for Cell Properties

Any of the following 5 prefixes can be used in the PERM, THICK and AREA plugins. However, none of these prefixes are accepted by the CELLPROP plugin, where all cell properties MUST be prefixed by "cell" to take the variable value of that cell. The "cell" prefix can also be used for cell properties in an AREA plugin, but not in either the PERM or THICK plugins.

Prefixes for Connection Properties

The following prefixes associated with connections are shown below. The v.prefix cannot be used in the AREA plugin.

Properties available to different plugins

The following lists show the suitability of various property types as input to/output from the various plugins.

NOTE:- If an unsuitable data type is called on in a particular plugin, no error message is reported and the plugin will compile and run successfully. However, the output will in all likelihood be meaningless.

Cell properties as input and output

Certain cell properties must be loaded into TransGen as they influence the transmissibility calculations (e.g. PERMX, PERMY). Certain other properties are calculated by TransGen as a function of the model geometry (e.g. j, depth). These two types of property can always be used in all plugins.

Other grid block property names are recognized by TransGen although they are not essential input (e.g. PORO, ACTNUM, MULTX). If these are referred to in a plugin, but have not been loaded, they are assigned a default value (as shown below).

HINT:- See Including Transmissibility Multipliers from Eclipse for a description of the way TransGen treats MULTX and MULTY. This treatment is new to TransGen Version 3.

Any user-defined cell property introduced via the User-defined keywords page of WizGen in Flexible project mode is initially assigned a default value 0.0. This can be modified before any plugins are run by defining its value in each cell through an input file (see including User-defined Cell Property files via the Included Data page), or its value can be modified by calculation in a plugin. If a user-defined cell property is used as input to a calculation in a plugin, it has the value assigned at that particular stage of the calculation. As described previously, it is very important to appreciate the order in which plugins are run: first CELLPROP, then THICK, then PERM, then AREA.

NOTE:- User-defined cell properties are treated in the same way as other cell properties with the important difference that they may be output as well as input. These are the only type of grid-block property that can be modified, all others are read only.

Fault connection properties available to plugins

Most fault properties calculated by TransGen are stored internally both as connection vertex properties (e.g. v.thick, v.displ, v.fsp1) and as average connection properties (e.g. c.thick, c.displ, c.fsp1). The exceptions are direction and area (i.e. c.dir and c.area), for which a value at the vertex is meaningless. However, user-defined connection properties are only stored as connection averages, e.g. c.user_defined_connection. Therefore, there is NO v.user_defined_connection definition available for use in plugins.

Fault connection properties as input and output

Fault connection information has two kinds of prefix, connection averages (c.property) and connection vertex (v.property).

Before the THICK, PERM, and AREA plugins are run, any properties stored at vertices (i.e. displacement, thickness, permeability and FSP measures) will have been averaged to provide a connection average property representative of the values at the vertices of the connection after the last plugin has been run.

Hence, if a property, v.fsp1, is modified in each of the three plugins that reference faults:-

In the THICK plugin, the values for c.fsp1 represent the averages of the values of v.fsp1 calculated in the TGFSP keyword;

In the PERM plugin, the values of c.fsp1 represent the averages of the values of v.fsp1 calculated in the THICK plugin

In the AREA plugin, the values of c.fsp1 in the AREA plugin represent the averages of the values of v.fsp1 calculated in the PERM plugin.

User-defined connection properties are assigned initial defaulted values of -1.0, representative of undefined connections. If no data have been loaded for these connections (see including User-defined Connection Property files via the Included Data page), they have a value of -1.0 when they are called in plugins. Their values may, of course, be updated in the plugins.

NOTE:- Fault properties CANNOT be used as input to or output from a CELLPROP plugin.

Using Fault connection properties in the THICK & PERM plugins

The THICK plugin should be used to calculate fault rock thickness and the PERM plugin used to calculate fault rock permeability. Both these plugins MUST be included in the TransGen run file.

Permeability and thickness must be calculated on connection vertices, using code such as:-

v.thick = 0.005882 * v.displ;

which simply defines fault rock thickness to be a fraction of fault displacement, and:-

double term1;
double term2;

term1 = 0.4   4.0 * v.sgr;
term2 = pow(1 - v.sgr, 5.0);

v.perm = pow(10.0, term1 - 0.25*term2);

which calculates fault rock permeability as a function of SGR using the expression:-

See section on C++ language use in plugins for information about the language and logic of writing plugins.

Outputting properties stored at vertices

Both connection average (c.property) and connection vertex (v.property) properties can be used as input to the THICK and PERM plugins. If both are available, we recommend that vertex properties be used to calculate other vertex properties (e.g. thick, perm or to modify properties generated with the TGFSP keyword) as this ensures greater precision. There is no problem, however, with using connection average properties to calculate vertex properties if a vertex property does not exist. For example:-

v.perm = v.fsp1 + c.user1;

is ideal, and

v.perm = c.fsp1 + c.user1;

is acceptable but not recommended as it is less precise.

The commands:-

c.perm = v.fsp1 + c.user1;

or

c.perm = c.fsp1 + c.user1;

should never be used, as perm is stored at vertices as well as connections.

If a fault connection property is stored at both vertices and connections, the connection average properties should NOT be used as output. This is because the property is averaged as a function of the values at the connection vertices after the plugin has been run and the averaging will overwrite the existing connection averages. Therefore, any connection averages modified in the THICK or PERM plugin for these properties will later be overwritten during the averaging process.

Connection properties stored at both vertices and as connection averages that are available as output are fault rock thickness (called thick in plugins), fault rock permeability (called perm in plugins) and the FSP measures.

Outputting properties that are stored only as connection average values

Vertex properties should generally be avoided if calculating fault properties that only exist as averages (e.g. the values of user-defined connections). This is because the PERM and THICK plugins are run on every vertex of every connection, so a command such as:-

c.user1 = v.fsp1 + v.fsp2;

would continually update the value of the user-defined property as each vertex is processed and the final value would depend only on the last vertex processed. It is therefore not appropriate to the connection as a whole. Instead the command:-

c.user1 = c.fsp1 + c.fsp2;

should be used.

There are exceptions to this rule. An example would be if a user-defined connection property is defined to store the maximum FSP value present on a connection. In this case the code:-

if (v.fsp1 > c.user1) {
   c.user1 = v.fsp1;
}

would set the user-defined connection property user1 (which has the initial default value of -1.0) to the maximum value of fsp1 present on the connection vertices.