resqpy 4.16.10.dev2__py3-none-any.whl → 4.17.0__py3-none-any.whl

resqpy/__init__.py

@@ -28,6 +28,6 @@
 
 import logging
 
-__version__ = "4.16.10.dev2"  # Set at build time
+__version__ = "4.17.0"  # Set at build time
 log = logging.getLogger(__name__)
 log.info(f"Imported resqpy version {__version__}")

resqpy/fault/_grid_connection_set.py

@@ -118,7 +118,7 @@ class GridConnectionSet(BaseResqpy):
         self.cell_index_pairs = None  #: shape (count, 2); dtype int; index normalized for flattened array
         self.cell_index_pairs_null_value = -1  #: integer null value for array above
         self.grid_index_pairs = None  #: shape (count, 2); dtype int; optional; used if more than one grid referenced
-        self.face_index_pairs = None  #: shape (count, 2); dtype int32; local to cell, ie. range 0 to 5
+        self.face_index_pairs = None  #: shape (count, 2); dtype int8; local to cell, ie. range 0 to 5
         self.face_index_pairs_null_value = -1  #: integer null value for array above
         # NB face index values 0..5 usually mean [K-, K+, J+, I+, J-, I-] respectively but there is some ambiguity
         #    over I & J in the Energistics RESQML Usage Guide; see comments in DevOps backlog item 269001 for more info
@@ -129,17 +129,18 @@ class GridConnectionSet(BaseResqpy):
         self.feature_list = None  #: ordered list, actually of interpretations, indexed by feature_indices
         # feature list contains tuples: (content_type, uuid, title) for fault features (or other interpretations)
         self.property_collection = None  #: optional property.PropertyCollection
+        self.cell_index_dtype = np.int32  #: set to int64 if any grid is big, otherwise int32
 
         # NB: RESQML documentation is not clear which order is correct; should be kept consistent with same data in property.py
         # face_index_map maps from (axis, p01) to face index value in range 0..5
         # this is the default as indicated on page 139 (but not p. 180) of the RESQML Usage Gude v2.0.1
         # also assumes K is generally increasing downwards
         # see DevOps backlog item 269001 discussion for more information
-        #     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)
         # note: the rework_face_pairs() method, below, overwrites the face indices based on I, J cell indices
         if not title:
             title = feature_name
@@ -196,6 +197,7 @@ class GridConnectionSet(BaseResqpy):
                 self.cache_arrays()
             if find_properties:
                 self.extract_property_collection()
