resqpy.unstructured.VerticalPrismGrid

class resqpy.unstructured.VerticalPrismGrid(parent_model, uuid=None, find_properties=True, cache_geometry=False, title=None, originator=None, extra_metadata={})

Bases: PrismGrid

Class for unstructured grids where every cell is a vertical triangular prism.

Notes

vertical prism cells are constrained to have a fixed triangular horzontal cross-section, though top and base triangular faces need not be horizontal; edges not involved in the triangular faces must be vertical; this is not a native RESQML sub-class but is a resqpy concoction to allow optimisation of some methods; face ordering within a cell is also constrained to be top, base, then the three vertical planar quadrilateral faces; node ordering within triangular faces is constrained to ensure correspondence of nodes in triangles within a column

Public Data Attributes:

Inherited from UnstructuredGrid

resqml_type

Inherited from BaseResqpy

resqml_type

part

Standard part name corresponding to self.uuid.

root

XML node corresponding to self.uuid.

citation_title

Citation block title equivalent to self.title.

Commonly Used Methods:

Inherited from UnstructuredGrid

__init__(parent_model[, uuid, ...])

Creates a new resqpy VerticalPrismGrid object.

cache_all_geometry_arrays()

Loads from hdf5 into memory all the arrays defining the grid geometry.

points_ref()

Returns an in-memory numpy array containing the xyz data for points used in the grid geometry.

xyz_box()

Returns the minimum and maximum xyz for the grid geometry.

centre_point([cell, cache_centre_array])

Returns centre point of a cell or array of centre points of all cells.

xy_units()

Returns the projected view (x, y) units of measure of the coordinate reference system for the grid.

z_units()

Returns the vertical (z) units of measure of the coordinate reference system for the grid.

write_hdf5([file, geometry, ...])

Write to an hdf5 file the datasets for the grid geometry and optionally properties from cached arrays.

create_xml([ext_uuid, add_as_part, ...])

Creates an unstructured grid node and optionally adds as a part in the model.

Methods:

__init__(parent_model[, uuid, ...])

Creates a new resqpy VerticalPrismGrid object.

from_surfaces(parent_model, surfaces[, ...])

Create a layered vertical prism grid from an ordered list of untorn surfaces.

from_seed_points_and_surfaces(parent_model, ...)

Create a layered vertical prism grid from seed points and an ordered list of untorn surfaces.

column_count()

Returns the number of columns in the grid.

cell_centre_point([cell])

Returns centre point of a single cell (or all cells) calculated as the mean position of its 6 nodes.

corner_points([cell])

Returns corner points for all cells or for a single cell.

thickness([cell])

Returns array of thicknesses of all cells or a single cell.

top_faces()

Returns the global face indices for the top triangular faces of the top layer of cells.

triangulation()

Returns triangulation used by this vertical prism grid.

triple_horizontal_permeability(primary_k, ...)

Returns array of triple horizontal permeabilities derived from a pair of permeability properties.

half_cell_transmissibility([use_property, ...])

Returns (and caches if realization is None) half cell transmissibilities for this vertical prism grid.

Inherited from PrismGrid

__init__(parent_model[, uuid, ...])

Creates a new resqpy VerticalPrismGrid object.

check_prism()

Checks that each cell has 5 faces and each face has 3 or 4 nodes.

Inherited from UnstructuredGrid

set_cell_count(n)

Set the number of cells in the grid.

active_cell_count()

Returns the number of cells deemed to be active for flow simulation purposes.

extract_crs_uuid()

Returns uuid for coordinate reference system, as stored in geometry xml tree.

extract_inactive_mask()

Returns boolean numpy array indicating which cells are inactive, if (in)active property found for this grid.

extract_property_collection()

Load grid property collection object holding lists of all properties in model that relate to this grid.

set_cells_per_face([check_all_faces_used])

Sets and returns the cells_per_face array showing which cells are using each face.

masked_cells_per_face(exclude_cell_mask)

Sets and returns the cells_per_face array showing which cells are using each face.

