resqpy 4.16.11__py3-none-any.whl → 4.17.1__py3-none-any.whl

resqpy/model/_hdf5.py

@@ -262,11 +262,11 @@ def _h5_array_element(model,
         if dtype is None:
             return result
         if result.size == 1:
-            if dtype is float or (isinstance(dtype, str) and dtype.startswith('float')):
+            if dtype is float or (isinstance(dtype, str) and ('float' in dtype)):
                 return float(result)
-            elif dtype is int or (isinstance(dtype, str) and dtype.startswith('int')):
+            elif dtype is int or (isinstance(dtype, str) and ('int' in dtype)):
                 return int(result)
-            elif dtype is bool or (isinstance(dtype, str) and dtype.startswith('bool')):
+            elif dtype is bool or (isinstance(dtype, str) and ('bool' in dtype)):
                 return bool(result)
         return np.array(result, dtype = dtype)
 

resqpy/olio/triangulation.py

@@ -115,7 +115,7 @@ def _dt_simple(po, plot_fn = None, progress_fn = None, container_size_factor = N
     if n_p < 3:
         return None, None  # not enough points
     elif n_p == 3:
-        return np.array([0, 1, 2], dtype = int).reshape((1, 3)), np.array([0, 1, 2], dtype = int)
+        return np.array([0, 1, 2], dtype = np.int32).reshape((1, 3)), np.array([0, 1, 2], dtype = np.int32)
 
     if progress_fn is not None:
         progress_fn(0.0)
@@ -133,19 +133,20 @@ def _dt_simple(po, plot_fn = None, progress_fn = None, container_size_factor = N
     p[-1] = (min_xy[0] + 0.5 * csf * dxy[0], max_xy[1] + 0.8 * csf * dxy[1])
 
     # triangle vertex indices
-    t = np.empty((2 * n_p + 2, 3), dtype = int)  # empty space for triangle vertex indices
+    t_type = np.int32 if n_p < 2_147_483_648 else np.int64
+    t = np.empty((2 * n_p + 2, 3), dtype = t_type)  # empty space for triangle vertex indices
     t[0] = (n_p, n_p + 1, n_p + 2)  # initial set of one containing triangle
     nt = 1  # number of triangles so far populated
 
     # edges: list of indices of triangles and edge within triangle; -1 indicates no triangle using edge
-    e = np.full((3 * n_p + 6, 2, 2), fill_value = -1, dtype = int)
+    e = np.full((3 * n_p + 6, 2, 2), fill_value = -1, dtype = t_type)
     e[:3, 0, 0] = 0
     for edge in range(3):
         e[edge, 0, 1] = edge
     ne = 3  # number of edges so far in use
 
     # edge indices (in e) for each triangle, first axis indexed in sync with t
-    te = np.empty((2 * n_p + 2, 3), dtype = int)  # empty space for triangle edge indices
+    te = np.empty((2 * n_p + 2, 3), dtype = t_type)  # empty space for triangle edge indices
     te[0] = (0, 1, 2)
 
     # mask tracking which edges have been flipped
@@ -501,7 +502,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
         return trimmed_ci
 
     def __veroni_cells(aoi_count, aoi_intersect_segments, b, c, c_count, ca_count, cah_count, caho_count, cahon_count,
-                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi):
+                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi, t_type):
         # list of voronoi cells (each a numpy list of node indices into c extended with aoi points etc)
         v = []
         # for each seed point build the voronoi cell
@@ -550,7 +551,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
                                                   ci_for_p, out_pair_intersect_segments)
 
             #  remove circumcircle centres that are outwith area of interest
-            ci_for_p = np.array([ti for ti in ci_for_p if ti >= c_count or ti not in tc_outwith_aoi], dtype = int)
+            ci_for_p = np.array([ti for ti in ci_for_p if ti >= c_count or ti not in tc_outwith_aoi], dtype = t_type)
 
             # find azimuths of vectors from seed point to circumcircle centres and aoi boundary points
             azi = [vec.azimuth(centre - p[p_i, :2]) for centre in c[ci_for_p, :2]]
@@ -612,11 +613,12 @@ def voronoi(p, t, b, aoi: rql.Polyline):
     caho_count = cah_count + 2 * o_count
     cahon_count = caho_count + hull_count
     assert cahon_count + hull_count == len(c)
+    t_type = np.int32 if len(c) < 2_147_483_648 else np.int64
 
     #  compute intersection points between hull edge normals and aoi polyline
     # also extended virtual centres for hull edges
     extension_scaling = 1000.0 * np.sum((np.max(aoi.coordinates, axis = 0) - np.min(aoi.coordinates, axis = 0))[:2])
-    aoi_intersect_segments = np.empty((hull_count,), dtype = int)
+    aoi_intersect_segments = np.empty((hull_count,), dtype = t_type)
     for ei in range(hull_count):
         # use segment midpoint and normal methods of hull to project out
         m = hull.segment_midpoint(ei)[:2]  # midpoint
@@ -638,8 +640,8 @@ def voronoi(p, t, b, aoi: rql.Polyline):
         c[cahon_count + ei] = hull.coordinates[ei, :2] + extension_scaling * vector
 
     # where cicrumcircle centres are outwith aoi, compute intersections of normals of wing edges with aoi
-    out_pair_intersect_segments = np.empty((o_count, 2), dtype = int)
-    wing_hull_segments = np.empty((o_count, 2), dtype = int)
+    out_pair_intersect_segments = np.empty((o_count, 2), dtype = t_type)
+    wing_hull_segments = np.empty((o_count, 2), dtype = t_type)
     for oi, ti in enumerate(tc_outwith_aoi):
         tpi = __shorter_sides_p_i(p[t[ti]])
         for wing in range(2):
@@ -658,7 +660,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
             tpi = (tpi + 1) % 3
 
     v = __veroni_cells(aoi_count, aoi_intersect_segments, b, c, c_count, ca_count, cah_count, caho_count, cahon_count,
-                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi)
+                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi, t_type)
 
     return c[:caho_count], v
 
