resqpy 4.14.2__py3-none-any.whl → 5.1.5__py3-none-any.whl

resqpy/olio/vector_utilities.py

@@ -13,8 +13,8 @@ log = logging.getLogger(__name__)
 import math as maths
 import numpy as np
 import numba  # type: ignore
-from numba import njit  # type: ignore
-from typing import Tuple, Optional
+from numba import njit, prange  # type: ignore
+from typing import Tuple, Optional, List
 
 
 def radians_from_degrees(deg):
@@ -952,13 +952,13 @@ def triangle_box(triangle: np.ndarray) -> Tuple[float, float, float, float]:  #
     """
     x_values = triangle[:, 0]
     y_values = triangle[:, 1]
-    return min(x_values), max(x_values), min(y_values), max(y_values)
+    return np.min(x_values), np.max(x_values), np.min(y_values), np.max(y_values)
 
 
 @njit
 def vertical_intercept(x: float, x_values: np.ndarray, y_values: np.ndarray) -> Optional[float]:  # pragma: no cover
     """Finds the y value of a straight line between two points at a given x.
-    
+
     If the x value given is not within the x values of the points, returns None.
 
     arguments:
@@ -982,8 +982,81 @@ def vertical_intercept(x: float, x_values: np.ndarray, y_values: np.ndarray) ->
 
 
 @njit