external_face_indices()

Returns a numpy int vector listing the indices of faces which are only used by one cell.

external_face_indices_for_masked_cells(...)

Returns a numpy int vector listing the indices of faces which are used by exactly one of masked cells.

internal_face_indices_for_masked_cells(...)

Returns a numpy int vector listing the indices of faces which are used by two of masked cells.

face_centre_point(face_index)

Returns a nominal centre point for a single face calculated as the mean position of its nodes.

face_count_for_cell(cell)

Returns the number of faces for a particular cell.

max_face_count_for_any_cell()

Returns the largest number of faces in use by any one cell.

node_count_for_face(face_index)

Returns the number of nodes for a particular face.

max_node_count_for_any_face()

Returns the largest number of nodes in use by any one face.

node_indices_for_face(face_index)

Returns numpy list of node indices for a single face.

distinct_node_indices_for_cell(cell)

Returns a numpy list of distinct node indices used by the faces of a single cell.

face_indices_for_cell(cell)

Returns numpy list of face indices for a single cell.

face_indices_and_handedness_for_cell(cell)

Returns numpy list of face indices for a single cell, and numpy boolean list of face right handedness.

edges_for_face(face_index)

Returns numpy list of pairs of node indices, each pair being one edge of the face.

edges_for_face_with_node_indices_ordered_within_pairs(...)

Returns numpy list of pairs of node indices, each pair being one edge of the face.

distinct_edges_for_cell(cell)

Returns numpy list of pairs of node indices, each pair being one distinct edge of the cell.

cell_face_centre_points(cell)

Returns a numpy array of centre points of the faces for a single cell.

face_normal(face_index)

Returns a unit vector normal to a planar approximation of the face.

planar_face_points(face_index[, xy_plane])

Returns points for a planar approximation of a face.

face_triangulation(face_index[, local_nodes])

Returns a Delauney triangulation of (a planar approximation of) a face.

area_of_face(face_index[, in_plane])

Returns the area of a face.

cell_centre_point([cell])

Returns centre point of a single cell (or all cells) calculated as the mean position of its 6 nodes.

volume(cell)

Returns the volume of a single cell.

check_indices()

Asserts that all node and face indices are within range.

adjusted_volume(v[, required_uom])

Returns volume adjusted for differing xy & z units in crs, and/or converted to required uom.

Inherited from BaseResqpy

__init__(parent_model[, uuid, ...])

Creates a new resqpy VerticalPrismGrid object.

try_reuse()

Look for an equivalent existing RESQML object and modify the uuid of this object if found.

create_xml([ext_uuid, add_as_part, ...])

Creates an unstructured grid node and optionally adds as a part in the model.

append_extra_metadata(meta_dict)

Append a given dictionary of metadata to the existing metadata.

__eq__(other)

Implements equals operator; uses is_equivalent() otherwise compares class type and uuid.

__ne__(other)

Implements not equal operator.

__repr__()

String representation.


__init__(parent_model, uuid=None, find_properties=True, cache_geometry=False, title=None, originator=None, extra_metadata={})[source]

Creates a new resqpy VerticalPrismGrid object.

Parameters
  • parent_model (model.Model object) – the model which this grid is part of

  • uuid (uuid.UUID, optional) – if present, the new grid object is populated from the RESQML object

  • find_properties (boolean, default True) – if True and uuid is present, a grid property collection is instantiated as an attribute, holding properties for which this grid is the supporting representation

  • cache_geometry (boolean, default False) – if True and uuid is present, all the geometry arrays are loaded into attributes of the new grid object

  • title (str, optional) – citation title for new grid; ignored if uuid is present

  • originator (str, optional) – name of person creating the grid; defaults to login id; ignored if uuid is present

  • extra_metadata (dict, optional) – dictionary of extra metadata items to add to the grid; ignored if uuid is present

Returns

a newly created VerticalPrismGrid object

active_cell_count()

Returns the number of cells deemed to be active for flow simulation purposes.

