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

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

@@ -438,10 +438,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 +454,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 +951,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 +1141,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 +1336,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 +1364,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))

resqpy/surface/_tri_mesh.py

@@ -120,6 +120,7 @@ class TriMesh(rqs.Mesh):
                 self.origin = None
             else:
                 self.origin = origin
+        self.t_type = np.int32 if self.is_big() else np.int64
 
     @classmethod
     def from_tri_mesh_and_z_values(cls,
@@ -302,7 +303,7 @@ class TriMesh(rqs.Mesh):
     def tri_nodes_for_tji(self, tji):
         """Return mesh node indices, shape (3, 2), for triangle tji (tj, ti)."""
         j, i = tji
-        tn = np.zeros((3, 2), dtype = int)
+        tn = np.zeros((3, 2), dtype = self.t_type)
         j_odd = j % 2
         i2, i_odd = divmod(i, 2)
         assert 0 <= j < self.nj - 1 and 0 <= i < 2 * (self.ni - 1)
@@ -325,7 +326,7 @@ class TriMesh(rqs.Mesh):
         j = tji_array[..., 0]
         i = tji_array[..., 1]
         tn_shape = tuple(list(tji_array.shape[:-1]) + [3, 2])
-        tn = np.zeros(tn_shape, dtype = int)
+        tn = np.zeros(tn_shape, dtype = self.t_type)
         j_odd = j % 2
         i2, i_odd = np.divmod(i, 2)
         mask = np.logical_or(np.logical_or(j < 0, j >= self.nj - 1), np.logical_or(i < 0, i >= 2 * (self.ni - 1)))
@@ -342,9 +343,9 @@ class TriMesh(rqs.Mesh):
 
     def all_tri_nodes(self):
         """Returns array of mesh node indices for all triangles, shape (nj - 1, 2 * (ni - 1), 3, 2)."""
-        tna = np.zeros((self.nj - 1, 2 * (self.ni - 1), 3, 2), dtype = int)
+        tna = np.zeros((self.nj - 1, 2 * (self.ni - 1), 3, 2), dtype = self.t_type)
         # set mesh j indices
-        tna[:, :, 0, 0] = np.expand_dims(np.arange(self.nj - 1, dtype = int), axis = -1)
+        tna[:, :, 0, 0] = np.expand_dims(np.arange(self.nj - 1, dtype = self.t_type), axis = -1)
         tna[1::2, ::2, 0, 0] += 1
         tna[::2, 1::2, 0, 0] += 1
         tna[:, :, 1, 0] = tna[:, :, 0, 0]
@@ -352,7 +353,7 @@ class TriMesh(rqs.Mesh):
         tna[1::2, ::2, 2, 0] -= 2
         tna[::2, 1::2, 2, 0] -= 2
         # set mesh i indices
-        tna[:, ::2, 0, 1] = np.expand_dims(np.arange(self.ni - 1, dtype = int), axis = 0)
+        tna[:, ::2, 0, 1] = np.expand_dims(np.arange(self.ni - 1, dtype = self.t_type), axis = 0)
         tna[:, 1::2, 0, 1] = tna[:, ::2, 0, 1]
         tna[:, :, 1, 1] = tna[:, :, 0, 1] + 1
         tna[:, :, 2, 1] = tna[:, :, 0, 1]
@@ -362,7 +363,7 @@ class TriMesh(rqs.Mesh):
     def triangles_and_points(self):
         """Returns node indices and xyz points in form suitable for a Surface (triangulated set)."""
         tna = self.all_tri_nodes()
-        composite_ji = tna[:, :, :, 0] * self.ni + tna[:, :, :, 1]
+        composite_ji = (tna[:, :, :, 0] * self.ni + tna[:, :, :, 1]).astype(self.t_type)
         return (composite_ji.reshape((-1, 3)), self.full_array_ref().reshape((-1, 3)))
 
     def tji_for_triangle_index(self, ti):
@@ -410,7 +411,7 @@ class TriMesh(rqs.Mesh):
                                                          tp)
         tn_a[:, 1] *= 2  # node j
 
