resqpy 4.14.3__tar.gz → 4.15.0__tar.gz

{resqpy-4.14.3 → resqpy-4.15.0}/PKG-INFO

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

{resqpy-4.14.3 → resqpy-4.15.0}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "resqpy"
-version = "4.14.3" # Set at build time
+version = "4.15.0" # Set at build time
 description = "Python API for working with RESQML models"
 authors = ["BP"]
 license = "MIT"

{resqpy-4.14.3 → resqpy-4.15.0}/resqpy/__init__.py

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

{resqpy-4.14.3 → resqpy-4.15.0}/resqpy/property/__init__.py

@@ -1,8 +1,8 @@
 """Collections of properties for grids, wellbore frames, grid connection sets etc."""
 
 __all__ = [
-    'PropertyCollection', 'Property', 'WellLog', 'WellIntervalProperty', 'WellIntervalPropertyCollection',
-    'WellLogCollection', 'StringLookup', 'PropertyKind', 'GridPropertyCollection',
+    'PropertyCollection', 'Property', 'AttributePropertySet', 'ApsProperty', 'WellLog', 'WellIntervalProperty',
+    'WellIntervalPropertyCollection', 'WellLogCollection', 'StringLookup', 'PropertyKind', 'GridPropertyCollection',
     'property_over_time_series_from_collection', 'property_collection_for_keyword', 'infer_property_kind',
     'write_hdf5_and_create_xml_for_active_property', 'reformat_column_edges_to_resqml_format',
     'reformat_column_edges_from_resqml_format', 'same_property_kind', 'selective_version_of_collection',
@@ -30,6 +30,7 @@ from .property_common import property_collection_for_keyword,  \
 from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind
 from .string_lookup import StringLookup
 from .property_collection import PropertyCollection
+from .attribute_property_set import AttributePropertySet, ApsProperty
 from .grid_property_collection import GridPropertyCollection
 from ._property import Property
 from .well_interval_property import WellIntervalProperty

resqpy-4.15.0/resqpy/property/attribute_property_set.py

@@ -0,0 +1,264 @@
+"""Class handling set of RESQML properties using attribute syntax for properties and their metadata."""
+
+# Nexus is a registered trademark of the Halliburton Company
+
+import logging
+
+log = logging.getLogger(__name__)
+
+import numpy as np
+import numpy.ma as ma
+
+import resqpy.property as rqp
+
+
+class ApsProperty:
+    """Class holding a single property with attribute style read access to metadata items."""
+
+    # note: this class could be private to the AttributePropertySet class
+
+    def __init__(self, aps, part):
+        """Initialise a single property from a property set with attribute style read access to metadata items."""
+        self.aps = aps
+        self._part = part
+        self.key = aps._key(part)
+
+    # NB. the following are read-only attributes
+
+    @property
+    def part(self):
+        """The part (string) identifier for this property."""
+        return self._part
+
+    @part.setter
+    def part(self, value):
+        self._part = value
+
+    @property
+    def node(self):
+        """The xml root node for this property."""
+        return self.aps.node_for_part(self.part)
+
+    @property
+    def uuid(self):
+        """The uuid for this property."""
+        return self.aps.uuid_for_part(self.part)
+
+    @property
+    def array_ref(self):
+        """The cached numpy array of values for this property."""
+        return self.aps.cached_part_array_ref(self.part)
+
+    @property
+    def values(self):
+        """A copy of the numpy array of values for this property."""
+        return self.array_ref.copy()
+
+    @property
+    def property_kind(self):
+        """The property kind of this property."""
+        return self.aps.property_kind_for_part(self.part)
+
+    @property
+    def facet_type(self):
+        """The facet type for this property (may be None)."""
+        return self.aps.facet_type_for_part(self.part)
+
+    @property
+    def facet(self):
+        """The facet value for this property (may be None)."""
+        return self.aps.facet_for_part(self.part)
+
+    @property
+    def indexable(self):
+        """The indexable element for this property (synonymous with indexable_element)."""
+        return self.aps.indexable_for_part(self.part)
+
+    @property
+    def indexable_element(self):
+        """The indexable element for this property (synonymous with indexable)."""
+        return self.indexable
+
+    @property
+    def is_continuous(self):
+        """Boolean indicating whether this property is continuous."""
+        return self.aps.continuous_for_part(self.part)
+
+    @property
+    def is_categorical(self):
+        """Boolean indicating whether this property is categorical."""
+        return self.aps.part_is_categorical(self.part)
+
+    @property
+    def is_discrete(self):
+        """Boolean indicating whether this property is discrete (False for categorical properties)."""
+        return not (self.is_continuous or self.is_categorical)
+
+    @property
+    def is_points(self):
+        """Boolean indicating whether this is a points property."""
+        return self.aps.points_for_part(self.part)
+
+    @property
+    def count(self):
+        """The count (number of sub-elements per element, usually 1) for this property."""
+        return self.aps.count_for_part(self.part)
+
+    @property
+    def uom(self):
+        """The unit of measure for this property (will be None for discrete or categorical properties)."""
+        return self.aps.uom_for_part(self.part)
+
+    @property
+    def null_value(self):
+        """The null value for this property (will be None for continuous properties, for which NaN is always the null value)."""
+        return self.aps.null_value_for_part(self.part)
+
+    @property
+    def realization(self):
+        """The realisation number for this property (may be None)."""
+        return self.aps.realization_for_part(self.part)
+
+    @property
+    def time_index(self):
+        """The time index for this property (may be None)."""
+        return self.aps.time_index_for_part(self.part)
+
+    @property
+    def title(self):
+        """The citation title for this property (synonymous with citation_title)."""
+        return self.aps.citation_title_for_part(self.part)
+
+    @property
+    def citation_title(self):
+        """The citation title for this property (synonymous with title)."""
+        return self.title
+
+    @property
+    def min_value(self):
+        """The minimum value for this property, as stored in xml metadata."""
+        return self.aps.minimum_value_for_part(self.part)
+
+    @property
+    def max_value(self):
+        """The maximum value for this property, as stored in xml metadata."""
+        return self.aps.maximum_value_for_part(self.part)
+
+    @property
+    def constant_value(self):
+        """The constant value for this property, as stored in xml metadata (usually None)."""
+        return self.aps.constant_value_for_part(self.part)
+
+    @property
+    def extra(self):
+        """The extra metadata for this property (synonymous with extra_metadata)."""
+        return self.aps.extra_metadata_for_part(self.part)
+
+    @property
+    def extra_metadata(self):
+        """The extra metadata for this property (synonymous with extra)."""
+        return self.extra
+
+    @property
+    def support_uuid(self):
+        """The uuid of the supporting representation for this property."""
+        return self.aps.support_uuid_for_part(self.part)
+
+    @property
+    def string_lookup_uuid(self):
+        """The uuid of the string lookup table for a categorical property (otherwise None)."""
+        return self.aps.string_lookup_uuid_for_part(self.part)
+
+    @property
+    def time_series_uuid(self):
+        """The uuid of the time series for this property (may be None)."""
+        return self.aps.time_series_uuid_for_part(self.part)
+
+    @property
+    def local_property_kind_uuid(self):
+        """The uuid of the local property kind for this property (may be None)."""
+        return self.aps.local_property_kind_uuid(self.part)
+
+
+class AttributePropertySet(rqp.PropertyCollection):
+    """Class for set of RESQML properties for any supporting representation, using attribute syntax."""
+
+    def __init__(self, model = None, support = None, property_set_uuid = None, realization = None, key_mode = 'pk'):
+        """Initialise an empty property set, optionally populate properties from a supporting representation.
+
+        arguments:
+           model (Model, optional): required if property_set_uuid is not None
+           support (optional): a grid.Grid object, or a well.BlockedWell, or a well.WellboreFrame object which belongs to a
+              resqpy.Model which includes associated properties; if this argument is given, and property_set_root is None,
+              the properties in the support's parent model which are for this representation (ie. have this object as the
+              supporting representation) are added to this collection as part of the initialisation
+           property_set_uuid (optional): if present, the collection is populated with the properties defined in the xml tree
+              of the property set
+           realization (integer, optional): if present, the single realisation (within an ensemble) that this collection is for;
+              if None, then the collection is either covering a whole ensemble (individual properties can each be flagged with a
+              realisation number), or is for properties that do not have multiple realizations
+           key_mode (str, default 'pk'): either 'pk' (for property kind) or 'title', identifying the basis of property attribute keys
+
+        note:
+           at present, if the collection is being initialised from a property set, the support argument must also be specified;
+           also for now, if not initialising from a property set, all properties related to the support are included, whether
+           the relationship is supporting representation or some other relationship;
+
+        :meta common:
+        """
+
+        assert key_mode in ['pk', 'title']
+        assert property_set_uuid is None or model is not None
+        assert support is None or model is None or support.model is model
+        if property_set_uuid is None:
+            property_set_root = None
+        else:
+            property_set_root = model.root_for_uuid(property_set_uuid)
+
+        super().__init__(support = support, property_set_root = property_set_root, realization = realization)
+        self.key_mode = key_mode
+        self._make_attributes()
+
+    def keys(self):
+        """Iterator over property keys within the set."""
+        for p in self.parts():
+            yield self._key(p)
+
+    def properties(self):
+        """Iterator over ApsProperty members of the set."""
+        for k in self.keys():
+            yield getattr(self, k)
+
+    def items(self):
+        """Iterator over (key, ApsProperty) members of the set."""
+        for k in self.keys():
+            yield (k, getattr(self, k))
+
+    def _key(self, part):
+        """Returns the key (attribute name) for a given part."""
+        if self.key_mode == 'pk':
+            key = self.property_kind_for_part(part)
+            facet = self.facet_for_part(part)
+            if facet is not None:
+                key += f'_{facet}'
+        else:
+            key = self.citation_title_for_part(part)
+        key = key.replace(' ', '_')
+        ti = self.time_index_for_part(part)
+        if ti is not None:
+            key += f'_t{ti}'
+        r = self.realization_for_part(part)
+        if r is not None:
+            key += f'_r{r}'
+        return key
+
+    def _make_attributes(self):
+        """Setup individual properties with attribute style read access to metadata."""
+        for part in self.parts():
+            key = self._key(part)
+            aps_property = ApsProperty(self, part)
+            setattr(self, key, aps_property)
+
+    def __len__(self):
+        """Returns the number of properties in the set."""
+        return self.number_of_parts()

{resqpy-4.14.3 → resqpy-4.15.0}/resqpy/surface/_surface.py

@@ -272,48 +272,86 @@ class Surface(rqsb.BaseSurface):
 
         self.model = parent_model
 
-    def triangles_and_points(self):
-        """Returns arrays representing combination of all the patches in the surface.
+    def number_of_patches(self):
+        """Returns the number of patches present in the surface."""
+
+        self.extract_patches(self.root)
+        return len(self.patch_list)
+
+    def triangles_and_points(self, patch = None):
+        """Returns arrays representing one patch or a combination of all the patches in the surface.
+
+        arguments:
+           patch (int, optional): patch index; if None, combined arrays for all patches are returned
 
         returns:
            tuple (triangles, points):
               triangles (int array of shape[:, 3]): integer indices into points array,
-                  being the nodes of the corners of the triangles;
+                 being the nodes of the corners of the triangles;
               points (float array of shape[:, 3]): flat array of xyz points, indexed by triangles
 
         :meta common:
         """
 
-        if self.triangles is not None:
-            return (self.triangles, self.points)
         self.extract_patches(self.root)
-        points_offset = 0
-        for triangulated_patch in self.patch_list:
-            (t, p) = triangulated_patch.triangles_and_points()
-            if points_offset == 0:
-                self.triangles = t.copy()
-                self.points = p.copy()
-            else:
-                self.triangles = np.concatenate((self.triangles, t.copy() + points_offset))
-                self.points = np.concatenate((self.points, p.copy()))
-            points_offset += p.shape[0]
-        return (self.triangles, self.points)
+        if patch is None:
+            if self.triangles is None:
+                points_offset = 0
+                for triangulated_patch in self.patch_list:
+                    (t, p) = triangulated_patch.triangles_and_points()
+                    if points_offset == 0:
+                        self.triangles = t.copy()
+                        self.points = p.copy()
+                    else:
+                        self.triangles = np.concatenate((self.triangles, t.copy() + points_offset))
+                        self.points = np.concatenate((self.points, p.copy()))
+                    points_offset += p.shape[0]
+            return (self.triangles, self.points)
+        assert 0 <= patch < len(self.patch_list),  \
+            ValueError(f'patch index {patch} out of range for surface with {len(self.patch_list)} patches')
+        return self.patch_list[patch].triangles_and_points()
 
-    def triangle_count(self):
-        """Return the numner of triangles in this surface."""
+    def triangle_count(self, patch = None):
+        """Return the numner of triangles in this surface, or in one patch.
+
+        arguments:
+           patch (int, optional): patch index; if None, a combined triangle count for all patches is returned
+
+        returns:
+           int being the number of trianges in the patch (if specified) or in all the patches
+        """
 
         self.extract_patches(self.root)
-        if not self.patch_list:
-            return 0
-        return np.sum([tp.triangle_count for tp in self.patch_list])
+        if patch is None:
+            if not self.patch_list:
+                return 0
+            return np.sum([tp.triangle_count for tp in self.patch_list])
+        assert 0 <= patch < len(self.patch_list),  \
+            ValueError(f'patch index {patch} out of range for surface with {len(self.patch_list)} patches in triangle_count')
+        return self.patch_list[patch].triangle_count
+
+    def node_count(self, patch = None):
+        """Return the number of nodes (points) used in this surface, or in one patch.
+
+        arguments:
+           patch (int, optional): patch index; if None, a combined node count for all patches is returned
+
+        returns:
+           int being the number of nodes in the patch (if specified) or in all the patches
 
-    def node_count(self):
-        """Return the number of nodes (points) used in this surface."""
+        note:
+           a multi patch surface might have more than one node colocated; this method will treat such coincident nodes
+           as separate nodes
+        """
 
         self.extract_patches(self.root)
-        if not self.patch_list:
-            return 0
-        return np.sum([tp.node_count for tp in self.patch_list])
+        if patch is None:
+            if not self.patch_list:
+                return 0
+            return np.sum([tp.node_count for tp in self.patch_list])
+        assert 0 <= patch < len(self.patch_list),  \
+            ValueError(f'patch index {patch} out of range for surface with {len(self.patch_list)} patches in node_count')
+        return self.patch_list[patch].node_count
 
     def change_crs(self, required_crs):
         """Changes the crs of the surface, also sets a new uuid if crs changed.
@@ -381,7 +419,7 @@ class Surface(rqsb.BaseSurface):
         self.uuid = bu.new_uuid()
 
     def set_to_split_surface(self, large_surface, line, delta_xyz):
-        """Populate this (empty) surface with a version of a larger surface split by an xy line.
+        """Populate this (empty) surface with a version of a larger surface split by a straight xy line.
 
         arguments:
             large_surface (Surface): the larger surface, a copy of which is to be split
@@ -404,8 +442,8 @@ class Surface(rqsb.BaseSurface):
         tp[:, 1] = len(p) + 1
         tp[:, 2] = np.arange(len(p), dtype = int)
         cw = vec.clockwise_triangles(pp, tp)
-        pai = np.where(cw >= 0.0, True, False)  # bool mask over p
-        pbi = np.where(cw <= 0.0, True, False)  # bool mask over p
+        pai = (cw >= 0.0)  # bool mask over p
+        pbi = (cw <= 0.0)  # bool mask over p
         tap = pai[t]
         tbp = pbi[t]
         ta = np.any(tap, axis = 1)  # bool array over t
@@ -435,17 +473,24 @@ class Surface(rqsb.BaseSurface):
 
         self.set_from_triangles_and_points(t_combo, p_combo)
 
-    def distinct_edges(self):
-        """Returns a numpy int array of shape (N, 2) being the ordered node pairs of distinct edges of triangles."""
+    def distinct_edges(self, patch = None):
+        """Returns a numpy int array of shape (N, 2) being the ordered node pairs of distinct edges of triangles.
+
+        arguments:
+           patch (int, optional): patch index; if None, a combination of edges for all patches is returned
+        """
 
-        triangles, _ = self.triangles_and_points()
+        triangles, _ = self.triangles_and_points(patch = patch)
         assert triangles is not None
         unique_edges, _ = triangulate.edges(triangles)
         return unique_edges
 
-    def distinct_edges_and_counts(self):
+    def distinct_edges_and_counts(self, patch = None):
         """Returns unique edges as pairs of point indices, and a count of uses of each edge.
 
+        arguments:
+           patch (int, optional): patch index; if None, combined results for all patches are returned
+
         returns:
             numpy int array of shape (N, 2), numpy int array of shape (N,)
             where 2D array is list-like sorted points index pairs for unique edges
@@ -453,25 +498,26 @@ class Surface(rqsb.BaseSurface):
 
         notes:
             first entry in each pair is always the lower of the two point indices;
-            for well formed surfaces, the count should everywhere be zero or one;
+            for well formed surfaces, the count should everywhere be one or two;
             the function does not attempt to detect coincident points
         """
 
-        triangles, _ = self.triangles_and_points()
+        triangles, _ = self.triangles_and_points(patch = patch)
         assert triangles is not None
         return triangulate.edges(triangles)
 
-    def edge_lengths(self, required_uom = None):
+    def edge_lengths(self, required_uom = None, patch = None):
         """Returns float array of shape (N, 3) being triangle edge lengths.
 
         arguments:
             required_uom (str, optional): the required length uom for the resulting edge lengths; default is crs xy units
+            patch (int, optional): patch index; if None, edge lengths for all patches are returned
 
         returns:
             numpy float array of shape (N, 3) where N is the number of triangles
         """
 
-        t, p = self.triangles_and_points()
+        t, p = self.triangles_and_points(patch = patch)
         crs = rqc.Crs(self.model, uuid = self.crs_uuid)
         if required_uom is None:
             required_uom = crs.xy_units
@@ -495,6 +541,20 @@ class Surface(rqsb.BaseSurface):
         self.triangles = triangles.copy()
         self.points = points.copy()
 
+    def set_multi_patch_from_triangles_and_points(self, triangles_and_points_list):
+        """Populate this (empty) Surface object from a list of paits: array of triangle corner indices, array of points."""
+
+        self.patch_list = []
+        self.trianges = None
+        self.points = None
+        for patch, entry in enumerate(triangles_and_points_list):
+            assert len(entry) == 2, 'expecting pair of arrays (triangles, points) for each patch'
+            triangles, points = entry
+            tri_patch = rqstp.TriangulatedPatch(self.model, patch_index = patch, crs_uuid = self.crs_uuid)
+            tri_patch.set_from_triangles_and_points(triangles, points)
+            self.patch_list.append(tri_patch)
+        self.uuid = bu.new_uuid()
+
     def set_from_point_set(self,
                            point_set,
                            convexity_parameter = 5.0,
@@ -927,10 +987,10 @@ class Surface(rqsb.BaseSurface):
         for patch in self.patch_list:
             patch.vertical_rescale_points(ref_depth, scaling_factor)
 
-    def line_intersection(self, line_p, line_v, line_segment = False):
+    def line_intersection(self, line_p, line_v, line_segment = False, patch = None):
         """Returns x,y,z of an intersection point of straight line with the surface, or None if no intersection found."""
 
-        t, p = self.triangles_and_points()
+        t, p = self.triangles_and_points(patch = patch)
         tp = p[t]
         intersects = meet.line_triangles_intersects(line_p, line_v, tp, line_segment = line_segment)
         indices = meet.intersects_indices(intersects)
@@ -938,21 +998,22 @@ class Surface(rqsb.BaseSurface):
             return None
         return intersects[indices[0]]
 
-    def sample_z_at_xy_points(self, points, multiple_handling = 'any'):
+    def sample_z_at_xy_points(self, points, multiple_handling = 'any', patch = None):
         """Returns interpolated z values for an array of xy values.
 
         arguments:
             points (numpy float array of shape (..., 2 or 3)): xy points to sample surface at (z values ignored)
             multiple_handling (str, default 'any'): one of 'any', 'minimum', 'maximum', 'exception'
+            patch (int, optional): patch index; if None, results are for the full surface
 
         returns:
             numpy float array of shape points.shape[:-1] being z values interpolated from the surface z values
 
         notes:
             points must be in the same crs as the surface;
-            NaN will be set for any points that do not intersect with the surface in the xy projection;
-            multiple_handling argument controls behaviour when one sample point intersects surface more than
-            once: 'any' a random one of the intersection z values is returned; 'minimum' or 'maximum': the
+            NaN will be set for any points that do not intersect with the patch or surface in the xy projection;
+            multiple_handling argument controls behaviour when one sample point intersects more than once:
+            'any' a random one of the intersection z values is returned; 'minimum' or 'maximum': the
             numerical min or max of the z values is returned; 'exception': a ValueError is raised
         """
 
@@ -964,7 +1025,7 @@ class Surface(rqsb.BaseSurface):
         else:
             sample_xy = np.zeros((points.size // 2, 3), dtype = float)
             sample_xy[:, :2] = points.reshape((-1, 2))
-        t, p = self.triangles_and_points()
+        t, p = self.triangles_and_points(patch = patch)
         p_list = vec.points_in_triangles_njit(sample_xy, p[t], 1)
         vertical = np.array((0.0, 0.0, 1.0), dtype = float)
         z = np.full(sample_xy.shape[0], np.NaN, dtype = float)
@@ -983,17 +1044,18 @@ class Surface(rqsb.BaseSurface):
                 raise ValueError(f'multiple {self.title} surface intersections at xy: {sample_xy[p_index]}')
         return z.reshape(points.shape[:-1])
 
-    def normal_vectors(self, add_as_property: bool = False) -> np.ndarray:
-        """Returns the normal vectors for each triangle in the surface.
-        
+    def normal_vectors(self, add_as_property: bool = False, patch = None) -> np.ndarray:
+        """Returns the normal vectors for each triangle in the patch or surface.
+
         arguments:
-            add_as_property (bool): if True, face_surface_normal_vectors_array is added as a property to the model.
+            add_as_property (bool): if True, face_surface_normal_vectors_array is added as a property to the model
+            patch (int, optional): patch index; if None, normal vectors for triangles in all patches are returned
 
         returns:
-            normal_vectors_array (np.ndarray): the normal vectors corresponding to each triangle in the surface.
+            normal_vectors_array (np.ndarray): the normal vectors corresponding to each triangle in the surface
         """
         crs = rqc.Crs(self.model, uuid = self.crs_uuid)
-        triangles, points = self.triangles_and_points()
+        triangles, points = self.triangles_and_points(patch = patch)
         if crs.xy_units != crs.z_units:
             points = points.copy()
             wam.convert_lengths(points[:, 2], crs.z_units, crs.xy_units)
@@ -1053,13 +1115,13 @@ class Surface(rqsb.BaseSurface):
         return ep
 
     def resampled_surface(self, title = None):
-        """Creates a new triangulated set which is a resampled version of the current triangulated set. Each existing triangle in the tset is divided equally into 4 new triangles.
-           
+        """Creates a new surface which is a refined version of this surface; each triangle is divided equally into 4 new triangles.
+
         arguments:
-            title (str): a new title for the output triangulated set, if None the title will have the same title as the input triangulated set
-        
+            title (str): title for the output triangulated set, if None the title will be inherited from the input surface
+
         returns:
-            resqpy.surface.Surface object, with extra_metadata ('resampled from surface': <uuid>), where uuid is the origin surface uuid
+            resqpy.surface.Surface object, with extra_metadata ('resampled from surface': uuid), where uuid is for the original surface uuid
         """
         rt, rp = self.triangles_and_points()
         edge1 = np.mean(rp[rt[:]][:, ::2, :], axis = 1)

{resqpy-4.14.3 → resqpy-4.15.0}/resqpy/time_series/_any_time_series.py

@@ -34,8 +34,10 @@ 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:
+            if year_offset is not None:
                 assert self.timeframe == 'geologic'
+                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'

{resqpy-4.14.3 → resqpy-4.15.0}/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:
         """