+        self._set_cell_index_dtype()
 
     @classmethod
     def from_gcs_uuid_list(cls,
@@ -357,6 +359,14 @@ class GridConnectionSet(BaseResqpy):
             self.property_collection = rqp.PropertyCollection(support = self)
         return self.property_collection
 
+    def _set_cell_index_dtype(self):
+        """Determines whether to use int32 or int64 for normalised cell indices."""
+        self.cell_index_dtype = np.int32
+        for g in self.grid_list:
+            if g.is_big():
+                self.cell_index_dtype = np.int64
+                break
+
     def set_pairs_from_kelp(self,
                             kelp_0,
                             kelp_1,
@@ -394,7 +404,7 @@ class GridConnectionSet(BaseResqpy):
                 k_layer = np.zeros((grid.nk - 1, grid.ni), dtype = bool)
             else:
                 k_layer = np.zeros((grid.nk - 1, grid.nj), dtype = bool)
-            kelp_a = np.array(kelp_k, dtype = int).T
+            kelp_a = np.array(kelp_k, dtype = np.int32).T
             k_layer[kelp_a[0], kelp_a[1]] = True
             k_faces = np.zeros((grid.nk - 1, grid.nj, grid.ni), dtype = bool)
             if axis == 'J':
@@ -408,7 +418,7 @@ class GridConnectionSet(BaseResqpy):
                 j_layer = np.zeros((grid.nj - 1, grid.ni), dtype = bool)
             else:
                 j_layer = np.zeros((grid.nk, grid.nj - 1), dtype = bool)
-            kelp_a = np.array(kelp_j, dtype = int).T
+            kelp_a = np.array(kelp_j, dtype = np.int32).T
             j_layer[kelp_a[0], kelp_a[1]] = True
             j_faces = np.zeros((grid.nk, grid.nj - 1, grid.ni), dtype = bool)
             if axis == 'K':
@@ -422,7 +432,7 @@ class GridConnectionSet(BaseResqpy):
                 i_layer = np.zeros((grid.nj, grid.ni - 1), dtype = bool)
             else:
                 i_layer = np.zeros((grid.nk, grid.ni - 1), dtype = bool)
-            kelp_a = np.array(kelp_i, dtype = int).T
+            kelp_a = np.array(kelp_i, dtype = np.int32).T
             i_layer[kelp_a[0], kelp_a[1]] = True
             i_faces = np.zeros((grid.nk, grid.nj, grid.ni - 1), dtype = bool)
             if axis == 'K':
@@ -548,10 +558,10 @@ class GridConnectionSet(BaseResqpy):
                 else:
                     cell_pair_list.append((cell, cell + 1))
                     face_pair_list.append((self.face_index_map[2, 1], self.face_index_map[2, 0]))
-        self.cell_index_pairs = np.array(cell_pair_list, dtype = int)
-        self.face_index_pairs = np.array(face_pair_list, dtype = int)
+        self.cell_index_pairs = np.array(cell_pair_list, dtype = self.cell_index_dtype)
+        self.face_index_pairs = np.array(face_pair_list, dtype = np.int8)
         self.count = len(self.cell_index_pairs)
-        self.feature_indices = np.zeros(self.count, dtype = int)
+        self.feature_indices = np.zeros(self.count, dtype = np.int32)
         assert len(self.face_index_pairs) == self.count
 
     def set_pairs_from_faces_df(self,
@@ -609,9 +619,9 @@ class GridConnectionSet(BaseResqpy):
             if success:
                 feature_index += 1
 
-        self.feature_indices = np.array(fi_list, dtype = int)
-        self.cell_index_pairs = np.array(cell_pair_list, dtype = int)
-        self.face_index_pairs = np.array(face_pair_list, dtype = int)
+        self.feature_indices = np.array(fi_list, dtype = np.int32)
+        self.cell_index_pairs = np.array(cell_pair_list, dtype = self.cell_index_dtype)
+        self.face_index_pairs = np.array(face_pair_list, dtype = np.int8)
         self.count = len(self.cell_index_pairs)
         assert len(self.face_index_pairs) == self.count
         if create_mult_prop and self.count > 0:
@@ -696,7 +706,7 @@ class GridConnectionSet(BaseResqpy):
         singleton.cell_index_pairs, singleton.face_index_pairs =  \
            self.raw_list_of_cell_face_pairs_for_feature_index(feature_index)
         singleton.count = singleton.cell_index_pairs.shape[0]
-        singleton.feature_indices = np.zeros((singleton.count,), dtype = int)
+        singleton.feature_indices = np.zeros((singleton.count,), dtype = np.int32)
         singleton.feature_list = [self.feature_list[feature_index]]
         return singleton
 
@@ -823,7 +833,7 @@ class GridConnectionSet(BaseResqpy):
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'cell_index_pairs',
-                                        dtype = 'int')
+                                        dtype = 'int64' if self.cell_index_dtype is np.int64 else 'int32')
 
         if self.face_index_pairs is None:
             log.debug('caching face index pairs from hdf5')
@@ -834,7 +844,7 @@ class GridConnectionSet(BaseResqpy):
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'face_index_pairs',
-                                        dtype = 'int32')
+                                        dtype = 'int8')
 
         if len(self.grid_list) > 1 and self.grid_index_pairs is None:
             grid_index_node = rqet.find_tag(self.root, 'GridIndexPairs')
@@ -845,7 +855,7 @@ class GridConnectionSet(BaseResqpy):
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'grid_index_pairs',
-                                        dtype = 'int')
+                                        dtype = 'int32' if len(self.grid_list) > 127 else 'int8')
 
         if self.feature_list is None:
             return
@@ -854,18 +864,18 @@ class GridConnectionSet(BaseResqpy):
         if self.feature_indices is None:
             log.debug('caching feature indices')
             elements_node = rqet.find_nested_tags(interp_root, ['InterpretationIndices', 'Elements'])
-            #         elements_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'Elements'])
+            # elements_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'Elements'])
             h5_key_pair = self.model.h5_uuid_and_path_for_node(elements_node, tag = 'Values')
             assert h5_key_pair is not None
             self.model.h5_array_element(h5_key_pair,
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'feature_indices',
-                                        dtype = 'uint32')
+                                        dtype = 'int32')
             assert self.feature_indices.shape == (self.count,)
 
             cl_node = rqet.find_nested_tags(interp_root, ['InterpretationIndices', 'CumulativeLength'])