adjusted_volume(v, required_uom=None)

Returns volume adjusted for differing xy & z units in crs, and/or converted to required uom.

Note

if required_uom is not specified, units of returned value will be cube of crs units if xy & z are the same and either ‘m’ or ‘ft’, otherwise ‘m3’ will be used

append_extra_metadata(meta_dict)

Append a given dictionary of metadata to the existing metadata.

area_of_face(face_index, in_plane=False)

Returns the area of a face.

Parameters
  • face_index (int) – the index of the face for which the area is required

  • in_plane (boolean, default False) – if True, the area returned is the area of the planar approximation of the face; if False, the area is the sum of the areas of the triangulation of the face, which need not be planar

Returns

float being the area of the face

Notes

units of measure of the area is implied by the units of the crs in use by the grid

cache_all_geometry_arrays()

Loads from hdf5 into memory all the arrays defining the grid geometry.

Returns

None

Notes

call this method if much grid geometry processing is coming up; the arrays are cached as direct attributes to this grid object; the node and face indices make use of ‘jagged’ arrays (effectively an array of lists represented as a linear array and a ‘cumulative length’ index array)

cell_centre_point(cell=None)[source]

Returns centre point of a single cell (or all cells) calculated as the mean position of its 6 nodes.

Parameters

cell (int) – the index of the cell for which the centre point is required

Returns

numpy float array of shape (3,) being the xyz location of the centre point of the cell

cell_face_centre_points(cell)

Returns a numpy array of centre points of the faces for a single cell.

Parameters

cell (int) – the index of the cell for which face centre points are required

Returns

numpy array of shape (F, 3) being the xyz location of each of the F faces for the cell

Notes

the order of the returned face centre points matches the faces_per_cell for the cell; the returned values are nominal centre points for the faces - the mean position of their nodes - which are not generally their barycentres

centre_point(cell=None, cache_centre_array=False)

Returns centre point of a cell or array of centre points of all cells.

Optionally cache centre points for all cells.

Parameters
  • cell (optional) – if present, the cell number of the individual cell for which the centre point is required; zero based indexing

  • cache_centre_array (boolean, default False) – If True, or cell is None, an array of centre points is generated and added as an attribute of the grid, with attribute name array_centre_point

Returns

(x, y, z) 3 element numpy array of floats holding centre point of a single cell; or numpy 2D array of shape (cell_count, 3) if cell is None

Notes

a simple mean of the nominal centres of the faces is used to calculate the centre point of a cell; this is not generally the barycentre of the cell; resulting coordinates are in the same (local) crs as the grid points

check_indices()

Asserts that all node and face indices are within range.

check_prism()

Checks that each cell has 5 faces and each face has 3 or 4 nodes.

Note

currently only performs a cursory check, without checking nodes are shared or that there are exactly two triangular faces without shared nodes

property citation_title

Citation block title equivalent to self.title.

column_count()[source]

Returns the number of columns in the grid.

corner_points(cell=None)[source]

Returns corner points for all cells or for a single cell.

Parameters

cell (int, optional) – cell index of single cell for which corner points are required; if None, corner points are returned for all cells

Returns

numpy float array of shape (2, 3, 3) being xyz points for top & base points for one cell, or numpy float array of shape (N, 2, 3, 3) being xyz points for top & base points for all cells

create_xml(ext_uuid=None, add_as_part=True, add_relationships=True, title=None, originator=None, write_active=True, write_geometry=True, extra_metadata={})

Creates an unstructured grid node and optionally adds as a part in the model.

