resqpy 4.14.2__py3-none-any.whl → 5.1.6__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,
@@ -218,6 +219,7 @@ class TriMesh(rqs.Mesh):
             base edge towards point 2; f1 is component towards point 1; f0 is component towards point 0;
             the trilinear coordinates sum to one and can be used as weights to interpolate z values at points
         """
+        assert xy_array.ndim > 1 and 2 <= xy_array.shape[-1] <= 3
         x = xy_array[..., 0].copy()
         y = xy_array[..., 1].copy()
         if self.origin is not None:
@@ -235,14 +237,14 @@ class TriMesh(rqs.Mesh):
         mask = np.logical_or(mask, np.logical_or(i < 0, i >= self.ni - 1))
         fx = ip - i.astype(float)
         i *= 2
-        am = np.where(fx > 1.0 - fy)
+        am = (fx > 1.0 - fy).astype(bool)
         i[am] += 1
         fx[am] -= 1.0 - fy[am]
         fy[am] = 1.0 - fy[am]
         j[mask] = -1
         i[mask] = -1
-        fx[mask] = np.NaN
-        fy[mask] = np.NaN
+        fx[mask] = np.nan
+        fy[mask] = np.nan
 
         return (np.stack((j, i), axis = -1), np.stack((1.0 - (fx + fy), fx, fy), axis = -1))
 
@@ -274,6 +276,7 @@ class TriMesh(rqs.Mesh):
             of three vertices of triangles containing xy points; float triplets contain corresponding weights (summing to
             one per triangle) which can be used to interpolate z values at points xy_array
         """
+        assert xy_array.ndim > 1 and 2 <= xy_array.shape[-1] <= 3
         tji, tc = self.tji_tc_for_xy_array(xy_array)
         ji = self.tri_nodes_for_tji_array(tji)
         return (ji, tc)
@@ -302,7 +305,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 +328,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 +345,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 +355,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 +365,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 +413,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/_tri_mesh_stencil.py

@@ -94,7 +94,7 @@ class TriMeshStencil:
         # convert into representation more njit & numpy friendly
         self.start_ip = np.array([ip for (ip, _, _) in half_hex], dtype = int)
         self.row_length = np.array([rl for (_, rl, _) in half_hex], dtype = int)
-        self.half_hex = np.full((self.n, 2 * self.n - 1), np.NaN, dtype = float)
+        self.half_hex = np.full((self.n, 2 * self.n - 1), np.nan, dtype = float)
         for jp in range(self.n):
             self.half_hex[jp, :self.row_length[jp]] = half_hex[jp][2]
 
@@ -210,7 +210,7 @@ class TriMeshStencil:
 
     # todo: class methods for mexican hat
 