-            #         cl_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'CumulativeLength'])
+            # cl_node = rqet.find_nested_tags(interp_root, ['FaultIndices', 'CumulativeLength'])
             h5_key_pair = self.model.h5_uuid_and_path_for_node(cl_node, tag = 'Values')
             assert h5_key_pair is not None
             self.model.h5_array_element(h5_key_pair,
@@ -873,8 +883,8 @@ class GridConnectionSet(BaseResqpy):
                                         object = self,
                                         array_attribute = 'fi_cl',
                                         dtype = 'uint32')
-            assert self.fi_cl.shape == (
-                self.count,), 'connection set face pair(s) not assigned to exactly one feature'  # rough check
+            assert self.fi_cl.shape == (self.count,),  \
+                'connection set face pair(s) not assigned to exactly one feature'  # rough check
 
         # delattr(self, 'fi_cl')  # assumed to be one-to-one mapping, so cumulative length is discarded
 
@@ -1196,7 +1206,7 @@ class GridConnectionSet(BaseResqpy):
             # uuid/InterpretationIndices/elements  (N,)  uint32
             h5_reg.register_dataset(self.uuid, 'InterpretationIndices/elements', self.feature_indices)
             # uuid/InterpretationIndices/cumulativeLength  (N,)  uint32
-            one_to_one = np.arange(1, self.count + 1, dtype = int)
+            one_to_one = np.arange(1, self.count + 1, dtype = np.uint32)
             h5_reg.register_dataset(self.uuid, 'InterpretationIndices/cumulativeLength', one_to_one)
 
         h5_reg.write(file_name, mode = mode)
@@ -1371,11 +1381,16 @@ class GridConnectionSet(BaseResqpy):
                         include_both_sides = False,
                         use_minus = False,
                         trans_mult_uuid = None):
-        """Creates a Nexus include file holding MULT keywords and data. trans_mult_uuid (optional) is the uuid of a property on the gcs containing transmissibility multiplier values. If not provided values of 1.0 will be used."""
+        """Creates a Nexus include file holding MULT keywords and data. 
+
+        note:
+            trans_mult_uuid (optional) is the uuid of a property on the gcs containing transmissibility multiplier values;
+            If not provided values of 1.0 will be used
+        """
         if trans_mult_uuid is not None:
             self.extract_property_collection()
-            assert self.property_collection.part_in_collection(self.model.part_for_uuid(
-                trans_mult_uuid)), f'trans_mult_uuid provided is not part of collection {trans_mult_uuid}'
+            assert self.property_collection.part_in_collection(self.model.part_for_uuid(trans_mult_uuid)),  \
+                f'trans_mult_uuid provided is not part of collection {trans_mult_uuid}'
             tmult_array = self.property_collection.cached_part_array_ref(self.model.part_for_uuid(trans_mult_uuid))
             assert tmult_array is not None
         else:
@@ -1421,26 +1436,39 @@ class GridConnectionSet(BaseResqpy):
                 feature_name = self.feature_list[feature_index][2].split()[0].upper()
                 cell_index_pairs, face_index_pairs = self.list_of_cell_face_pairs_for_feature_index(feature_index)
                 if tmult_array is not None:
-                    feature_mask = np.where(self.feature_indices == feature_index, 1, 0)
+                    feature_mask = (self.feature_indices == feature_index)
                     feat_mult_array = np.extract(feature_mask, tmult_array)
                 else:
                     feat_mult_array = np.ones(shape = (cell_index_pairs.shape[0],), dtype = float)
                 for side in sides:
-                    both = np.empty((cell_index_pairs.shape[0], 6), dtype = int)  # axis, polarity, k, j, i, tmult
+                    both = np.empty((cell_index_pairs.shape[0], 5), dtype = np.int32)  # axis, polarity, k, j, i
                     both[:, :2] = face_index_pairs[:, side, :]  # axis, polarity