@@ -703,7 +705,8 @@ def triangulated_polygons(p, v, centres = None):
         points[len(p):] = centres
 
     t_count = sum([len(x) for x in v])
-    triangles = np.empty((t_count, 3), dtype = int)
+    t_type = np.int32 if len(points) < 2_147_483_648 else np.int64
+    triangles = np.empty((t_count, 3), dtype = t_type)
     t_index = 0
 
     for cell, poly_vertices in enumerate(v):
@@ -711,7 +714,7 @@ def triangulated_polygons(p, v, centres = None):
         centre_i = len(p) + cell
         if centres is None:
             polygon = rql.Polyline(model,
-                                   set_coord = p[np.array(poly_vertices, dtype = int)],
+                                   set_coord = p[np.array(poly_vertices, dtype = t_type)],
                                    is_closed = True,
                                    set_crs = crs.uuid,
                                    title = 'v cell')
@@ -917,7 +920,7 @@ def edges(t):
     """
 
     assert t.ndim == 2 and t.shape[1] == 3
-    all_edges = np.empty((len(t), 3, 2), dtype = int)
+    all_edges = np.empty((len(t), 3, 2), dtype = t.dtype)
     all_edges[:, :, 0] = t
     all_edges[:, :2, 1] = t[:, 1:]
     all_edges[:, 2, 1] = t[:, 0]
@@ -946,6 +949,7 @@ def triangles_using_edges(t, edges):
     """Returns int array of shape (len(edges), 2) with indices of upto 2 triangles using each edge (-1 for unused)."""
 
     assert t.ndim == 2 and t.shape[1] == 3 and edges.ndim == 2 and edges.shape[1] == 2
+    t_type = np.int32 if len(t) < 2_147_483_648 else np.int64
     ti = np.full((len(edges), 2), -1, dtype = int)
     for i in range(len(edges)):
         te = triangles_using_edge(t, edges[i, 0], edges[i, 1])

resqpy/olio/vector_utilities.py

@@ -14,7 +14,7 @@ import math as maths
 import numpy as np
 import numba  # type: ignore
 from numba import njit, prange  # type: ignore
-from typing import Tuple, Optional
+from typing import Tuple, Optional, List
 
 
 def radians_from_degrees(deg):
@@ -1013,6 +1013,47 @@ def vertical_intercept_nan(x: float, x_value_0: float, x_value_1: float, y_value
     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
@@ -1138,6 +1179,56 @@ def points_in_triangles_aligned_optimised(nx: int,
     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
@@ -1165,6 +1256,89 @@ def _points_in_triangles_aligned_optimised_batch(nx: int, ny: int, base_triangle
     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.
 

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:
@@ -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/property/grid_property_collection.py

@@ -51,11 +51,11 @@ class GridPropertyCollection(rqp.PropertyCollection):
 
         # NB: RESQML documentation is not clear which order is correct; should be kept consistent with same data in fault.py
         # face_index_map maps from (axis, p01) to face index value in range 0..5
-        #     self.face_index_map = np.array([[0, 1], [4, 2], [5, 3]], dtype = int)
-        self.face_index_map = np.array([[0, 1], [2, 4], [5, 3]], dtype = int)  # order: top, base, J-, I+, J+, I-
+        # self.face_index_map = np.array([[0, 1], [4, 2], [5, 3]], dtype = np.int8)
+        self.face_index_map = np.array([[0, 1], [2, 4], [5, 3]], dtype = np.int8)  # order: top, base, J-, I+, J+, I-
         # and the inverse, maps from 0..5 to (axis, p01)
-        #     self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 1], [2, 1], [1, 0], [2, 0]], dtype = int)
-        self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 0], [2, 1], [1, 1], [2, 0]], dtype = int)
+        # self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 1], [2, 1], [1, 0], [2, 0]], dtype = np.int8)
+        self.face_index_inverse_map = np.array([[0, 0], [0, 1], [1, 0], [2, 1], [1, 1], [2, 0]], dtype = np.int8)
 
     def _copy_support_to_grid_attributes(self):
         # following three pseudonyms are for backward compatibility
@@ -266,11 +266,11 @@ class GridPropertyCollection(rqp.PropertyCollection):
             dtype = None
             if keyword[0].upper() == 'I' or keyword in ['KID', 'UID', 'UNPACK', 'DAD']:
                 # coerce to integer values (vdb stores integer data as reals!)
-                dtype = 'int32'
+                dtype = np.int32
             elif keyword in ['DEADCELL', 'LIVECELL']:
-                dtype = 'bool'  # could use the default dtype of 64 bit integer
+                dtype = bool  # could use the default dtype of 64 bit integer
             else:
-                dtype = 'float'  # convert to 64 bit; could omit but RESQML states 64 bit
+                dtype = np.float32
                 discrete = False
             import_array = vdbase.grid_static_property(grid_name, keyword, dtype = dtype)
             assert import_array is not None
@@ -335,7 +335,7 @@ class GridPropertyCollection(rqp.PropertyCollection):
             time_index = timestep
         keyword = keyword.upper()
         try:
-            import_array = vdbase.grid_recurrent_property_for_timestep(grid_name, keyword, timestep, dtype = 'float')
+            import_array = vdbase.grid_recurrent_property_for_timestep(grid_name, keyword, timestep, dtype = np.float32)
             assert import_array is not None
         except Exception:
             # could raise an exception (as for static properties)
@@ -489,9 +489,9 @@ class GridPropertyCollection(rqp.PropertyCollection):
                 for k0 in range(self.grid.nk):
                     for j0 in range(self.grid.nj):
                         for i0 in range(self.grid.ni):
-                            #                     if decoarsen_array[k0, j0, i0] < 0:
+                            # if decoarsen_array[k0, j0, i0] < 0:
                             if kid[k0, j0, i0] == 0:
-                                #                        assert not kid_mask[k0, j0, i0]
+                                # assert not kid_mask[k0, j0, i0]
                                 ke = k0 + 1
                                 while ke < self.grid.nk and kid_mask[ke, j0, i0]:
                                     ke += 1

resqpy/rq_import/_import_vdb_ensemble.py

@@ -225,11 +225,11 @@ def import_vdb_ensemble(
         vdb_file = ensemble_list[realisation]
         log.info('processing realisation ' + str(realisation) + ' from: ' + str(vdb_file))
         vdbase = vdb.VDB(vdb_file)
-        #      case_list = vdbase.cases()
-        #      assert len(case_list) > 0, 'no cases found in vdb: ' + str(vdb_file)
-        #      if len(case_list) > 1: log.warning('more than one case found in vdb (using first): ' + str(vdb_file))
-        #      vdb_case = case_list[0]
-        #      vdbase.set_use_case(vdb_case)
+        # case_list = vdbase.cases()
+        # assert len(case_list) > 0, 'no cases found in vdb: ' + str(vdb_file)
+        # if len(case_list) > 1: log.warning('more than one case found in vdb (using first): ' + str(vdb_file))
+        # vdb_case = case_list[0]
+        # vdbase.set_use_case(vdb_case)
         vdbase.set_extent_kji(grid.extent_kji)
 
         prop_import_collection = rp.GridPropertyCollection(realization = realisation)
@@ -243,9 +243,8 @@ def import_vdb_ensemble(
                     if keyword_list is not None and keyword not in keyword_list:
                         continue
                     prop_kind, facet_type, facet = rp.property_kind_and_facet_from_keyword(keyword)
-                    if property_kind_list is not None and prop_kind not in property_kind_list and prop_kind not in [
-                            'active', 'region initialization'
-                    ]:
+                    if property_kind_list is not None and prop_kind not in property_kind_list and  \
+                        prop_kind not in ['active', 'region initialization']:
                         continue
                     prop_import_collection.import_vdb_static_property_to_cache(vdbase,
                                                                                keyword,
@@ -312,9 +311,9 @@ def import_vdb_ensemble(
                     if decoarsen_array is not None:
                         step_import_collection.decoarsen_imported_list(decoarsen_array = decoarsen_array)
                     # extend hdf5 with cached arrays for this timestep
-                    #         log.info('number of recurrent grid property arrays for timestep: ' + str(timestep_number) +
-                    #                  ' is: ' + str(step_import_collection.number_of_imports()))
-                    #         log.info('extending hdf5 file with recurrent properties for timestep: ' + str(timestep_number))
+                    # log.info('number of recurrent grid property arrays for timestep: ' + str(timestep_number) +
+                    #          ' is: ' + str(step_import_collection.number_of_imports()))
+                    # log.info('extending hdf5 file with recurrent properties for timestep: ' + str(timestep_number))
                     grid.write_hdf5_from_caches(hdf5_file,
                                                 mode = 'a',
                                                 geometry = False,
@@ -322,8 +321,8 @@ def import_vdb_ensemble(
                                                 write_active = False)
                     # add imported list for this timestep to full imported list
                     prop_import_collection.inherit_imported_list_from_other_collection(step_import_collection)
-                    #         log.debug('total number of property arrays after timestep: ' + str(timestep_number) +
-                    #                   ' is: ' + str(prop_import_collection.number_of_imports()))
+                    # log.debug('total number of property arrays after timestep: ' + str(timestep_number) +
+                    #           ' is: ' + str(prop_import_collection.number_of_imports()))
                     # remove cached copies of arrays
                     step_import_collection.remove_all_cached_arrays()
 

resqpy/surface/_mesh.py

@@ -207,6 +207,10 @@ class Mesh(rqsb.BaseSurface):
                    extra_metadata = em)
         return mesh
 
+    def is_big(self):
+        """Returns True if the number of nodes exceeds 2^31 - 1, False otherwise."""
+        return (self.ni * self.nj >= 2_147_483_648)
+
     def set_represented_interpretation_root(self, interp_root):
         """Makes a note of the xml root of the represented interpretation."""
 

resqpy/surface/_surface.py

@@ -279,11 +279,13 @@ class Surface(rqsb.BaseSurface):
         self.extract_patches(self.root)
         return len(self.patch_list)
 
-    def triangles_and_points(self, patch = None):
+    def triangles_and_points(self, patch = None, copy = False):
         """Returns arrays representing one patch or a combination of all the patches in the surface.
 
         arguments:
            patch (int, optional): patch index; if None, combined arrays for all patches are returned