Parameters
  • ext_uuid (uuid.UUID, optional) – the uuid of the hdf5 external part holding the array data for the grid geometry

  • add_as_part (boolean, default True) – if True, the newly created xml node is added as a part in the model

  • add_relationships (boolean, default True) – if True, relationship xml parts are created relating the new grid part to: the crs, and the hdf5 external part

  • title (string) – used as the citation title text; careful consideration should be given to this argument when dealing with multiple grids in one model, as it is the means by which a human will distinguish them

  • originator (string, optional) – the name of the human being who created the unstructured grid part; default is to use the login name

  • write_active (boolean, default True) – if True, xml for an active cell property is also generated, but only if the active_property_uuid is set and no part exists in the model for that uuid

  • write_geometry (boolean, default True) – if False, the geometry node is omitted from the xml

  • extra_metadata (dict) – any key value pairs in this dictionary are added as extra metadata xml nodes

Returns

the newly created unstructured grid xml node

Notes

the write_active argument should generally be set to the same value as that passed to the write_hdf5… method; the RESQML standard allows the geometry to be omitted for a grid, controlled here by the write_geometry argument; the explicit geometry may be omitted for unstructured grids, in which case the arrays should not be written to the hdf5 file either

distinct_edges_for_cell(cell)

Returns numpy list of pairs of node indices, each pair being one distinct edge of the cell.

Parameters

cell (int) – the index of the cell

Returns

numpy int array of shape (E, 2) being the node indices identifying the E edges of the cell

Note

within each pair, the two node indices are ordered with the lower index first

distinct_node_indices_for_cell(cell)

Returns a numpy list of distinct node indices used by the faces of a single cell.

Parameters

cell (int) – the index of the cell for which distinct node indices are required

Returns

numpy int array of shape (N, ) being the indices of N distinct nodes used by the cell’s faces

Note

the returned array is sorted by increasing node index

edges_for_face(face_index)

Returns numpy list of pairs of node indices, each pair being one edge of the face.

Parameters

face_index (int) – the index of the face (as used in faces_per_cell and implicitly in nodes_per_face)

Returns

numpy int array of shape (N, 2) being the node indices identifying the N edges of the face

Notes

the order of the pairs follows the order of the nodes for the face; within each pair, the order of the two node indices also follows the order of the nodes for the face

edges_for_face_with_node_indices_ordered_within_pairs(face_index)

Returns numpy list of pairs of node indices, each pair being one edge of the face.

Parameters

face_index (int) – the index of the face (as used in faces_per_cell and implicitly in nodes_per_face)

Returns

numpy int array of shape (N, 2) being the node indices identifying the N edges of the face

Notes

the order of the pairs follows the order of the nodes for the face; within each pair, the two node indices are ordered with the lower index first

external_face_indices()

Returns a numpy int vector listing the indices of faces which are only used by one cell.

Note

resulting array is ordered by face index

external_face_indices_for_masked_cells(exclude_cell_mask)

Returns a numpy int vector listing the indices of faces which are used by exactly one of masked cells.

Parameters
  • exclude_cell_mask (numpy bool array of shape (cell_count,)) – cells with a value True in this array

  • result (are excluded when populating the) –

Note

resulting array is ordered by face index

extract_crs_uuid()

Returns uuid for coordinate reference system, as stored in geometry xml tree.

Returns

uuid.UUID object

extract_inactive_mask()

Returns boolean numpy array indicating which cells are inactive, if (in)active property found for this grid.

Returns

numpy array of booleans, of shape (cell_count,) being True for cells which are inactive; False for active

Note

RESQML does not have a built-in concept of inactive (dead) cells, though the usage guide advises to use a discrete property with a local property kind of ‘active’; this resqpy code can maintain an ‘inactive’ attribute for the grid object, which is a boolean numpy array indicating which cells are inactive

extract_property_collection()

Load grid property collection object holding lists of all properties in model that relate to this grid.

Returns

resqml_property.PropertyCollection object

Note

a reference to the grid property collection is cached in this grid object; if the properties change, for example by generating some new properties, the property_collection attribute of the grid object would need to be reset to None elsewhere before calling this method again

face_centre_point(face_index)

Returns a nominal centre point for a single face calculated as the mean position of its nodes.

Parameters

face_index (int) – the index of the face (as used in faces_per_cell and implicitly in nodes_per_face)

Returns

numpy float array of shape (3,) being the xyz location of the centre point of the face

