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

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
@@ -56,52 +57,61 @@ class TriangulatedPatch:
             crs_root = self.model.root_for_uuid(self.crs_uuid)
         return crs_root, self.crs_uuid
 
-    def triangles_and_points(self):
+    def triangles_and_points(self, copy = False):
         """Returns arrays representing the patch.
 
-        Returns:
+        arguments:
+            copy (bool, default False): if True, a copy of the arrays is returned; if False, the cached
+              arrays are returned
+
+        returns:
            Tuple (triangles, points):
 
            * triangles (int array of shape[:, 3]): integer indices into points array,
              being the nodes of the corners of the triangles
            * points (float array of shape[:, 3]): flat array of xyz points, indexed by triangles
         """
-        if self.triangles is not None:
+        if self.triangles is None:
+
+            assert self.triangle_count is not None and self.node_count is not None
+
+            geometry_node = rqet.find_tag(self.node, 'Geometry')
+            assert geometry_node is not None
+            p_root = rqet.find_tag(geometry_node, 'Points')
+            assert p_root is not None, 'Points xml node not found for triangle patch'
+            assert rqet.node_type(p_root) == 'Point3dHdf5Array'
+            h5_key_pair = self.model.h5_uuid_and_path_for_node(p_root, tag = 'Coordinates')
+            if h5_key_pair is None:
+                return (None, None)
+            try:
+                self.model.h5_array_element(h5_key_pair,
+                                            cache_array = True,
+                                            object = self,
+                                            array_attribute = 'points',
+                                            dtype = 'float')
+            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:
+                log.warning('No Triangles found in xml for patch index: ' + str(self.patch_index))
+                return (None, None)
+            try:
+                self.model.h5_array_element(h5_key_pair,
+                                            cache_array = True,
+                                            object = self,
+                                            array_attribute = 'triangles',
+                                            dtype = self.t_type)
+            except Exception:
+                log.error('hdf5 triangles failure for triangle patch ' + str(self.patch_index))
+                raise
+
+        if copy:
+            return (self.triangles.copy(), self.points.copy())
+        else:
             return (self.triangles, self.points)
-        assert self.triangle_count is not None and self.node_count is not None
-
-        geometry_node = rqet.find_tag(self.node, 'Geometry')
-        assert geometry_node is not None
-        p_root = rqet.find_tag(geometry_node, 'Points')
-        assert p_root is not None, 'Points xml node not found for triangle patch'
-        assert rqet.node_type(p_root) == 'Point3dHdf5Array'
-        h5_key_pair = self.model.h5_uuid_and_path_for_node(p_root, tag = 'Coordinates')
-        if h5_key_pair is None:
-            return (None, None)
-        try:
-            self.model.h5_array_element(h5_key_pair,
-                                        cache_array = True,
-                                        object = self,
-                                        array_attribute = 'points',
-                                        dtype = 'float')
-        except Exception:
-            log.error('hdf5 points failure for triangle patch ' + str(self.patch_index))
-            raise
-        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:
-            log.warning('No Triangles found in xml for patch index: ' + str(self.patch_index))
-            return (None, None)
-        try:
-            self.model.h5_array_element(h5_key_pair,
-                                        cache_array = True,
-                                        object = self,
-                                        array_attribute = 'triangles',
-                                        dtype = 'int')
-        except Exception:
-            log.error('hdf5 triangles failure for triangle patch ' + str(self.patch_index))
-            raise
-        return (self.triangles, self.points)
 
     def set_to_trimmed_patch(self, larger_patch, xyz_box = None, xy_polygon = None, internal = False):
         """Populate this (empty) patch with triangles and points that overlap with a trimming volume.
@@ -147,7 +157,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 +200,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 +212,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 +250,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 +292,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 +309,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 +333,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 +369,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 +385,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 +402,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 +419,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 +484,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 +516,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 +561,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.1.dist-info}/METADATA

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