+           copy (bool, default False): if True, a copy of the arrays is returned; if False, the cached
+              arrays are returned
 
         returns:
            tuple (triangles, points):
@@ -296,21 +298,30 @@ class Surface(rqsb.BaseSurface):
 
         self.extract_patches(self.root)
         if patch is None:
-            if self.triangles is None:
-                points_offset = 0
-                for triangulated_patch in self.patch_list:
-                    (t, p) = triangulated_patch.triangles_and_points()
-                    if points_offset == 0:
-                        self.triangles = t.copy()
-                        self.points = p.copy()
-                    else:
-                        self.triangles = np.concatenate((self.triangles, t.copy() + points_offset))
-                        self.points = np.concatenate((self.points, p.copy()))
-                    points_offset += p.shape[0]
-            return (self.triangles, self.points)
+            if self.triangles is None or self.points is None:
+                if self.triangles is None:
+                    points_offset = 0
+                    for triangulated_patch in self.patch_list:
+                        (t, p) = triangulated_patch.triangles_and_points()
+                        if points_offset == 0:
+                            self.triangles = t
+                            self.points = p
+                        else:
+                            self.triangles = np.concatenate((self.triangles, t.copy() + points_offset))
+                            self.points = np.concatenate((self.points, p))
+                        points_offset += p.shape[0]
+            if copy:
+                return (self.triangles.copy(), self.points.copy())
+            else:
+                return (self.triangles, self.points)
         assert 0 <= patch < len(self.patch_list),  \
             ValueError(f'patch index {patch} out of range for surface with {len(self.patch_list)} patches')