-                    both[:, 2:-1] = cell_index_pairs[:, side, :]  # k, j, i
-                    both[:, -1] = feat_mult_array.flatten()
-                    df = pd.DataFrame(both, columns = ['axis', 'polarity', 'k', 'j', 'i', 'tmult'])
-                    df = df.sort_values(by = ['axis', 'polarity', 'j', 'i', 'k', 'tmult'])
-                    both_sorted = np.empty(both.shape, dtype = int)
-                    both_sorted[:] = df
-                    cell_indices = both_sorted[:, 2:-1]
-                    face_indices = np.empty((both_sorted.shape[0], 2), dtype = int)
-                    face_indices[:, :] = both_sorted[:, :2]
-                    tmult_values = both_sorted[:, -1]
-                    del both_sorted
+                    both[:, 2:] = cell_index_pairs[:, side, :]  # k, j, i
+                    # both[:, -1] = feat_mult_array.flatten()
+                    # df = pd.DataFrame(both, columns = ['axis', 'polarity', 'k', 'j', 'i', 'tmult'])
+                    # df = df.sort_values(by = ['axis', 'polarity', 'j', 'i', 'k', 'tmult'])
+                    # both_sorted = np.empty(both.shape, dtype = np.int32)
+                    # both_sorted[:] = df
+                    si = np.argsort(both[:, 2])  # k
+                    msi = si
+                    both = both[si]
+                    si = np.argsort(both[:, 4], kind = 'stable')  # i
+                    msi = msi[si]
+                    both = both[si]
+                    si = np.argsort(both[:, 3], kind = 'stable')  # j
+                    msi = msi[si]
+                    both = both[si]
+                    si = np.argsort(both[:, 1], kind = 'stable')  # polarity
+                    msi = msi[si]
+                    both = both[si]
+                    si = np.argsort(both[:, 0], kind = 'stable')  # axis
+                    msi = msi[si]
+                    both = both[si]
+                    cell_indices = both[:, 2:]
+                    face_indices = np.empty((both.shape[0], 2), dtype = np.int8)
+                    face_indices[:, :] = both[:, :2]
+                    tmult_values = feat_mult_array[msi]
                     del both
-                    del df
                     k = None
                     i = j = k2 = axis = polarity = None  # only needed to placate flake8 which whinges incorrectly otherwise
                     for row in range(cell_indices.shape[0]):
@@ -1692,7 +1720,7 @@ class GridConnectionSet(BaseResqpy):
                     combined_values = property_value_by_column_edge.copy()
                 else:
                     combined_values = None
-                combined_index = np.full((fault_by_column_edge_mask.shape), -1, dtype = int)
+                combined_index = np.full((fault_by_column_edge_mask.shape), -1, dtype = np.int32)
                 combined_index = np.where(fault_by_column_edge_mask, feature, combined_index)
                 sum_unmasked = np.sum(fault_by_column_edge_mask)
             else:
@@ -1802,7 +1830,7 @@ class GridConnectionSet(BaseResqpy):
         def sorted_paired_cell_face_index_position(cell_face_index, a_or_b):
             # pair one side (a_or_b) of cell_face_index with its position, then sort
             count = len(cell_face_index)
-            sp = np.empty((count, 2), dtype = int)
+            sp = np.empty((count, 2), dtype = np.int32)
             sp[:, 0] = cell_face_index[:, a_or_b]
             sp[:, 1] = np.arange(count)
             t = [tuple(r) for r in sp]  # could use numpy fields based sort instead of tuple list?
@@ -1985,19 +2013,19 @@ class GridConnectionSet(BaseResqpy):
             for k0 in range(entry['k1'], entry['k2'] + 1):
                 for j0 in range(entry['j1'], entry['j2'] + 1):
                     for i0 in range(entry['i1'], entry['i2'] + 1):
-                        neighbour = np.array([k0, j0, i0], dtype = int)
+                        neighbour = np.array([k0, j0, i0], dtype = np.int32)
                         if fp:
                             neighbour[axis] += 1
                         else:
                             neighbour[axis] -= 1
                         fi_list.append(feature_index)
-                        cell_pair_list.append((grid.natural_cell_index(
-                            (k0, j0, i0)), grid.natural_cell_index(neighbour)))
+                        cell_pair_list.append((grid.natural_cell_index((k0, j0, i0)),  \
+                                               grid.natural_cell_index(neighbour)))
                         face_pair_list.append((self.face_index_map[axis, fp], self.face_index_map[axis, 1 - fp]))
                         if create_mult_prop:
                             mult_list.append(multiplier)
         if fi_root is not None and fault_const_mult and fault_mult_value is not None:
-            #patch extra_metadata into xml for new fault interpretation object
+            # patch extra_metadata into xml for new fault interpretation object
             rqet.create_metadata_xml(fi_root, {"Transmissibility multiplier": str(fault_mult_value)})
         return True, const_mult
 

resqpy/grid/_grid.py

@@ -265,6 +265,10 @@ class Grid(BaseResqpy):
             return np.count_nonzero(self.array_cell_geometry_is_defined)
         return None
 