-    def apply(self, tri_mesh, handle_nan = True, border_value = np.NaN, preserve_nan = False, title = None):
+    def apply(self, tri_mesh, handle_nan = True, border_value = np.nan, preserve_nan = False, title = None):
         """Return a new tri mesh with z values generated by applying the stencil to z values of an existing tri mesh.
 
         arguments:
@@ -250,7 +250,7 @@ class TriMeshStencil:
             if not np.any(nan_mask):
                 nan_mask = None
         z_values[border:border + tri_mesh.nj, border:border + tri_mesh.ni] = tm_z
-        applied = np.full((e_nj, e_ni), np.NaN, dtype = float)
+        applied = np.full((e_nj, e_ni), np.nan, dtype = float)
 
         if handle_nan:
             _apply_stencil_nanmean(self.n, self.start_ip, self.row_length, self.half_hex, z_values, applied, border,
@@ -262,7 +262,7 @@ class TriMeshStencil:
         # restore NaN values where they were present in input, if requested
         tm_z_applied = applied[border:border + tri_mesh.nj, border:border + tri_mesh.ni]
         if nan_mask is not None:
-            tm_z_applied[nan_mask] = np.NaN
+            tm_z_applied[nan_mask] = np.nan
 
         # create a new tri mesh object using the values from the applied array for z
         tm = rqs.TriMesh(tri_mesh.model,

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/time_series/_any_time_series.py

@@ -34,12 +34,15 @@ class AnyTimeSeries(BaseResqpy):
             dt_text = rqet.find_tag_text(child, 'DateTime')
             assert dt_text, 'missing DateTime field in xml for time series'
             year_offset = rqet.find_tag_int(child, 'YearOffset')
-            if year_offset:
-                assert self.timeframe == 'geologic'
+            if self.timeframe == 'geologic' and year_offset is not None:
+                if year_offset > 0:
+                    log.warning(f'positive year offset in xml indicates future geological time: {year_offset}')
                 self.timestamps.append(year_offset)  # todo: trim and check timestamp
-            else:
-                assert self.timeframe == 'human'
+            elif self.timeframe == 'human' and not year_offset:
+                # year_offset can be 0 for "human" time frames, indicating None.
                 self.timestamps.append(dt_text)  # todo: trim and check timestamp
+            else:
+                raise AssertionError(f'Invalid combination of timeframe {self.timeframe} and year_offset {year_offset}')
             self.timestamps.sort()
 
     def is_equivalent(self, other_ts):

resqpy/time_series/_geologic_time_series.py

@@ -29,7 +29,7 @@ class GeologicTimeSeries(ats.AnyTimeSeries):
 
         note:
            if instantiating from an existing RESQML time series, its Time entries must all have YearOffset data
-           which should be large negative integers
+           which should be large negative integers (or zero if reaching the current era)
 
         :meta common:
         """

resqpy/unstructured/_hexa_grid.py

@@ -23,7 +23,8 @@ class HexaGrid(rug.UnstructuredGrid):
                  cache_geometry = False,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Creates a new resqpy HexaGrid object (RESQML UnstructuredGrid with cell shape hexahedral)
 
         arguments:
@@ -39,6 +40,8 @@ class HexaGrid(rug.UnstructuredGrid):
               ignored if uuid is present
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if uuid is present
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created HexaGrid object
@@ -52,7 +55,8 @@ class HexaGrid(rug.UnstructuredGrid):
                          cell_shape = 'hexahedral',
                          title = title,
                          originator = originator,
-                         extra_metadata = extra_metadata)
+                         extra_metadata = extra_metadata,
+                         load_inactive = load_inactive)
 
         if self.root is not None:
             assert grr.grid_flavour(self.root) == 'HexaGrid'

resqpy/unstructured/_prism_grid.py

@@ -34,7 +34,8 @@ class PrismGrid(rug.UnstructuredGrid):
                  cache_geometry = False,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Creates a new resqpy PrismGrid object (RESQML UnstructuredGrid with cell shape trisngular prism)
 
         arguments:
@@ -50,6 +51,8 @@ class PrismGrid(rug.UnstructuredGrid):
               ignored if uuid is present
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if uuid is present
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created PrismGrid object
@@ -63,7 +66,8 @@ class PrismGrid(rug.UnstructuredGrid):
                          cell_shape = 'prism',
                          title = title,
                          originator = originator,
-                         extra_metadata = extra_metadata)
+                         extra_metadata = extra_metadata,
+                         load_inactive = load_inactive)
 
         if self.root is not None:
             assert grr.grid_flavour(self.root) in ['PrismGrid', 'VerticalPrismGrid']
@@ -110,7 +114,8 @@ class VerticalPrismGrid(PrismGrid):
                  cache_geometry = False,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Creates a new resqpy VerticalPrismGrid object.
 
         arguments:
@@ -126,6 +131,8 @@ class VerticalPrismGrid(PrismGrid):
               ignored if uuid is present
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if uuid is present
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created VerticalPrismGrid object
@@ -139,7 +146,8 @@ class VerticalPrismGrid(PrismGrid):
                          cache_geometry = cache_geometry,
                          title = title,
                          originator = originator,
-                         extra_metadata = extra_metadata)
+                         extra_metadata = extra_metadata,
+                         load_inactive = load_inactive)
 
         if self.root is not None:
             assert grr.grid_flavour(self.root) in ['VerticalPrismGrid', 'PrismGrid']