Note

this returns a nominal centre point for a face - the mean position of its nodes - which is not generally its barycentre

face_count_for_cell(cell)

Returns the number of faces for a particular cell.

face_indices_and_handedness_for_cell(cell)

Returns numpy list of face indices for a single cell, and numpy boolean list of face right handedness.

Parameters

cell (int) – the index of the cell for which face indices are required

Returns

numpy int array of shape (F,), numpy boolean array of shape (F, ) – being the face indices of each of the F faces for the cell, and the right handedness (clockwise order) of the face nodes when viewed from within the cell

Note

the face indices are used when accessing the nodes per face data and can also be used to identify shared faces; the handedness (clockwise or anti-clockwise ordering of nodes) is significant for some processing of geometry such as volume calculations

face_indices_for_cell(cell)

Returns numpy list of face indices for a single cell.

Parameters

cell (int) – the index of the cell for which face indices are required

Returns

numpy int array of shape (F,) being the face indices of each of the F faces for the cell

Note

the face indices are used when accessing the nodes per face data and can also be used to identify shared faces

face_normal(face_index)

Returns a unit vector normal to a planar approximation of the face.

Parameters

face_index (int) – the index of the face (as used in faces_per_cell and implicitly in nodes_per_face)

Returns

numpy float array of shape (3,) being the xyz components of a unit length vector normal to the face

Note

in the case of a degenerate face, a zero length vector is returned; the direction of the normal will be into or out of the cell depending on the handedness of the cell face; the direction of the vector is a true normal, accounting for any difference in xy & z units

face_triangulation(face_index, local_nodes=False)

Returns a Delauney triangulation of (a planar approximation of) a face.

Parameters
  • face_index (int) – the index of the face for which a triangulation is required

  • local_nodes (boolean, default False) – if True, the returned node indices are local to the face nodes, ie. can index into node_indices_for_face(); if False, the returned node indices are the global node indices in use by the grid

Returns

numpy int array of shape (N - 2, 3) being the node indices of the triangulation, where N is the number of nodes defining the face

classmethod from_seed_points_and_surfaces(parent_model, seed_xy, surfaces, area_of_interest, title=None, originator=None, extra_metadata={}, set_handedness=False)[source]

Create a layered vertical prism grid from seed points and an ordered list of untorn surfaces.

Parameters
  • parent_model (model.Model object) – the model which this grid is part of

  • seed_xy (numpy float array of shape (N, 2 or 3)) – the xy locations of seed points

  • surfaces (list of surface.Surface) – list of two or more untorn surfaces ordered from shallowest to deepest; see notes

  • area_of_interest (closed convex Polyline) – the frontier polygon in the xy plane

  • title (str, optional) – citation title for the new grid

  • originator (str, optional) – name of person creating the grid; defaults to login id

  • extra_metadata (dict, optional) – dictionary of extra metadata items to add to the grid

Returns

a newly created VerticalPrismGrid object

Notes

the triangular pattern of the columns (in the xy plane) is constructed as a re-triangulation of the Voronoi diagram of the Delauney triangulation of the seed points; the seed points may be xy or xyz data but z is ignored; this method will not work for torn (faulted) surfaces, nor for surfaces with recumbent folds; the surfaces may not cross each other, ie. the depth ordering must be consistent over the area; all the seed points must lie wholly within the area of interest; where a gravity vector from a node above does not intersect a surface, the point is inherited as a copy of the node above (the topmost surface must cover the entire area of interest); the Surface class has methods for creating a Surface from a PointSet or a Mesh (RESQML Grid2dRepresentation), or for a horizontal plane

classmethod from_surfaces(parent_model, surfaces, column_points=None, column_triangles=None, title=None, originator=None, extra_metadata={}, set_handedness=False)[source]

Create a layered vertical prism grid from an ordered list of untorn surfaces.