+    def is_big(self):
+        """Returns True if number of cells exceeds 2^31 - 1, otherwise False."""
+        return (np.prod(self.extent_kji) >= 2_147_483_648)
+
     def natural_cell_index(self, cell_kji0):
         """Returns a single integer for the cell, being the index into a flattened array."""
 

resqpy/grid_surface/_blocked_well_populate.py

@@ -118,7 +118,7 @@ def populate_blocked_well_from_trajectory(blocked_well,
         if xyz is None:
             log.error('failed to lazily find intersection of trajectory with top surface of grid')
             return None
-        cell_kji0 = np.array((0, col_ji0[0], col_ji0[1]), dtype = int)
+        cell_kji0 = np.array((0, col_ji0[0], col_ji0[1]), dtype = np.int32)
         axis = 0
         polarity = 0
 
@@ -133,7 +133,7 @@ def populate_blocked_well_from_trajectory(blocked_well,
         else:
             log.debug(f"skin intersection x,y,z: {xyz}; knot: {entry_knot}; cell kji0: {cell_kji0}; face: "
                       f"{'KJI'[axis]}{'-+'[polarity]}")
-            cell_kji0 = np.array(cell_kji0, dtype = int)
+            cell_kji0 = np.array(cell_kji0, dtype = np.int32)
 
     previous_kji0 = cell_kji0.copy()
     previous_kji0[axis] += polarity * 2 - 1  # note: previous may legitimately be 'beyond' edge of grid
@@ -244,9 +244,9 @@ def populate_blocked_well_from_trajectory(blocked_well,
 
     blocked_well.node_mds = np.array(node_mds_list, dtype = float)
     blocked_well.node_count = node_count
-    blocked_well.grid_indices = np.array(grid_indices_list, dtype = int)
-    blocked_well.cell_indices = np.array(cell_indices_list, dtype = int)
-    blocked_well.face_pair_indices = np.array(face_pairs_list, dtype = int)
+    blocked_well.grid_indices = np.array(grid_indices_list, dtype = np.int32)
+    blocked_well.cell_indices = np.array(cell_indices_list, dtype = np.int64)
+    blocked_well.face_pair_indices = np.array(face_pairs_list, dtype = np.int8)
     blocked_well.cell_count = cell_count
     blocked_well.grid_list = [grid]
 

resqpy/grid_surface/_find_faces.py

@@ -599,6 +599,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         grid.block_dxyz_dkji[0, 2],
     )
     triangles, points = surface.triangles_and_points()
+    t_dtype = np.int32 if len(triangles) < 2_000_000_000 else np.int64
     assert (triangles is not None and points is not None), f"surface {surface.title} is empty"
     if agitate:
         if random_agitation:
@@ -622,7 +623,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     if nk > 1:
         # log.debug("searching for k faces")
         k_faces = np.zeros((nk - 1, grid.nj, grid.ni), dtype = bool)
-        k_triangles = np.full((nk - 1, grid.nj, grid.ni), -1, dtype = int)
+        k_triangles = np.full((nk - 1, grid.nj, grid.ni), -1, dtype = t_dtype)
         k_depths = np.full((nk - 1, grid.nj, grid.ni), np.nan)
         k_offsets = np.full((nk - 1, grid.nj, grid.ni), np.nan)
         p_xy = np.delete(points, 2, 1)
@@ -666,7 +667,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     if grid.nj > 1:
         # log.debug("searching for j faces")
         j_faces = np.zeros((nk, grid.nj - 1, grid.ni), dtype = bool)
-        j_triangles = np.full((nk, grid.nj - 1, grid.ni), -1, dtype = int)
+        j_triangles = np.full((nk, grid.nj - 1, grid.ni), -1, dtype = t_dtype)
         j_depths = np.full((nk, grid.nj - 1, grid.ni), np.nan)
         j_offsets = np.full((nk, grid.nj - 1, grid.ni), np.nan)
         p_xz = np.delete(points, 1, 1)
@@ -715,7 +716,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     if grid.ni > 1:
         # log.debug("searching for i faces")
         i_faces = np.zeros((nk, grid.nj, grid.ni - 1), dtype = bool)
-        i_triangles = np.full((nk, grid.nj, grid.ni - 1), -1, dtype = int)
+        i_triangles = np.full((nk, grid.nj, grid.ni - 1), -1, dtype = t_dtype)
         i_depths = np.full((nk, grid.nj, grid.ni - 1), np.nan)
         i_offsets = np.full((nk, grid.nj, grid.ni - 1), np.nan)
         p_yz = np.delete(points, 0, 1)

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/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