-        return self.patch_list[patch].triangles_and_points()
+        return self.patch_list[patch].triangles_and_points(copy = copy)
+
+    def decache_triangles_and_points(self):
+        """Removes the cached composite triangles and points arrays."""
+        self.points = None
+        self.triangles = None
 
     def triangle_count(self, patch = None):
         """Return the numner of triangles in this surface, or in one patch.
@@ -438,10 +449,11 @@ class Surface(rqsb.BaseSurface):
         t, p = large_surface.triangles_and_points()
         assert p.ndim == 2 and p.shape[1] == 3
         pp = np.concatenate((p, line), axis = 0)
-        tp = np.empty(p.shape, dtype = int)
+        t_type = np.int32 if len(pp) <= 2_147_483_647 else np.int64
+        tp = np.empty(p.shape, dtype = t_type)
         tp[:, 0] = len(p)
         tp[:, 1] = len(p) + 1
-        tp[:, 2] = np.arange(len(p), dtype = int)
+        tp[:, 2] = np.arange(len(p), dtype = t_type)
         cw = vec.clockwise_triangles(pp, tp)
         pai = (cw >= 0.0)  # bool mask over p
         pbi = (cw <= 0.0)  # bool mask over p
@@ -453,11 +465,11 @@ class Surface(rqsb.BaseSurface):
         # here we stick the two halves together into a single patch
         # todo: keep as two patches as required by RESQML business rules
         p_combo = np.empty((0, 3))
-        t_combo = np.empty((0, 3), dtype = int)
+        t_combo = np.empty((0, 3), dtype = t_type)
         for i, tab in enumerate((ta, tb)):
             p_keep = np.unique(t[tab])
             # note new point index for each old point that is being kept
-            p_map = np.full(len(p), -1, dtype = int)
+            p_map = np.full(len(p), -1, dtype = t_type)
             p_map[p_keep] = np.arange(len(p_keep))
             # copy those unique points into a trimmed points array
             points_trimmed = p[p_keep].copy()
@@ -950,7 +962,8 @@ class Surface(rqsb.BaseSurface):
                     triangles.append(line.rstrip().split(" ")[1:4])
         assert len(vertices) >= 3, 'vertices missing'
         assert len(triangles) > 0, 'triangles missing'
-        triangles = np.array(triangles, dtype = int) - index_offset
+        t_type = np.int32 if len(vertices) <= 2_147_483_647 else np.int64
+        triangles = np.array(triangles, dtype = t_type) - index_offset
         vertices = np.array(vertices, dtype = float)
         assert np.all(triangles >= 0) and np.all(triangles < len(vertices)), 'triangle vertex indices out of range'
         self.set_from_triangles_and_points(triangles = triangles, points = vertices)
@@ -1139,8 +1152,9 @@ class Surface(rqsb.BaseSurface):
 
         # TODO: implement alternate solution using edge functions in olio triangulation to optimise
         points_unique, inverse = np.unique(allpoints, axis = 0, return_inverse = True)
-        tris = np.array(tris)
-        tris_unique = np.empty(shape = tris.shape, dtype = int)
+        t_type = np.int32 if len(allpoints) <= 2_147_483_647 else np.int64
+        tris = np.array(tris, dtype = t_type)
+        tris_unique = np.empty(shape = tris.shape, dtype = t_type)
         tris_unique[:, 0] = inverse[tris[:, 0]]
         tris_unique[:, 1] = inverse[tris[:, 1]]
         tris_unique[:, 2] = inverse[tris[:, 2]]
@@ -1333,7 +1347,8 @@ def distill_triangle_points(t, p):
     # find unique points used by triangles
     p_keep = np.unique(t)
     # note new point index for each old point that is being kept
-    p_map = np.full(len(p), -1, dtype = int)
+    t_type = np.int32 if len(p) <= 2_147_483_647 else np.int64
+    p_map = np.full(len(p), -1, dtype = t_type)
     p_map[p_keep] = np.arange(len(p_keep))
     # copy those unique points into a trimmed points array
     points_distilled = p[p_keep]
@@ -1360,8 +1375,9 @@ def nan_removed_triangles_and_points(t, p):
     expanded_mask[:] = np.expand_dims(np.logical_not(t_nan_mask), axis = -1)
     t_filtered = t[expanded_mask].reshape((-1, 3))
     # modified the filtered t values to adjust for the compression of filtered p
-    p_map = np.full(len(p), -1, dtype = int)
-    p_map[p_non_nan_mask] = np.arange(len(p_filtered), dtype = int)
+    t_type = np.int32 if len(p) <= 2_147_483_647 else np.int64
+    p_map = np.full(len(p), -1, dtype = t_type)
+    p_map[p_non_nan_mask] = np.arange(len(p_filtered), dtype = t_type)
     t_filtered = p_map[t_filtered]
     assert t_filtered.ndim == 2 and t_filtered.shape[1] == 3
     assert not np.any(t_filtered < 0) and not np.any(t_filtered >= len(p_filtered))