Parameters
  • parent_model (model.Model object) – the model which this grid is part of

  • surfaces (list of surface.Surface) – list of two or more untorn surfaces ordered from shallowest to deepest; see notes

  • column_points (2D numpy float array, optional) – if present, the xy points to use for the grid’s triangulation; see notes

  • column_triangles (numpy int array of shape (M, 3), optional) – if present, indices into the first dimension of column_points giving the xy triangulation to use for the grid; see notes

  • title (str, optional) – citation title for the new grid

  • originator (str, optional) – name of person creating the grid; defaults to login id

  • extra_metadata (dict, optional) – dictionary of extra metadata items to add to the grid

Returns

a newly created VerticalPrismGrid object

Notes

this method will not work for torn (faulted) surfaces, nor for surfaces with recumbent folds; the surfaces may not cross each other, ie. the depth ordering must be consistent over the area; the triangular pattern of the columns (in the xy plane) can be specified with the column_points and column_triangles arguments; if those arguments are None, the first, shallowest, surface is used as a master and determines the triangular pattern of the columns; where a gravity vector from a node above does not intersect a surface, the point is inherited as a copy of the node above and will be NaNs if no surface above has an intersection; the Surface class has methods for creating a Surface from a PointSet or a Mesh (RESQML Grid2dRepresentation), or for a horizontal plane; this class is represented in RESQML as an UnstructuredGridRepresentation – when a resqpy class is written for ColumnLayerGridRepresentation, a method will be added to that class to convert from a resqpy VerticalPrismGrid

half_cell_transmissibility(use_property=True, realization=None, tolerance=1e-06)[source]

Returns (and caches if realization is None) half cell transmissibilities for this vertical prism grid.

Parameters
  • use_property (boolean, default True) – if True, the grid’s property collection is inspected for a possible half cell transmissibility array and if found, it is used instead of calculation

  • realization (int, optional) –

  • tolerance (float, default 1.0e-6) – minimum half axis length below which the transmissibility will be deemed uncomputable (for the axis in question); NaN values will be returned (not Inf); units are implicitly those of the grid’s crs length units

Returns

numpy float array of shape (N, 5) where N is the number of cells in the grid and the 5 covers the faces of a cell in the order of the faces_per_cell data; units will depend on the length units of the coordinate reference system for the grid; the units will be m3.cP/(kPa.d) or bbl.cP/(psi.d) for grid length units of m and ft respectively

Notes

this method does not write to hdf5, nor create a new property or xml; if realization is None, a grid attribute cached array will be used; tolerance will only be used if the half cell transmissibilities are actually computed

internal_face_indices_for_masked_cells(exclude_cell_mask)

Returns a numpy int vector listing the indices of faces which are used by two of masked cells.

Parameters
  • exclude_cell_mask (numpy bool array of shape (cell_count,)) – cells with a value True in this array

  • result (are excluded when populating the) –

Note

resulting array is ordered by face index

masked_cells_per_face(exclude_cell_mask)

Sets and returns the cells_per_face array showing which cells are using each face.

Parameters
  • exclude_cell_mask (numpy bool array of shape (cell_count,)) – cells with a value True in this array

  • result (are excluded when populating the) –

Returns

numpy int array of shape (face_count, 2) showing upto 2 cell indices for each face index; -1 is a null value; if only one cell uses a face, its index is always in position 0 of the second axis

Note

this method recomputes the result on every call - nothing extra is cached in the grid

max_face_count_for_any_cell()

Returns the largest number of faces in use by any one cell.

max_node_count_for_any_face()

Returns the largest number of nodes in use by any one face.

node_count_for_face(face_index)

Returns the number of nodes for a particular face.

node_indices_for_face(face_index)

Returns numpy list of node indices for a single face.

Parameters

face_index (int) – the index of the face (as used in faces_per_cell and implicitly in nodes_per_face)

Returns

numpy int array of shape (N,) being the node indices identifying the vertices of the face

Note

the node indices are used to index the points data (points_cached attribute); ordering of returned nodes is clockwise or anticlockwise when viewed from within the cell, as indicated by the entry in the cell_face_is_right_handed array