-def points_in_triangles_aligned_optimised(nx: int, ny: int, dx: float, dy: float,
-                                          triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
+def vertical_intercept_nan(x: float, x_value_0: float, x_value_1: float, y_value_0: float,
+                           y_value_1: float) -> float:  # pragma: no cover
+    """Finds the y value of a straight line between two points at a given x.
+
+    If the x value given is not within the x values of the points, returns NaN.
+
+    arguments:
+        x (float): x value at which to determine the y value
+        x_value_0 (np.ndarray): the x coordinate of point 1
+        x_value_1 (np.ndarray): the x coordinate of point 2
+        y_value_0 (np.ndarray): the y coordinate of point 1
+        y_value_1 (np.ndarray): the y coordinate of point 2
+
+    returns:
+        y (float): y value of the straight line segment between point 1 and point 2,
+            evaluated at x; if x is outside the x values range, y is NaN
+    """
+    y = np.nan
+    if x_value_1 < x_value_0:
+        x_value_0, x_value_1 = x_value_1, x_value_0
+        y_value_0, y_value_1 = y_value_1, y_value_0
+    if x >= x_value_0 and x <= x_value_1:
+        if x_value_0 == x_value_1:
+            y = y_value_0
+        else:
+            m = (y_value_1 - y_value_0) / (x_value_1 - x_value_0)
+            c = y_value_1 - m * x_value_1
+            y = m * x + c
+    return y
+
+
+@njit
+def vertical_intercept_nan_yz(x: float, x_0: float, x_1: float, y_0: float, y_1: float, z_0: float,
+                              z_1: float) -> Tuple[float, float]:  # pragma: no cover
+    """Finds the y & z values of a straight line between two points at a given x.
+
+    If the x value given is not within the x values of the points, returns NaN.
+
+    arguments:
+        x (float): x value at which to determine the y value
+        x_0 (float): the x coordinate of point a
+        x_1 (float): the x coordinate of point b
+        y_0 (float): the y coordinate of point a
+        y_1 (float): the y coordinate of point b
+        z_0 (float): the z coordinate of point a
+        z_1 (float): the z coordinate of point b
+
+    returns:
+        y, z (float, float): y & z values of the straight line segment between point a and point b,
+            evaluated at x; if x is outside the x values range, y & z are NaN
+    """
+    y = np.nan
+    z = np.nan
+    if x_1 < x_0:
+        x_0, x_1 = x_1, x_0
+        y_0, y_1 = y_1, y_0
+        z_0, z_1 = z_1, z_0
+    if x >= x_0 and x <= x_1:
+        if x_0 == x_1:
+            y = y_0
+            z = z_0
+        else:
+            xr = x_1 - x_0
+            m = (y_1 - y_0) / xr
+            c = y_1 - m * x_1
+            y = m * x + c
+            m = (z_1 - z_0) / xr
+            c = z_1 - m * x_1
+            z = m * x + c
+    return (y, z)
+
+
+@njit
+def points_in_triangles_aligned_optimised_old(nx: int, ny: int, dx: float, dy: float,
+                                              triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
     """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
 
     arguments:
@@ -1023,6 +1096,249 @@ def points_in_triangles_aligned_optimised(nx: int, ny: int, dx: float, dy: float
     return triangles_points
 
 
+@njit
+def points_in_triangles_aligned_optimised_serial(nx: int, ny: int, dx: float, dy: float,
+                                                 triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
+    """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
+
+    arguments:
+        nx (int): number of points in x axis
+        ny (int): number of points in y axis
+        dx (float): spacing of points in x axis (first point is at half dx)
+        dy (float): spacing of points in y axis (first point is at half dy)
+        triangles (np.ndarray): float array of each triangles' vertices in 2D, shape (N, 3, 2)
+
+    returns:
+        triangles_points (np.ndarray): 2D array (list-like) containing only the points within each triangle,
+            with each row being the triangle number, points y index, and points x index
+    """
+    triangles = triangles.copy()
+    triangles[..., 0] /= dx
+    triangles[..., 1] /= dy
+    triangles -= 0.5
+    triangles_points_list = []
+    for triangle_num in range(len(triangles)):
+        triangle = triangles[triangle_num]
+        min_x, max_x, min_y, max_y = triangle_box(triangle)
+        for xi in range(max(maths.ceil(min_x), 0), min(maths.floor(max_x) + 1, nx)):
+            x = float(xi)
+            e0_y = vertical_intercept_nan(x, triangle[1, 0], triangle[2, 0], triangle[1, 1], triangle[2, 1])
+            e1_y = vertical_intercept_nan(x, triangle[0, 0], triangle[1, 0], triangle[0, 1], triangle[1, 1])
+            e2_y = vertical_intercept_nan(x, triangle[0, 0], triangle[2, 0], triangle[0, 1], triangle[2, 1])
+            ey_list = np.array([e0_y, e1_y, e2_y], dtype = np.float64)
+            floor_y = np.nanmin(ey_list)
+            ceil_y = np.nanmax(ey_list)
+            triangles_points_list.extend(
+                [[triangle_num, y, xi] for y in range(max(maths.ceil(floor_y), 0), min(maths.floor(ceil_y) + 1, ny))])
+
+    if len(triangles_points_list) == 0:
+        triangles_points = np.empty((0, 3), dtype = np.int32)
+    else:
+        triangles_points = np.array(triangles_points_list, dtype = np.int32)
+
+    return triangles_points
+
+
+@njit(parallel = True)
+def points_in_triangles_aligned_optimised(nx: int,
+                                          ny: int,
+                                          dx: float,
+                                          dy: float,
+                                          triangles: np.ndarray,
+                                          n_batches: int = 20) -> np.ndarray:  # pragma: no cover
+    """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
+
+    arguments:
+        nx (int): number of points in x axis
+        ny (int): number of points in y axis
+        dx (float): spacing of points in x axis (first point is at half dx)
+        dy (float): spacing of points in y axis (first point is at half dy)
+        triangles (np.ndarray): float array of each triangles' vertices in 2D, shape (N, 3, 2)
+        n_batches (int, default 20): number of parallel batches
+
+    returns:
+        triangles_points (np.ndarray): 2D array (list-like) containing only the points within each triangle,
+            with each row being the triangle number, points y index, and points x index
+    """
+    n_triangles = len(triangles)
+    if n_triangles == 0:
+        return np.empty((0, 3), dtype = np.int32)
+    triangles = triangles.copy()
+    triangles[..., 0] /= dx
+    triangles[..., 1] /= dy
+    triangles -= 0.5
+    n_batches = min(n_triangles, n_batches)
+    batch_size = (n_triangles - 1) // n_batches + 1
+    tp = [np.empty((0, 3), dtype = np.int32)] * n_batches
+    for batch in prange(n_batches):
+        base = batch * batch_size
+        tp[batch] = _points_in_triangles_aligned_optimised_batch(nx, ny, base, triangles[base:(batch + 1) * batch_size])
+    collated = np.empty((0, 3), dtype = np.int32)
+    for batch in range(n_batches):
+        collated = np.concatenate((collated, tp[batch]), axis = 0)
+    return collated
+
+
+@njit(parallel = True)
+def points_in_triangles_aligned_unified(nx: int,
+                                        ny: int,
+                                        ax: int,
+                                        ay: int,
+                                        az: int,
+                                        triangles: np.ndarray,
+                                        n_batches: int = 20) -> Tuple[np.ndarray, np.ndarray]:  # pragma: no cover
+    """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
+
+    arguments:
+        - nx (int): number of points in x axis
+        - ny (int): number of points in y axis
+        - ax (int): 'x' axis selection (0, 1, or 2)
+        - ay (int): 'y' axis selection (0, 1, or 2)
+        - az (int): 'z' axis selection (0, 1, or 2)
+        - triangles (np.ndarray): float array of each triangles' normalised vertices in 3D, shape (N, 3, 3)
+        - n_batches (int, default 20): number of parallel batches
+
+    returns:
+        list like int array with each row being (tri number, axis 'y' int, axis 'x' int), and
+        corresponding list like float array being axis 'z' sampled at point on triangle
+        
+    notes:
+        - actual axes to use for x, y, & z are determined by the ax, ay, & az arguments
+        - 0, 1, & 2 must appear once each amongst the ax, ay, & az arguments
+        - triangles points have already been normalised to a unit grid spacing and offset by half a cell
+        - returned 'z' values are in normalised form
+        - to denormalize 'z' values, add 0.5 and multiply by the actual cell length in the corresponding axis
+    """
+    n_triangles = len(triangles)
+    if n_triangles == 0:
+        return np.empty((0, 3), dtype = np.int32), np.empty((0,), dtype = np.float64)
+    n_batches = min(n_triangles, n_batches)
+    batch_size = (n_triangles - 1) // n_batches + 1
+    tp = [np.empty((0, 3), dtype = np.int32)] * n_batches
+    tz = [np.empty((0,), dtype = np.float64)] * n_batches
+    for batch in prange(n_batches):
+        base = batch * batch_size
+        tp[batch], tz[batch] = _points_in_triangles_aligned_unified_batch(nx, ny, base,
+                                                                          triangles[base:(batch + 1) * batch_size], ax,
+                                                                          ay, az)
+    collated = np.empty((0, 3), dtype = np.int32)
+    collated_z = np.empty((0,), dtype = np.float64)
+    for batch in range(n_batches):
+        collated = np.concatenate((collated, tp[batch]), axis = 0)
+        collated_z = np.concatenate((collated_z, tz[batch]), axis = 0)
+    return collated, collated_z
+
+
+@njit
+def _points_in_triangles_aligned_optimised_batch(nx: int, ny: int, base_triangle: int,
+                                                 triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
+    triangles_points_list = []
+    for triangle_num in range(len(triangles)):
+        triangle = triangles[triangle_num]
+        min_x, max_x, min_y, max_y = triangle_box(triangle)
+        for xi in range(max(maths.ceil(min_x), 0), min(maths.floor(max_x) + 1, nx)):
+            x = float(xi)
+            e0_y = vertical_intercept_nan(x, triangle[1, 0], triangle[2, 0], triangle[1, 1], triangle[2, 1])
+            e1_y = vertical_intercept_nan(x, triangle[0, 0], triangle[1, 0], triangle[0, 1], triangle[1, 1])
+            e2_y = vertical_intercept_nan(x, triangle[0, 0], triangle[2, 0], triangle[0, 1], triangle[2, 1])
+            ey_list = np.array([e0_y, e1_y, e2_y], dtype = np.float64)
+            floor_y = np.nanmin(ey_list)
+            ceil_y = np.nanmax(ey_list)
+            triangles_points_list.extend([[triangle_num + base_triangle, y, xi]
+                                          for y in range(max(maths.ceil(floor_y), 0), min(maths.floor(ceil_y) + 1, ny))
+                                         ])
+
+    if len(triangles_points_list) == 0:
+        triangles_points = np.empty((0, 3), dtype = np.int32)
+    else:
+        triangles_points = np.array(triangles_points_list, dtype = np.int32)
+
+    return triangles_points
+
+
+@njit
+def _points_in_triangles_aligned_unified_batch(nx: int, ny: int, base_triangle: int, tp: np.ndarray, ax: int, ay: int,
+                                               az: int) -> Tuple[np.ndarray, np.ndarray]:  # pragma: no cover
+    # returns list like int array with each row being (tri number, axis y int, axis x int), and
+    # corresponding list like float array being axis z sampled at point on triangle
+    # todo: add type subscripting once support for python 3.8 is dropped
+    int_list = []
+    sampled_z_list = []
+
+    for triangle_num in range(len(tp)):
+        tri = tp[triangle_num]
+        min_x = np.min(tri[:, ax])
+        max_x = np.max(tri[:, ax])
+        min_y = np.min(tri[:, ay])
+        max_y = np.max(tri[:, ay])
+        for xi in range(max(maths.ceil(min_x), 0), min(maths.floor(max_x) + 1, nx)):
+            x = float(xi)
+            e0_y, e0_z = vertical_intercept_nan_yz(x, tri[1, ax], tri[2, ax], tri[1, ay], tri[2, ay], tri[1, az],
+                                                   tri[2, az])
+            e1_y, e1_z = vertical_intercept_nan_yz(x, tri[0, ax], tri[1, ax], tri[0, ay], tri[1, ay], tri[0, az],
+                                                   tri[1, az])
+            e2_y, e2_z = vertical_intercept_nan_yz(x, tri[0, ax], tri[2, ax], tri[0, ay], tri[2, ay], tri[0, az],
+                                                   tri[2, az])
+            floor_y = np.nan
+            ceil_y = np.nan
+            floor_z = np.nan
+            ceil_z = np.nan
+            if not np.isnan(e0_y):
+                floor_y = e0_y
+                ceil_y = e0_y
+                floor_z = e0_z
+                ceil_z = e0_z
+            if not np.isnan(e1_y):
+                if np.isnan(floor_y):
+                    floor_y = e1_y
+                    ceil_y = e1_y
+                    floor_z = e1_z
+                    ceil_z = e1_z
+                else:
+                    if e1_y < floor_y:
+                        floor_y = e1_y
+                        floor_z = e1_z
+                    else:
+                        ceil_y = e1_y
+                        ceil_z = e1_z
+            if not np.isnan(e2_y):
+                if np.isnan(floor_y):
+                    floor_y = e2_y
+                    ceil_y = e2_y
+                    floor_z = e2_z
+                    ceil_z = e2_z
+                else:
+                    if e2_y < floor_y:
+                        floor_y = e2_y
+                        floor_z = e2_z
+                    elif e2_y > ceil_y:
+                        ceil_y = e2_y
+                        ceil_z = e2_z
+            y_range = ceil_y - floor_y
+            z_range = ceil_z - floor_z
+            t = triangle_num + base_triangle
+            extend_int_list = []
+            extend_z_list = []
+            for y in range(max(maths.ceil(floor_y), 0), min(maths.floor(ceil_y) + 1, ny)):
+                yf = float(y) - floor_y
+                if y_range > 0.0:
+                    yf /= y_range
+                z = floor_z + yf * z_range
+                extend_int_list.append([triangle_num + base_triangle, y, xi])
+                extend_z_list.append(z)
+            int_list.extend(extend_int_list)
+            sampled_z_list.extend(extend_z_list)
+
+    if len(int_list) == 0:
+        int_array = np.empty((0, 3), dtype = np.int32)
+        z_array = np.empty((0,), dtype = np.float64)
+    else:
+        int_array = np.array(int_list, dtype = np.int32)
+        z_array = np.array(sampled_z_list, dtype = np.float64)
+
+    return (int_array, z_array)
+
+
 def triangle_normal_vector(p3):
     """For a triangle in 3D space, defined by 3 vertex points, returns a unit vector normal to the plane of the triangle.
 
@@ -1047,6 +1363,24 @@ def triangle_normal_vector_numba(points):  # pragma: no cover
     return v / np.linalg.norm(v)
 
 
+@njit
+def triangles_normal_vectors(t: np.ndarray, p: np.ndarray) -> np.ndarray:  # pragma: no cover
+    """For a triangulated set, return an array of unit normal vectors (one per triangle).
+
+    note:
+        resulting vectors implicitly assume that xy & z units are the same; if this is not the case, adjust vectors
+        afterwards as required
+    """
+    nv = np.empty((len(t), 3), dtype = np.float64)
+    v = np.zeros(3, dtype = np.float64)
+    for ti in range(len(t)):
+        v[:] = np.cross(p[t[ti, 0]] - p[t[ti, 1]], p[t[ti, 0]] - p[t[ti, 2]])
+        if v[2] < 0.0:
+            v[:] = -v
+        nv[ti, :] = v / np.linalg.norm(v)
+    return nv
+
+
 def in_circumcircle(a, b, c, d):
     """Returns True if point d lies within the circumcircle pf ccw points a, b, c, projected onto xy plane.
 

resqpy/olio/volume.py

@@ -77,26 +77,6 @@ def tetra_cell_volume(cp, centre = None, off_hand = False):
     return v / 6.0
 
 
-def tetra_volumes_slow(cp, centres = None, off_hand = False):
-    """Returns volume array for all hexahedral cells assuming bilinear faces, using loop over cells."""
-
-    # NB: deprecated, superceded by much faster function below
-    # todo: handle NaNs
-    # Pagoda style corner point data
-    assert cp.ndim == 7
-
-    flat = cp.reshape(-1, 2, 2, 2, 3)
-    cells = flat.shape[0]
-    if centres is None:
-        centres = np.mean(flat, axis = (1, 2, 3))
-    else:
-        centres = centres.reshape((-1, 3))
-    volumes = np.zeros(cells)
-    for cell in range(cells):
-        volumes[cell] = tetra_cell_volume(flat[cell], centre = centres[cell], off_hand = off_hand)
-    return volumes.reshape(cp.shape[0:3])
-
-
 def tetra_volumes(cp, centres = None, off_hand = False):
     """Returns volume array for all hexahedral cells assuming bilinear faces, using numpy operations.
 

resqpy/olio/wellspec_keywords.py

@@ -75,9 +75,9 @@ wellspec_dict['DZ']       = (0, wk_preferably_not, wk_okay, None,   True)   # no
 
 wellspec_dtype: Dict[str, Type] = { }  # mapping wellspec column key to expected data type
 
-wellspec_dtype['IW']       = int
-wellspec_dtype['JW']       = int
-wellspec_dtype['L']        = int
+wellspec_dtype['IW']       = np.int32
+wellspec_dtype['JW']       = np.int32
+wellspec_dtype['L']        = np.int32
 wellspec_dtype['GRID']     = str
 wellspec_dtype['RADW']     = float
 wellspec_dtype['KHMULT']   = float
@@ -89,11 +89,11 @@ wellspec_dtype['KH']       = float
 wellspec_dtype['SKIN']     = float
 wellspec_dtype['PPERF']    = float
 wellspec_dtype['ANGLE']    = float
-wellspec_dtype['IRELPM']   = int
+wellspec_dtype['IRELPM']   = np.int32
 wellspec_dtype['RADB']     = float
 wellspec_dtype['WI']       = float
 wellspec_dtype['K']        = float
-wellspec_dtype['LAYER']    = int
+wellspec_dtype['LAYER']    = np.int32
 wellspec_dtype['DEPTH']    = float   # '#' causes nexus to use cell depth
 wellspec_dtype['X']        = float   # use cell X for i.p. perf
 wellspec_dtype['Y']        = float   # use cell Y for i.p. perf
@@ -109,10 +109,10 @@ wellspec_dtype['PARENT']   = str
 wellspec_dtype['MDCON']    = float
 wellspec_dtype['SECT']     = str     # todo: need to check type
 wellspec_dtype['FLOWSECT'] = str     # todo: need to check type
-wellspec_dtype['ZONE']     = int
+wellspec_dtype['ZONE']     = np.int32
 wellspec_dtype['GROUP']    = str
 wellspec_dtype['TEMP']     = float
-wellspec_dtype['IPTN']     = int
+wellspec_dtype['IPTN']     = np.int32
 wellspec_dtype['D']        = float
 wellspec_dtype['ND']       = str
 wellspec_dtype['DZ']       = float
@@ -456,7 +456,7 @@ def get_well_data(
     line = kf.strip_trailing_comment(file.readline()).upper()
     columns_present = line.split()
     if selecting:
-        column_map = np.full((len(column_list),), -1, dtype = int)
+        column_map = np.full((len(column_list),), -1, dtype = np.int32)
         for i in range(len(column_list)):
             column = column_list[i].upper()
             if column in columns_present:
@@ -482,11 +482,11 @@ def get_well_data(
                     if column_list[col_index].upper() == "GRID":
                         data[col].append("ROOT")
                     else:
-                        data[col].append(np.NaN)
+                        data[col].append(np.nan)
                 else:
                     value = words[column_map[col_index]]
                     if value == "NA":
-                        data[col].append(np.NaN)
+                        data[col].append(np.nan)
                     elif value == "#":
                         data[col].append(value)
                     elif value:
@@ -496,7 +496,7 @@ def get_well_data(
         else:
             for col, value in zip(columns_present, words[:len(columns_present)]):
                 if value == "NA":
-                    data[col].append(np.NaN)
+                    data[col].append(np.nan)
                 elif value == "#":
                     data[col].append(value)
                 elif value:
@@ -519,13 +519,19 @@ def get_well_data(
 
     def stat_tranformation(row):
         if row["STAT"] == "ON":
-            return 1
+            return np.int8(1)
         else:
-            return 0
+            return np.int8(0)
 
     if "STAT" in df.columns:
         df["STAT"] = df.apply(lambda row: stat_tranformation(row), axis = 1)
 
+    int_col_dict = {}
+    for col in ["IW", "JW", "L", "LAYER", "STAT"]:
+        if col in df.columns:
+            int_col_dict[col] = (np.int8 if col == "STAT" else np.int32)
+    df = df.astype(int_col_dict)
+
     return df
 
 

resqpy/olio/write_hdf5.py

@@ -101,7 +101,7 @@ class H5Register():
         assert chunks is None or isinstance(chunks, str) or isinstance(chunks, tuple)
         assert compression is None or (isinstance(compression, str) and compression in ['gzip', 'lzf', 'none'])
         if str(dtype) == 'pack':
-            a = np.packbits(a, axis = -1)  # todo: check this returns uint8 array
+            a = np.packbits(a, axis = -1)
             dtype = 'uint8'
         elif dtype is not None:
             a = a.astype(dtype, copy = copy)

resqpy/olio/xml_et.py

@@ -778,6 +778,18 @@ def load_metadata_from_xml(node):
     return extra_metadata
 
 
+def find_metadata_item_node_in_xml(node, key):
+    """Returns the extra metadata node for a particular key, if present."""
+
+    if node is None:
+        return None
+    meta_nodes = list_of_tag(node, 'ExtraMetadata')
+    for meta in meta_nodes:
+        if find_tag_text(meta, 'Name') == key:
+            return meta
+    return None
+
+
 def create_metadata_xml(node, extra_metadata):
     """Writes the xml for the given metadata dictionary."""
 

resqpy/property/__init__.py

@@ -1,14 +1,15 @@
 """Collections of properties for grids, wellbore frames, grid connection sets etc."""
 
 __all__ = [
-    'PropertyCollection', 'Property', 'WellLog', 'WellIntervalProperty', 'WellIntervalPropertyCollection',
-    'WellLogCollection', 'StringLookup', 'PropertyKind', 'GridPropertyCollection',
+    'PropertyCollection', 'Property', 'AttributePropertySet', 'ApsProperty', 'WellLog', 'WellIntervalProperty',
+    'WellIntervalPropertyCollection', 'WellLogCollection', 'StringLookup', 'PropertyKind', 'GridPropertyCollection',
     'property_over_time_series_from_collection', 'property_collection_for_keyword', 'infer_property_kind',
     'write_hdf5_and_create_xml_for_active_property', 'reformat_column_edges_to_resqml_format',
     'reformat_column_edges_from_resqml_format', 'same_property_kind', 'selective_version_of_collection',
     'supported_local_property_kind_list', 'supported_property_kind_list', 'supported_facet_type_list',
     'expected_facet_type_dict', 'create_transmisibility_multiplier_property_kind',
-    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part'
+    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part', 'make_aps_key',
+    'establish_zone_property_kind'
 ]
 
 from .property_common import property_collection_for_keyword,  \
@@ -27,9 +28,10 @@ from .property_common import property_collection_for_keyword,  \
     guess_uom,  \
     property_parts,  \
     property_part
-from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind
+from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind, establish_zone_property_kind
 from .string_lookup import StringLookup
 from .property_collection import PropertyCollection
+from .attribute_property_set import AttributePropertySet, ApsProperty, make_aps_key
 from .grid_property_collection import GridPropertyCollection
 from ._property import Property
 from .well_interval_property import WellIntervalProperty

resqpy/property/_collection_add_part.py

@@ -199,7 +199,7 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
                                extra_metadata, expand_const_arrays):
     (p_uuid, p_file_name, p_keyword, p_cached_name, p_discrete, p_uom, p_time_index, p_null_value, p_min_value,
      p_max_value, property_kind, facet_type, facet, realization, indexable_element, count, local_property_kind_uuid,
-     const_value, points, p_time_series_uuid, p_string_lookup_uuid) = attributes
+     const_value, points, p_time_series_uuid, p_string_lookup_uuid, pre_packed) = attributes
 
     log.debug('processing imported property ' + str(p_keyword))
     assert not points or not p_discrete
@@ -214,7 +214,7 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
                                                                  p_keyword, p_discrete, string_lookup_uuid, points)
 
     p_array = _process_imported_property_get_p_array(collection, p_cached_name)
-    p_array_bool = None if p_array is None else p_array.dtype in [bool, np.int8]
+    p_array_bool = isinstance(const_value, bool) if p_array is None else p_array.dtype in [bool, np.int8, np.uint8]
 
     add_min_max = pcga._process_imported_property_get_add_min_max(points, property_kind, string_lookup_uuid,
                                                                   local_property_kind_uuid, p_array_bool)
@@ -251,7 +251,8 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
         find_local_property_kinds = find_local_property_kinds,
         extra_metadata = extra_metadata,
         const_value = const_value,
-        expand_const_arrays = expand_const_arrays)
+        expand_const_arrays = expand_const_arrays,
+        pre_packed = pre_packed)
     if p_node is not None:
         return p_node
     else:

resqpy/property/_collection_create_xml.py

@@ -66,7 +66,7 @@ def _create_xml_property_kind(collection, p_node, find_local_property_kinds, pro
         property_kind = 'rock permeability'
     p_kind_node = rqet.SubElement(p_node, ns['resqml2'] + 'PropertyKind')
     p_kind_node.text = rqet.null_xml_text
-    if find_local_property_kinds and property_kind not in rqp_c.supported_property_kind_list:
+    if find_local_property_kinds and property_kind not in wam.valid_property_kinds():
         property_kind_uuid = pcga._get_property_kind_uuid(collection, property_kind_uuid, property_kind, uom, discrete)
 
     if property_kind_uuid is None:
@@ -246,8 +246,10 @@ def _create_xml_facet_node(facet_type, facet, p_node):
         facet_value_node.text = facet
 
 
-def _check_shape_list(collection, indexable_element, direction, property_array, points, count):
+def _check_shape_list(collection, indexable_element, direction, property_array, points, count, pre_packed):
     shape_list = collection.supporting_shape(indexable_element = indexable_element, direction = direction)
+    if pre_packed:
+        shape_list[-1] = (shape_list[-1] - 1) // 8 + 1
     if shape_list is not None:
         if count > 1:
             shape_list.append(count)

resqpy/property/_collection_get_attributes.py

@@ -509,6 +509,8 @@ def _supporting_shape_surface(support, indexable_element):
         shape_list = [support.triangle_count()]
     elif indexable_element == 'nodes':
         shape_list = [support.node_count()]
+    elif indexable_element == 'patches':
+        shape_list = [len(support.patch_list)]
     return shape_list
 
 
@@ -538,6 +540,8 @@ def _supporting_shape_polylineset(support, indexable_element):
         shape_list = [len(support.coordinates) - reduction]
     elif indexable_element == 'nodes':
         shape_list = [len(support.coordinates)]
+    elif indexable_element in ['patches', 'enumerated elements', 'contacts']:  # one value per polyline within the set
+        shape_list = [len(support.count_perpol)]
     return shape_list