@@ -335,7 +343,7 @@ class VerticalPrismGrid(PrismGrid):
             if surf == 0:
                 # allow NaN entries to handle unused distant circumcentres in Voronoi graph data
                 # assert not np.any(nan_lines), 'top surface does not cover all column points'
-                single_intersects[nan_lines] = np.NaN
+                single_intersects[nan_lines] = np.nan
             else:
                 single_intersects[nan_lines] = points[surf - 1][nan_lines]
             # populate z values for layer of points

resqpy/unstructured/_pyramid_grid.py

@@ -22,7 +22,8 @@ class PyramidGrid(rug.UnstructuredGrid):
                  cache_geometry = False,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Creates a new resqpy PyramidGrid object (RESQML UnstructuredGrid with cell shape pyramidal)
 
         arguments:
@@ -38,6 +39,8 @@ class PyramidGrid(rug.UnstructuredGrid):
               ignored if uuid is present
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if uuid is present
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created PyramidGrid object
@@ -51,7 +54,8 @@ class PyramidGrid(rug.UnstructuredGrid):
                          cell_shape = 'pyramidal',
                          title = title,
                          originator = originator,
-                         extra_metadata = extra_metadata)
+                         extra_metadata = extra_metadata,
+                         load_inactive = load_inactive)
 
         if self.root is not None:
             assert grr.grid_flavour(self.root) == 'PyramidGrid'

resqpy/unstructured/_tetra_grid.py

@@ -24,7 +24,8 @@ class TetraGrid(rug.UnstructuredGrid):
                  cache_geometry = False,
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Creates a new resqpy TetraGrid object (RESQML UnstructuredGrid with cell shape tetrahedral)
 
         arguments:
@@ -40,6 +41,8 @@ class TetraGrid(rug.UnstructuredGrid):
               ignored if uuid is present
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if uuid is present
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created TetraGrid object
@@ -53,7 +56,8 @@ class TetraGrid(rug.UnstructuredGrid):
                          cell_shape = 'tetrahedral',
                          title = title,
                          originator = originator,
-                         extra_metadata = extra_metadata)
+                         extra_metadata = extra_metadata,
+                         load_inactive = load_inactive)
 
         if self.root is not None:
             assert grr.grid_flavour(self.root) == 'TetraGrid'

resqpy/unstructured/_unstructured_grid.py

@@ -35,7 +35,8 @@ class UnstructuredGrid(BaseResqpy):
                  cell_shape = 'polyhedral',
                  title = None,
                  originator = None,
-                 extra_metadata = {}):
+                 extra_metadata = {},
+                 load_inactive = True):
         """Create an Unstructured Grid object and optionally populate from xml tree.
 
         arguments:
@@ -55,6 +56,8 @@ class UnstructuredGrid(BaseResqpy):
               ignored if uuid is present
            extra_metadata (dict, optional): dictionary of extra metadata items to add to the grid;
               ignored if uuid is present
+           load_inactive (bool, default True): if True and uuid is provided, the inactive attribubte is
+              populated if a property of kind 'active' is found for the grid
 
         returns:
            a newly created Unstructured Grid object
@@ -103,6 +106,8 @@ class UnstructuredGrid(BaseResqpy):
             self.title = 'ROOT'
 
         if uuid is not None:
+            if load_inactive:
+                self.extract_inactive_mask()
             if geometry_required:
                 assert self.geometry_root is not None, 'unstructured grid geometry not present in xml'
             if cache_geometry and self.geometry_root is not None:
@@ -127,7 +132,6 @@ class UnstructuredGrid(BaseResqpy):
             assert self.node_count > 3
             self.face_count = rqet.find_tag_int(self.geometry_root, 'FaceCount')
             assert self.face_count > 3
-        self.extract_inactive_mask()
         # note: geometry arrays not loaded until demanded; see cache_all_geometry_arrays()
 
     def set_cell_count(self, n: int):