property part

Standard part name corresponding to self.uuid.

planar_face_points(face_index, xy_plane=False)

Returns points for a planar approximation of a face.

Parameters
  • face_index (int) – the index of the face for which a planar approximation is required

  • xy_plane (boolean, default False) – if True, the returned points lie in a horizontal plane with z = 0.0; if False, the plane is located approximately in the position of the original face, with the same normal direction

Returns

numpy float array of shape (N, 3) being the xyz points of the planar face nodes corresponding to the N nodes of the original face, in the same order

points_ref()

Returns an in-memory numpy array containing the xyz data for points used in the grid geometry.

Returns

numpy array of shape (node_count, 3)

Notes

this is the usual way to get at the actual grid geometry points data in the native RESQML layout; the array is cached as an attribute of the grid object

property root

XML node corresponding to self.uuid.

set_cell_count(n: int)

Set the number of cells in the grid.

Parameters

n (int) – the number of cells in the unstructured grid

Note

only call this method when creating a new grid, not when working from an existing RESQML grid

set_cells_per_face(check_all_faces_used=True)

Sets and returns the cells_per_face array showing which cells are using each face.

Parameters

check_all_faces_used (boolean, default True) – if True, an assertion error is raised if there are any faces which do not appear in any cells

Returns

numpy int array of shape (face_count, 2) showing upto 2 cell indices for each face index; -1 is a null value; if only one cell uses a face, its index is always in position 0 of the second axis

thickness(cell=None)[source]

Returns array of thicknesses of all cells or a single cell.

Note

units are z units of crs used by this grid

top_faces()[source]

Returns the global face indices for the top triangular faces of the top layer of cells.

triangulation()[source]

Returns triangulation used by this vertical prism grid.

Returns

numpy int array of shape (M, 3) being the indices into the grid points of the triangles forming the top faces of the top layer of cells of the grid

Notes

use points_ref() to access the full points data; the order of the first axis of the returned values will match the order of the columns within cell related data

triple_horizontal_permeability(primary_k, orthogonal_k, primary_azimuth=0.0)[source]

Returns array of triple horizontal permeabilities derived from a pair of permeability properties.

Parameters
  • primary_k (numpy float array of shape (N,) –

  • orthogonal_k (numpy float array of shape (N,) – direction orthogonal to the primary permeability

  • primary_azimuth (float or numpy float array of shape (N,), default 0.0) – the azimuth(s) of the primary permeability, in degrees compass bearing

Returns

numpy float array of shape (N, 3) being the triple horizontal permeabilities applicable to half cell horizontal transmissibilities

Notes

this method should be used to generate horizontal permeabilities for use in transmissibility calculations if starting from an anisotropic permeability defined by a pair of locally orthogonal values; resulting values will be locally bounded by the pair of source values; the order of the 3 values per cell follows the node indices for the top triangle, for the opposing vertical face; no net to gross ratio modification is applied here;

try_reuse()

Look for an equivalent existing RESQML object and modify the uuid of this object if found.

Returns

boolean – True if an equivalent object was found, False if not

Note

by design this method may change this object’s uuid as a side effect

volume(cell)

Returns the volume of a single cell.

Parameters

cell (int) – the index of the cell for which the volume is required

Returns

float being the volume of the cell; units of measure is implied by crs units

Note

this is a computationally expensive method

write_hdf5(file=None, geometry=True, imported_properties=None, write_active=None)

Write to an hdf5 file the datasets for the grid geometry and optionally properties from cached arrays.

xy_units()

Returns the projected view (x, y) units of measure of the coordinate reference system for the grid.

xyz_box()

Returns the minimum and maximum xyz for the grid geometry.

Returns

numpy array of float of shape (2, 3); the first axis is minimum, maximum; the second axis is x, y, z

z_units()

Returns the vertical (z) units of measure of the coordinate reference system for the grid.

title

Citation title

originator

Creator of object. By default, user id.

uuid

Unique identifier