-        return np.concatenate((tn_a, tn_b), axis = 0)
+        return np.concatenate((tn_a, tn_b), axis = 0).astype(self.t_type)
 
     def edge_zero_crossings(self, z_values = None):
         """Returns numpy list of points from edges where z values cross zero (or given value).

resqpy/surface/_triangulated_patch.py

@@ -31,6 +31,7 @@ class TriangulatedPatch:
         self.ni = None  # used to convert a triangle index back into a (j, i) pair when freshly built from mesh
         self.points = None
         self.crs_uuid = crs_uuid
+        self.t_type = np.int32  # gets set to int64 if number of points requires it
         if patch_node is not None:
             xml_patch_index = rqet.find_tag_int(patch_node, 'PatchIndex')
             assert xml_patch_index is not None
@@ -87,6 +88,7 @@ class TriangulatedPatch:
         except Exception:
             log.error('hdf5 points failure for triangle patch ' + str(self.patch_index))
             raise
+        self._set_t_type()
         triangles_node = rqet.find_tag(self.node, 'Triangles')
         h5_key_pair = self.model.h5_uuid_and_path_for_node(triangles_node)
         if h5_key_pair is None:
@@ -97,7 +99,7 @@ class TriangulatedPatch:
                                         cache_array = True,
                                         object = self,
                                         array_attribute = 'triangles',
-                                        dtype = 'int')
+                                        dtype = self.t_type)
         except Exception:
             log.error('hdf5 triangles failure for triangle patch ' + str(self.patch_index))
             raise
@@ -147,7 +149,7 @@ class TriangulatedPatch:
         # find unique points used by those triangles
         p_keep = np.unique(large_t[t_in])
         # note new point index for each old point that is being kept
-        p_map = np.full(len(points_in), -1, dtype = int)
+        p_map = np.full(len(points_in), -1, dtype = large_t.dtype)
         p_map[p_keep] = np.arange(len(p_keep))
         # copy those unique points into a trimmed points array
         points_trimmed = large_p[p_keep]
@@ -190,10 +192,10 @@ class TriangulatedPatch:
         # create pair of triangles
         if quad_triangles:
             self.triangle_count = 4
-            self.triangles = np.array([[0, 2, 4], [2, 1, 4], [1, 3, 4], [3, 0, 4]], dtype = int)
+            self.triangles = np.array([[0, 2, 4], [2, 1, 4], [1, 3, 4], [3, 0, 4]], dtype = self.t_type)
         else:
             self.triangle_count = 2
-            self.triangles = np.array([[0, 1, 2], [0, 3, 1]], dtype = int)
+            self.triangles = np.array([[0, 1, 2], [0, 3, 1]], dtype = self.t_type)
 
     def set_to_triangle(self, corners):
         """Populate this (empty) patch with a single triangle."""
@@ -202,12 +204,12 @@ class TriangulatedPatch:
         self.node_count = 3
         self.points = corners.copy()
         self.triangle_count = 1
-        self.triangles = np.array([[0, 1, 2]], dtype = int)
+        self.triangles = np.array([[0, 1, 2]], dtype = self.t_type)
 
     def set_to_triangle_pair(self, corners):
         """Populate this (empty) patch with a pair of triangles."""
 
-        self.set_from_triangles_and_points(np.array([[0, 1, 3], [0, 3, 2]], dtype = int), corners)
+        self.set_from_triangles_and_points(np.array([[0, 1, 3], [0, 3, 2]], dtype = self.t_type), corners)
 
     def set_from_triangles_and_points(self, triangles, points):
         """Populate this (empty) patch from triangle node indices and points from elsewhere."""
@@ -240,7 +242,7 @@ class TriangulatedPatch:
         self.node_count = (n + 1) * (n + 2) // 2
         self.points = np.empty((self.node_count, 3))
         self.triangle_count = n * n
-        self.triangles = np.empty((self.triangle_count, 3), dtype = int)
+        self.triangles = np.empty((self.triangle_count, 3), dtype = self.t_type)
         self.points[0] = sail_point(centre, radius, azimuth, 0.0).copy()
         p = 0
         t = 0
@@ -282,11 +284,12 @@ class TriangulatedPatch:
             quad_centres[:, :] = 0.25 * (mesh_xyz[:-1, :-1, :] + mesh_xyz[:-1, 1:, :] + mesh_xyz[1:, :-1, :] +
                                          mesh_xyz[1:, 1:, :]).reshape((-1, 3))
             self.points = np.concatenate((mesh_xyz.copy().reshape((-1, 3)), quad_centres))
+            self._set_t_type()
             mesh_size = mesh_xyz.size // 3
             self.node_count = self.points.size // 3
             self.triangle_count = 4 * (mesh_shape[0] - 1) * (mesh_shape[1] - 1)
             self.quad_triangles = True
-            triangles = np.empty((mesh_shape[0] - 1, mesh_shape[1] - 1, 4, 3), dtype = int)  # flatten later
+            triangles = np.empty((mesh_shape[0] - 1, mesh_shape[1] - 1, 4, 3), dtype = self.t_type)  # flatten later
             nic = ni - 1
             for j in range(mesh_shape[0] - 1):
                 for i in range(nic):
@@ -298,10 +301,11 @@ class TriangulatedPatch:
                     triangles[j, i, 3, 2] = j * ni + i
         else:
             self.points = mesh_xyz.copy().reshape((-1, 3))
+            self._set_t_type()
             self.node_count = mesh_shape[0] * mesh_shape[1]
             self.triangle_count = 2 * (mesh_shape[0] - 1) * (mesh_shape[1] - 1)
             self.quad_triangles = False
-            triangles = np.empty((mesh_shape[0] - 1, mesh_shape[1] - 1, 2, 3), dtype = int)  # flatten later
+            triangles = np.empty((mesh_shape[0] - 1, mesh_shape[1] - 1, 2, 3), dtype = self.t_type)  # flatten later
             for j in range(mesh_shape[0] - 1):
                 for i in range(mesh_shape[1] - 1):
                     triangles[j, i, 0, 0] = j * ni + i
@@ -321,7 +325,7 @@ class TriangulatedPatch:
 
         indices = self.get_indices_from_sparse_meshxyz(mesh_xyz)
 
-        triangles = np.zeros((2 * (mesh_shape[0] - 1) * (mesh_shape[1] - 1), 3), dtype = int)  # truncate later
+        triangles = np.zeros((2 * (mesh_shape[0] - 1) * (mesh_shape[1] - 1), 3), dtype = self.t_type)  # truncate later
         nt = 0
         for j in range(mesh_shape[0] - 1):
             for i in range(mesh_shape[1] - 1):
@@ -357,7 +361,7 @@ class TriangulatedPatch:
                 else:
                     raise Exception('code failure in sparse mesh processing')
         self.ni = None
-        self.triangles = triangles[:nt, :]
+        self.triangles = triangles[:nt, :].copy()
         self.triangle_count = nt
 
     def get_indices_from_sparse_meshxyz(self, mesh_xyz):
@@ -373,6 +377,7 @@ class TriangulatedPatch:
             points[i] = mesh_xyz[non_nans[0][i], non_nans[1][i]]
             indices[non_nans[0][i], non_nans[1][i]] = i
         self.points = points[:len(non_nans[0]), :]
+        self._set_t_type()
         self.node_count = len(non_nans[0])
 
         return indices
@@ -389,11 +394,12 @@ class TriangulatedPatch:
             quad_centres = np.empty((nj, ni, 3))
             quad_centres[:, :, :] = 0.25 * np.sum(mesh_xyz, axis = (2, 3))
             self.points = np.concatenate((mesh_xyz.copy().reshape((-1, 3)), quad_centres.reshape((-1, 3))))
+            self._set_t_type()
             mesh_size = mesh_xyz.size // 3
             self.node_count = 5 * nj * ni
             self.triangle_count = 4 * nj * ni
             self.quad_triangles = True
-            triangles = np.empty((nj, ni, 4, 3), dtype = int)  # flatten later
+            triangles = np.empty((nj, ni, 4, 3), dtype = self.t_type)  # flatten later
             for j in range(nj):
                 for i in range(ni):
                     base_p = 4 * (j * ni + i)
@@ -405,10 +411,11 @@ class TriangulatedPatch:
                     triangles[j, i, 3, 2] = base_p
         else:
             self.points = mesh_xyz.copy().reshape((-1, 3))
+            self._set_t_type()
             self.node_count = 4 * nj * ni
             self.triangle_count = 2 * nj * ni
             self.quad_triangles = False
-            triangles = np.empty((nj, ni, 2, 3), dtype = int)  # flatten later
+            triangles = np.empty((nj, ni, 2, 3), dtype = self.t_type)  # flatten later
             for j in range(nj):
                 for i in range(ni):
                     base_p = 4 * (j * ni + i)
@@ -469,7 +476,8 @@ class TriangulatedPatch:
         self.triangle_count = 12
         self.node_count = 8
         self.points = cp.copy().reshape((-1, 3))
-        triangles = np.empty((3, 2, 2, 3), dtype = int)  # flatten later
+        self._set_t_type()
+        triangles = np.empty((3, 2, 2, 3), dtype = self.t_type)  # flatten later
         for axis in range(3):
             if axis == 0:
                 ip1, ip2 = 2, 1
@@ -500,7 +508,8 @@ class TriangulatedPatch:
         quad_centres[2, 1, :] = 0.25 * np.sum(cp[:, :, 1, :], axis = (0, 1))  # I+
         self.node_count = 14
         self.points = np.concatenate((cp.copy().reshape((-1, 3)), quad_centres.reshape((-1, 3))))
-        triangles = np.empty((3, 2, 4, 3), dtype = int)  # flatten later
+        self._set_t_type()
+        triangles = np.empty((3, 2, 4, 3), dtype = self.t_type)  # flatten later
         for axis in range(3):
             if axis == 0:
                 ip1, ip2 = 2, 1
@@ -544,3 +553,6 @@ class TriangulatedPatch:
         _, _ = self.triangles_and_points()  # ensure points are loaded
         z_values = self.points[:, 2].copy()
         self.points[:, 2] = ref_depth + scaling_factor * (z_values - ref_depth)
+
+    def _set_t_type(self):
+        self.t_type = np.int64 if len(self.points) > 2_147_483_648 else np.int32

resqpy/well/_blocked_well.py

@@ -136,6 +136,7 @@ class BlockedWell(BaseResqpy):
         self.wellbore_interpretation = None  #: associated wellbore interpretation object
         self.wellbore_feature = None  #: associated wellbore feature object
         self.well_name = None  #: name of well to import from ascii file formats
+        self.cell_index_dtype = np.int32  #: set to int64 if any grid has more than 2^31 - 1 cells, otherwise int32
 
         self.cell_interval_map = None  # maps from cell index to interval (ie. node) index; populated on demand
 
@@ -150,11 +151,11 @@ class BlockedWell(BaseResqpy):
         # 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
 
         super().__init__(model = parent_model,
@@ -238,14 +239,14 @@ class BlockedWell(BaseResqpy):
 
         assert self.cell_count < self.node_count
 
-        self.__find_ci_node_and_load_hdf5_array(node = node)
-
-        self.__find_fi_node_and_load_hdf5_array(node)
-
         unique_grid_indices = self.__find_gi_node_and_load_hdf5_array(node = node)
 
         self.__find_grid_node(node = node, unique_grid_indices = unique_grid_indices)
 
+        self.__find_ci_node_and_load_hdf5_array(node = node)
+
+        self.__find_fi_node_and_load_hdf5_array(node)
+
         interp_uuid = rqet.find_nested_tags_text(node, ['RepresentedInterpretation', 'UUID'])
         if interp_uuid is None:
             self.wellbore_interpretation = None
@@ -273,7 +274,7 @@ class BlockedWell(BaseResqpy):
 
         ci_node = rqet.find_tag(node, 'CellIndices')
         assert ci_node is not None, 'blocked well cell indices hdf5 reference not found in xml'
-        rqwu.load_hdf5_array(self, ci_node, 'cell_indices', dtype = int)
+        rqwu.load_hdf5_array(self, ci_node, 'cell_indices', dtype = self.cell_index_dtype)
         assert (self.cell_indices is not None and self.cell_indices.ndim == 1 and
                 self.cell_indices.size == self.cell_count), 'mismatch in number of cell indices for blocked well'
         self.cellind_null = rqet.find_tag_int(ci_node, 'NullValue')
@@ -285,7 +286,7 @@ class BlockedWell(BaseResqpy):
 
         fi_node = rqet.find_tag(node, 'LocalFacePairPerCellIndices')
         assert fi_node is not None, 'blocked well face indices hdf5 reference not found in xml'
-        rqwu.load_hdf5_array(self, fi_node, 'raw_face_indices', dtype = 'int')
+        rqwu.load_hdf5_array(self, fi_node, 'raw_face_indices', dtype = np.int8)
         assert self.raw_face_indices is not None, 'failed to load face indices for blocked well'
         assert self.raw_face_indices.size == 2 * self.cell_count, 'mismatch in number of cell faces for blocked well'
         if self.raw_face_indices.ndim > 1:
@@ -305,15 +306,14 @@ class BlockedWell(BaseResqpy):
 
         gi_node = rqet.find_tag(node, 'GridIndices')
         assert gi_node is not None, 'blocked well grid indices hdf5 reference not found in xml'
-        rqwu.load_hdf5_array(self, gi_node, 'grid_indices', dtype = 'int')
+        rqwu.load_hdf5_array(self, gi_node, 'grid_indices', dtype = np.int32)
         # assert self.grid_indices is not None and self.grid_indices.ndim == 1 and self.grid_indices.size == self.node_count - 1
         # temporary code to handle blocked wells with incorrectly shaped grid indices wrt. nodes
         assert self.grid_indices is not None and self.grid_indices.ndim == 1
         if self.grid_indices.size != self.node_count - 1:
             if self.grid_indices.size == self.cell_count and self.node_count == 2 * self.cell_count:
                 log.warning(f'handling node duplication or missing unblocked intervals in blocked well: {self.title}')
-
-                expanded_grid_indices = np.full(self.node_count - 1, -1, dtype = int)
+                expanded_grid_indices = np.full(self.node_count - 1, -1, dtype = np.int32)
                 expanded_grid_indices[::2] = self.grid_indices
                 self.grid_indices = expanded_grid_indices
             else:
@@ -342,6 +342,8 @@ class BlockedWell(BaseResqpy):
             grid_uuid = rqet.uuid_for_part_root(grid_node)
             grid_obj = self.model.grid(uuid = grid_uuid, find_properties = False)
             self.grid_list.append(grid_obj)
+            if grid_obj.is_big():
+                self.cell_index_dtype = np.int64
 
     def extract_property_collection(self, refresh = False):
         """Returns a property collection for the blocked well."""
@@ -434,7 +436,7 @@ class BlockedWell(BaseResqpy):
     def _set_cell_interval_map(self):
         """Sets up an index mapping from blocked cell index to interval index, accounting for unblocked intervals."""
 
-        self.cell_interval_map = np.zeros(self.cell_count, dtype = int)
+        self.cell_interval_map = np.zeros(self.cell_count, dtype = np.int32)
         ci = 0
         for ii in range(self.node_count - 1):
             if self.grid_indices[ii] < 0:
@@ -461,7 +463,7 @@ class BlockedWell(BaseResqpy):
         grid_for_cell_list = []
         grid_indices = self.compressed_grid_indices()
         assert len(grid_indices) == self.cell_count
-        cell_indices = np.empty((self.cell_count, 3), dtype = int)
+        cell_indices = np.empty((self.cell_count, 3), dtype = np.int32)
         for cell_number in range(self.cell_count):
             grid = self.grid_list[grid_indices[cell_number]]
             grid_for_cell_list.append(grid)
@@ -493,7 +495,7 @@ class BlockedWell(BaseResqpy):
 
         if cells_kji0 is None or len(cells_kji0) == 0:
             return None
-        well_box = np.empty((2, 3), dtype = int)
+        well_box = np.empty((2, 3), dtype = np.int32)
         well_box[0] = np.min(cells_kji0, axis = 0)
         well_box[1] = np.max(cells_kji0, axis = 0)
         return well_box
@@ -853,9 +855,9 @@ class BlockedWell(BaseResqpy):
         self.node_count = len(trajectory_mds)
         self.node_mds = np.array(trajectory_mds)
         self.cell_count = len(blocked_cells_kji0)
-        self.grid_indices = np.array(blocked_intervals, dtype = int)  # NB. only supporting one grid at the moment
-        self.cell_indices = grid.natural_cell_indices(np.array(blocked_cells_kji0))
-        self.face_pair_indices = np.array(blocked_face_pairs, dtype = int)
+        self.grid_indices = np.array(blocked_intervals, dtype = np.int32)  # NB. only supporting one grid at the moment
+        self.cell_indices = grid.natural_cell_indices(np.array(blocked_cells_kji0)).astype(self.cell_index_dtype)
+        self.face_pair_indices = np.array(blocked_face_pairs, dtype = np.int8)
         self.grid_list = [grid]
 
         trajectory_points, trajectory_mds = BlockedWell.__add_tail_to_trajectory_if_necessary(
@@ -877,7 +879,7 @@ class BlockedWell(BaseResqpy):
         row = df.iloc[df_row]
         if pd.isna(row[0]) or pd.isna(row[1]) or pd.isna(row[2]):
             return None
-        cell_kji0 = np.empty((3,), dtype = int)
+        cell_kji0 = np.empty((3,), dtype = np.int32)
         cell_kji0[:] = row[2], row[1], row[0]
         cell_kji0[:] -= 1
         return cell_kji0
@@ -1201,9 +1203,10 @@ class BlockedWell(BaseResqpy):
                 self.node_count = len(trajectory_mds)
                 self.node_mds = np.array(trajectory_mds)
                 self.cell_count = len(blocked_cells_kji0)
-                self.grid_indices = np.array(blocked_intervals,
-                                             dtype = int)  # NB. only supporting one grid at the moment
-                self.cell_indices = grid.natural_cell_indices(np.array(blocked_cells_kji0))
+                # NB. only supporting one grid at the moment
+                self.grid_indices = np.array(blocked_intervals, dtype = np.int32)
+                self.cell_indices = grid.natural_cell_indices(np.array(blocked_cells_kji0)).astype(
+                    self.cell_index_dtype)
                 self.face_pair_indices = np.array(blocked_face_pairs)
                 self.grid_list = [grid]
 
@@ -1240,7 +1243,7 @@ class BlockedWell(BaseResqpy):
         words = line.split()
         assert len(words) >= 9, 'not enough items on data line in cell I/O file, minimum 9 expected'
         i1, j1, k1 = int(words[0]), int(words[1]), int(words[2])
-        cell_kji0 = np.array((k1 - 1, j1 - 1, i1 - 1), dtype = int)
+        cell_kji0 = np.array((k1 - 1, j1 - 1, i1 - 1), dtype = np.int32)
         assert np.all(0 <= cell_kji0) and np.all(
             cell_kji0 < grid.extent_kji), 'cell I/O cell index not within grid extent'
         entry_xyz = np.array((float(words[3]), float(words[4]), float(words[5])))
@@ -1511,7 +1514,7 @@ class BlockedWell(BaseResqpy):
             for grid in self.grid_list:
                 grid.cache_all_geometry_arrays()
 
-        k_face_check = np.zeros((2, 2), dtype = int)
+        k_face_check = np.zeros((2, 2), dtype = np.int8)
         k_face_check[1, 1] = 1  # now represents entry, exit of K-, K+
         k_face_check_end = k_face_check.copy()
         k_face_check_end[1] = -1  # entry through K-, terminating (TD) within cell

resqpy/well/_trajectory.py

@@ -448,7 +448,7 @@ class Trajectory(BaseResqpy):
         """Loads the trajectory object based on the centre points of a list of cells."""
 
         assert grid is not None, 'grid argument missing for trajectory initislisation from cell list'
-        cell_kji0_list = np.array(cell_kji0_list, dtype = int)
+        cell_kji0_list = np.array(cell_kji0_list, dtype = np.int32)
         assert cell_kji0_list.ndim == 2 and cell_kji0_list.shape[1] == 3
         assert spline_mode in ['none', 'linear', 'square', 'cube']
 
@@ -483,7 +483,7 @@ class Trajectory(BaseResqpy):
         df = wellspec_dict[well_name]
         assert len(df) > 0, 'no rows of perforation data found in wellspec for well ' + well_name
 
-        cell_kji0_list = np.empty((len(df), 3), dtype = int)
+        cell_kji0_list = np.empty((len(df), 3), dtype = np.int32)
         cell_kji0_list[:, 0] = df['L']
         cell_kji0_list[:, 1] = df['JW']
         cell_kji0_list[:, 2] = df['IW']

resqpy/well/blocked_well_frame.py

@@ -191,7 +191,7 @@ def add_blocked_well_properties_from_wellbore_frame(bw,
         wb_a = np.zeros(bw.cell_count, dtype = bool)
         length = np.zeros(bw.cell_count, dtype = float)
         pperf = np.zeros(bw.cell_count, dtype = float)
-        dominant_wbf_interval = np.full(bw.cell_count, -1, dtype = int)
+        dominant_wbf_interval = np.full(bw.cell_count, -1, dtype = np.int32)
         ci = 0
         for wb_ii in range(bw.node_count - 1):
             if bw.grid_indices[wb_ii] < 0:

resqpy/well/well_object_funcs.py

@@ -442,10 +442,10 @@ def add_logs_from_cellio(blockedwell, cellio):
         df = df.apply(pd.to_numeric)
         # Get the cell_indices from the grid for the given i/j/k
         df['cell_indices'] = grid.natural_cell_indices(
-            np.array((df['k_index'] - 1, df['j_index'] - 1, df['i_index'] - 1), dtype = int).T)
+            np.array((df['k_index'] - 1, df['j_index'] - 1, df['i_index'] - 1), dtype = np.int32).T)
         df = df.drop(['i_index', 'j_index', 'k_index', 'x_in', 'y_in', 'z_in', 'x_out', 'y_out', 'z_out'], axis = 1)
-    assert (df['cell_indices'] == blockedwell.cell_indices
-           ).all(), 'Cell indices do not match between blocked well and log inputs'
+    assert (df['cell_indices'] == blockedwell.cell_indices).all(),  \
+        'Cell indices do not match between blocked well and log inputs'
 
     # Work out if the data columns are continuous, categorical or discrete
     type_dict = {}
@@ -468,11 +468,11 @@ def add_logs_from_cellio(blockedwell, cellio):
         if log not in ['cell_indices']:
             data_type = type_dict[log]
             if log == 'ZONES':
-                data_type, dtype, null, discrete = 'discrete', int, -1, True
+                data_type, dtype, null, discrete = 'discrete', np.int32, -1, True
             elif data_type == 'continuous':
                 dtype, null, discrete = float, np.nan, False
             else:
-                dtype, null, discrete = int, -1, True
+                dtype, null, discrete = np.int32, -1, True
             if data_type == 'categorical':
                 lookup_uuid = lookup_dict[log]  # For categorical data, find or generate a StringLookupTable
             else:

{resqpy-4.16.11.dist-info → resqpy-4.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: resqpy
-Version: 4.16.11
+Version: 4.17.0
 Summary: Python API for working with RESQML models
 Home-page: https://github.com/bp/resqpy
 License: MIT