resqpy 4.18.11__py3-none-any.whl → 5.0.0__py3-none-any.whl

resqpy/__init__.py

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

resqpy/grid/__init__.py

@@ -1,14 +1,13 @@
 """The Grid Module."""
 
 __all__ = [
-    'Grid', 'RegularGrid', 'extract_grid_parent', 'establish_zone_property_kind', 'find_cell_for_x_sect_xz',
-    'grid_flavour', 'is_regular_grid', 'any_grid'
+    'Grid', 'RegularGrid', 'extract_grid_parent', 'find_cell_for_x_sect_xz', 'grid_flavour', 'is_regular_grid',
+    'any_grid'
 ]
 
 from ._grid import Grid
 from ._regular_grid import RegularGrid
 from ._grid_types import grid_flavour, is_regular_grid, any_grid
-from ._moved_functions import establish_zone_property_kind
 from ._extract_functions import extract_grid_parent, extent_kji_from_root
 from ._points_functions import find_cell_for_x_sect_xz
 

resqpy/grid/_grid.py

@@ -680,13 +680,7 @@ class Grid(BaseResqpy):
         return _create_grid_xml(self, ijk, ext_uuid, add_as_part, add_relationships, write_active, write_geometry,
                                 use_lattice, use_parametric_lines)
 
-    def x_section_points(self, axis, ref_slice0 = 0, plus_face = False, masked = False):
-        """Deprecated: please use `unsplit_x_section_points` instead."""
-        warnings.warn('Deprecated: please use `unsplit_x_section_points` instead.', DeprecationWarning)
-
-        return unsplit_x_section_points(self, axis, ref_slice0 = ref_slice0, plus_face = plus_face, masked = masked)
-
-    # The implementations of the below functions have been moved to separate modules.
+    # the implementations of the functions below have been moved to separate modules
 
     def cell_geometry_is_defined(self, cell_kji0 = None, cell_geometry_is_defined_root = None, cache_array = True):
         """Returns True if the geometry of the specified cell is defined.

resqpy/grid_surface/_find_faces.py

@@ -558,6 +558,8 @@ def find_faces_to_represent_surface_regular_dense_optimised(grid,
         to a grid connection set; use the non-dense version of the function for a reduced memory footprint;
         this function is DEPRECATED pending proving of newer find_faces_to_represent_surface_regular_optimised()
     """
+    warnings.warn('DEPRECATED: grid_surface.find_faces_to_represent_surface_regular_dense_optimised() function; ' +
+                  'use find_faces_to_represent_surface_regular_optimised() instead')
 
     assert isinstance(grid, grr.RegularGrid)
     assert grid.is_aligned
@@ -1363,6 +1365,7 @@ def bisector_from_faces(  # type: ignore
           assigned to either the True or False part
         - this function is DEPRECATED, pending proving of newer indices based approach
     """
+    warnings.warn('DEPRECATED: grid_surface.bisector_from_faces() function; use bisector_from_face_indices() instead')
     assert len(grid_extent_kji) == 3
 
     # find the surface boundary (includes a buffer slice where surface does not reach edge of grid)

resqpy/lines/_polyline.py

@@ -25,25 +25,22 @@ class Polyline(rql_c._BasePolyline):
 
     resqml_type = 'PolylineRepresentation'
 
-    def __init__(
-            self,
-            parent_model,
-            uuid = None,
-            set_bool = None,  #: DEPRECATED
-            set_coord = None,
-            set_crs = None,
-            is_closed = None,
-            title = None,
-            rep_int_root = None,
-            originator = None,
-            extra_metadata = None):
+    def __init__(self,
+                 parent_model,
+                 uuid = None,
+                 set_coord = None,
+                 set_crs = None,
+                 is_closed = None,
+                 title = None,
+                 rep_int_root = None,
+                 originator = None,
+                 extra_metadata = None):
         """Initialises a new polyline object.
 
         arguments:
             parent_model (model.Model object): the model which the new PolylineRepresentation belongs to
             uuid (uuid.UUID, optional): the uuid of an existing RESQML PolylineRepresentation from which
                 to initialise the resqpy Polyline
-            set_bool (boolean, optional): DEPRECATED: synonym for is_closed argument
             set_coord (numpy float array, optional): an ordered set of xyz values used to define a new polyline;
                 last dimension of array must have extent 3; ignored if uuid is not None
             set_crs (uuid.UUID, optional): the uuid of a crs to be used when initialising from coordinates;
@@ -65,10 +62,6 @@ class Polyline(rql_c._BasePolyline):
         """
 
         self.model = parent_model
-        if set_bool is not None:
-            warnings.warn('DEPRECATED: use is_closed argument instead of set_bool, in Polyline initialisation')
-            if is_closed is None:
-                is_closed = set_bool
         self.isclosed = is_closed
         self.nodepatch = None
         self.crs_uuid = set_crs
@@ -466,22 +459,20 @@ class Polyline(rql_c._BasePolyline):
         if cache and self.centre is not None:
             return self.centre
         assert mode in ['weighted', 'sampled']
-        if mode == 'sampled':  # this mode is deprecated as it simply approximates the weighted mode
-            sample_points = self.equidistant_points(n, in_xy = in_xy)
-            centre = np.mean(sample_points, axis = 0)
-        else:  # 'weighted'
-            sum = np.zeros(3)
-            seg_count = len(self.coordinates) - 1
-            if self.isclosed:
-                seg_count += 1
-            d = 2 if in_xy else 3
-            p1 = np.zeros(3)
-            p2 = np.zeros(3)
-            for seg_index in range(seg_count):
-                successor = (seg_index + 1) % len(self.coordinates)
-                p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
-                sum += (p1 + p2) * vu.naive_length(p2 - p1)
-            centre = sum / (2.0 * self.full_length(in_xy = in_xy))
+        if mode != 'weighted':  # ignore any other mode, ie. sampled
+            warnings.warn('DEPRECATED: weighted mode is only mode now supported for Polyline.balanced_centre()')
+        sum = np.zeros(3)
+        seg_count = len(self.coordinates) - 1
+        if self.isclosed:
+            seg_count += 1
+        d = 2 if in_xy else 3
+        p1 = np.zeros(3)
+        p2 = np.zeros(3)
+        for seg_index in range(seg_count):
+            successor = (seg_index + 1) % len(self.coordinates)
+            p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
+            sum += (p1 + p2) * vu.naive_length(p2 - p1)
+        centre = sum / (2.0 * self.full_length(in_xy = in_xy))
         if cache:
             self.centre = centre
         return centre

resqpy/model/_model.py

@@ -1340,7 +1340,8 @@ class Model():
            an hdf5 file name is cached once determined for a given ext uuid; to clear the cache,
            call the h5_clear_filename_cache() method
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_file_name(); use string instead')
         return m_h._h5_file_name(self, uuid = uuid, override = override, file_must_exist = file_must_exist)
 
     def h5_access(self, uuid = None, mode = 'r', override = 'default', file_path = None):
@@ -1366,7 +1367,8 @@ class Model():
            an exception will be raised if the hdf5 file cannot be opened; note that sometimes another
            piece of code accessing the file might cause a 'resource unavailable' exception
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_access(); use string instead')
         return m_h._h5_access(self, uuid = uuid, mode = mode, override = override, file_path = file_path)
 
     def h5_release(self):

resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -213,7 +213,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         surface = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         flange_bool = surface.set_from_point_set(pset,
                                                  convexity_parameter = 2.0,
-                                                 reorient = True,
+                                                 reorient = reorient,
                                                  extend_with_flange = extend_fault_representation,
                                                  flange_inner_ring = flange_inner_ring,
                                                  saucer_parameter = saucer_parameter,

resqpy/olio/triangulation.py

@@ -25,7 +25,7 @@ import resqpy.olio.vector_utilities as vec
 
 def _dt_scipy(points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Calculates the Delaunay triangulation for an array of points and the convex hull indices.
-    
+
     arguments:
         points (np.ndarray): coordinates of the points to triangulate; array has shape
             (npoints, ndim)
@@ -871,6 +871,7 @@ def surrounding_xy_ring(p,
        numpy float array of shape (N, 3) being xyz points in surrounding ring(s); z is set constant to
        mean value of z in p (optionally adjussted based on saucer_angle);
        N is count if inner_ring is False, 3 * count if True
+       radius used for ring of additional points
     """
 
     def make_ring(count, centre, radius, saucer_angle):
@@ -898,8 +899,8 @@ def surrounding_xy_ring(p,
         inner_radius = p_radius * 1.1
         assert radius > inner_radius
         in_ring = make_ring(2 * count, centre, inner_radius, saucer_angle)
-        return np.concatenate((in_ring, ring), axis = 0)
-    return ring
+        return np.concatenate((in_ring, ring), axis = 0), radius
+    return ring, radius
 
 
 def edges(t):

resqpy/olio/volume.py

@@ -77,26 +77,6 @@ def tetra_cell_volume(cp, centre = None, off_hand = False):
     return v / 6.0
 
 
-def tetra_volumes_slow(cp, centres = None, off_hand = False):
-    """Returns volume array for all hexahedral cells assuming bilinear faces, using loop over cells."""
-
-    # NB: deprecated, superceded by much faster function below
-    # todo: handle NaNs
-    # Pagoda style corner point data
-    assert cp.ndim == 7
-
-    flat = cp.reshape(-1, 2, 2, 2, 3)
-    cells = flat.shape[0]
-    if centres is None:
-        centres = np.mean(flat, axis = (1, 2, 3))
-    else:
-        centres = centres.reshape((-1, 3))
-    volumes = np.zeros(cells)
-    for cell in range(cells):
-        volumes[cell] = tetra_cell_volume(flat[cell], centre = centres[cell], off_hand = off_hand)
-    return volumes.reshape(cp.shape[0:3])
-
-
 def tetra_volumes(cp, centres = None, off_hand = False):
     """Returns volume array for all hexahedral cells assuming bilinear faces, using numpy operations.
 

resqpy/property/__init__.py

@@ -8,7 +8,8 @@ __all__ = [
     'reformat_column_edges_from_resqml_format', 'same_property_kind', 'selective_version_of_collection',
     'supported_local_property_kind_list', 'supported_property_kind_list', 'supported_facet_type_list',
     'expected_facet_type_dict', 'create_transmisibility_multiplier_property_kind',
-    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part', 'make_aps_key'
+    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part', 'make_aps_key',
+    'establish_zone_property_kind'
 ]
 
 from .property_common import property_collection_for_keyword,  \
@@ -27,7 +28,7 @@ from .property_common import property_collection_for_keyword,  \
     guess_uom,  \
     property_parts,  \
     property_part
-from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind
+from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind, establish_zone_property_kind
 from .string_lookup import StringLookup
 from .property_collection import PropertyCollection
 from .attribute_property_set import AttributePropertySet, ApsProperty, make_aps_key

resqpy/rq_import/_grid_from_cp.py

@@ -511,8 +511,8 @@ class _GridFromCp:
                 assert len(where_defined) == 3 and len(where_defined[0]) > 0, 'no extant cell geometries'
                 sample_kji0 = (where_defined[0][0], where_defined[1][0], where_defined[2][0])
             sample_cp = self.__cp_array[sample_kji0]
-            self.__cell_ijk_lefthanded = (vec.clockwise(sample_cp[0, 0, 0], sample_cp[0, 1, 0], sample_cp[0, 0, 1]) >=
-                                          0.0)
+            self.__cell_ijk_lefthanded =  \
+                (vec.clockwise(sample_cp[0, 0, 0], sample_cp[0, 1, 0], sample_cp[0, 0, 1]) >= 0.0)
             if not self.grid.k_direction_is_down:
                 self.__cell_ijk_lefthanded = not self.__cell_ijk_lefthanded
             if self.__crs.is_right_handed_xyz():

resqpy/surface/_surface.py

@@ -8,6 +8,7 @@ import logging
 log = logging.getLogger(__name__)
 
 import numpy as np
+import math as maths
 
 import resqpy.crs as rqc
 import resqpy.lines as rql
@@ -47,7 +48,7 @@ class Surface(rqsb.BaseSurface):
                  originator = None,
                  extra_metadata = {}):
         """Create an empty Surface object (RESQML TriangulatedSetRepresentation).
-        
+
         Optionally populates from xml, point set or mesh.
 
         arguments:
@@ -619,23 +620,17 @@ class Surface(rqsb.BaseSurface):
            suitable for adding as a property for the surface, with indexable element 'faces';
            when flange extension occurs, the radius is the greater of the values determined from the radial factor
            and radial distance arguments;
-           the saucer_parameter is interpreted in one of two ways: (1) +ve fractoinal values between zero and one
-           are the fractional distance from the centre of the points to its rim at which to sample the surface for
-           extrapolation and thereby modify the recumbent z of flange points; 0 will usually give shallower and
-           smoother saucer; larger values (must be less than one) will lead to stronger and more erratic saucer
-           shape in flange; (2) other values between -90.0 and 90.0 are interpreted as an angle to apply out of
-           the plane of the original points, to give a simple (and less computationally demanding) saucer shape;
-           +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
-           the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
-           to the average plane of the original points
+           the saucer_parameter must be between -90.0 and 90.0, and is interpreted as an angle to apply out of
+           the plane of the original points, to give a simple saucer shape; +ve angles result in the shift being in 
+           the direction of the -ve z hemisphere; -ve angles result in the shift being in the +ve z hemisphere; in 
+           either case the direction of the shift is perpendicular to the average plane of the original points
         """
 
         simple_saucer_angle = None
-        if saucer_parameter is not None and (saucer_parameter > 1.0 or saucer_parameter < 0.0):
+        if saucer_parameter is not None:
             assert -90.0 < saucer_parameter < 90.0, f'simple saucer angle parameter must be less than 90 degrees; too big: {saucer_parameter}'
             simple_saucer_angle = saucer_parameter
             saucer_parameter = None
-        assert saucer_parameter is None or 0.0 <= saucer_parameter < 1.0
         crs = rqc.Crs(self.model, uuid = point_set.crs_uuid)
         p = point_set.full_array_ref()
         assert p.ndim >= 2
@@ -648,37 +643,28 @@ class Surface(rqsb.BaseSurface):
                 f'removing {len(p) - np.count_nonzero(row_mask)} NaN points from point set {point_set.title} prior to surface triangulation'
             )
             p = p[row_mask, :]
-        if crs.xy_units == crs.z_units or not reorient:
+        if crs.xy_units == crs.z_units:
             unit_adjusted_p = p
         else:
             unit_adjusted_p = p.copy()
             wam.convert_lengths(unit_adjusted_p[:, 2], crs.z_units, crs.xy_units)
-        if reorient:
-            p_xy, self.normal_vector, reorient_matrix = triangulate.reorient(unit_adjusted_p,
-                                                                             max_dip = reorient_max_dip)
-        else:
-            p_xy = unit_adjusted_p
+        # reorient the points to the fault normal vector
+        p_xy, self.normal_vector, reorient_matrix = triangulate.reorient(unit_adjusted_p, max_dip = reorient_max_dip)
         if extend_with_flange:
-            if not reorient:
-                assert saucer_parameter is None and simple_saucer_angle is None,  \
-                    'flange saucer mode only available with reorientation active'
-                log.warning('extending point set with flange without reorientation')
-            flange_points = triangulate.surrounding_xy_ring(p_xy,
-                                                            count = flange_point_count,
-                                                            radial_factor = flange_radial_factor,
-                                                            radial_distance = flange_radial_distance,
-                                                            inner_ring = flange_inner_ring,
-                                                            saucer_angle = simple_saucer_angle)
-            p_xy_e = np.concatenate((p_xy, flange_points), axis = 0)
+            flange_points, radius = triangulate.surrounding_xy_ring(p_xy,
+                                                                    count = flange_point_count,
+                                                                    radial_factor = flange_radial_factor,
+                                                                    radial_distance = flange_radial_distance,
+                                                                    inner_ring = flange_inner_ring,
+                                                                    saucer_angle = 0.0)
+            flange_points_reverse_oriented = vec.rotate_array(reorient_matrix.T, flange_points)
             if reorient:
-                # reorient back extenstion points into original p space
-                flange_points_reverse_oriented = vec.rotate_array(reorient_matrix.T, flange_points)
-                p_e = np.concatenate((unit_adjusted_p, flange_points_reverse_oriented), axis = 0)
+                p_xy_e = np.concatenate((p_xy, flange_points), axis = 0)
             else:
-                p_e = p_xy_e
+                p_xy_e = np.concatenate((unit_adjusted_p, flange_points_reverse_oriented), axis = 0)
+
         else:
-            p_xy_e = p_xy
-            p_e = unit_adjusted_p
+            p_xy_e = unit_adjusted_p
             flange_array = None
         log.debug('number of points going into dt: ' + str(len(p_xy_e)))
         success = False
@@ -693,19 +679,209 @@ class Surface(rqsb.BaseSurface):
             t = triangulate.dt(p_xy_e[:, :2], container_size_factor = convexity_parameter * 1.1)
         log.debug('number of triangles: ' + str(len(t)))
         if make_clockwise:
-            triangulate.make_all_clockwise_xy(t, p_e)  # modifies t in situ
+            triangulate.make_all_clockwise_xy(t, p_xy_e)  # modifies t in situ
         if extend_with_flange:
             flange_array = np.zeros(len(t), dtype = bool)
             flange_array[:] = np.where(np.any(t >= len(p), axis = 1), True, False)
-            if saucer_parameter is not None:
-                _adjust_flange_z(self.model, self.crs_uuid, p_xy_e, len(p), t, flange_array, saucer_parameter)
-                p_e = vec.rotate_array(reorient_matrix.T, p_xy_e)
-        if crs.xy_units != crs.z_units and reorient:
-            wam.convert_lengths(p_e[:, 2], crs.xy_units, crs.z_units)
+            if simple_saucer_angle is not None:
+                assert abs(simple_saucer_angle) < 90.0
+                z_shift = radius * maths.tan(vec.radians_from_degrees(simple_saucer_angle))
+                flange_points[:, 2] -= z_shift
+                flange_points_reverse_oriented = vec.rotate_array(reorient_matrix.T, flange_points)
+            if crs.xy_units != crs.z_units:
+                wam.convert_lengths(flange_points_reverse_oriented[:, 2], crs.xy_units, crs.z_units)
+            p_e = np.concatenate((p, flange_points_reverse_oriented))
+        else:
+            p_e = p
         self.crs_uuid = point_set.crs_uuid
         self.set_from_triangles_and_points(t, p_e)
         return flange_array
 
+    def extend_surface_with_flange(self,
+                                   convexity_parameter = 5.0,
+                                   reorient = False,
+                                   reorient_max_dip = None,
+                                   flange_point_count = 11,
+                                   flange_radial_factor = 10.0,
+                                   flange_radial_distance = None,
+                                   flange_inner_ring = False,
+                                   saucer_parameter = None,
+                                   make_clockwise = False,
+                                   retriangulate = False):
+        """Returns a new Surface object where the original surface has been extended with a flange with a Delaunay triangulation of points in a PointSet object.
+
+        arguments:
+            convexity_parameter (float, default 5.0): controls how likely the resulting triangulation is to be
+                convex; reduce to 1.0 to allow slightly more concavities; increase to 100.0 or more for very little
+                chance of even a slight concavity
+            reorient (bool, default False): if True, a copy of the points is made and reoriented to minimise the
+                z range (ie. z axis is approximate normal to plane of points), to enhace the triangulation
+            reorient_max_dip (float, optional): if present, the reorientation of perspective off vertical is
+                limited to this angle in degrees
+            flange_point_count (int, default 11): the number of points to generate in the flange ring; ignored if
+                retriangulate is False
+            flange_radial_factor (float, default 10.0): distance of flange points from centre of points, as a
+                factor of the maximum radial distance of the points themselves; ignored if extend_with_flange is False
+            flange_radial_distance (float, optional): if present, the minimum absolute distance of flange points from
+                centre of points; units are those of the crs
+            flange_inner_ring (bool, default False): if True, an inner ring of points, with double flange point counr,
+                is created at a radius just outside that of the furthest flung original point; this improves
+                triangulation of the extended point set when the original has a non-convex hull. Ignored if retriangulate
+                is False
+            saucer_parameter (float, optional): if present, and extend_with_flange is True, then a parameter
+                controlling the shift of flange points in a perpendicular direction away from the fault plane;
+                see notes for how this parameter is interpreted
+            make_clockwise (bool, default False): if True, the returned triangles will all be clockwise when
+                viewed in the direction -ve to +ve z axis; if reorient is also True, the clockwise aspect is
+                enforced in the reoriented space
+            retriangulate (bool, default False): if True, the surface will be generated with a retriangulation of
+                the existing points. If False, the surface will be generated by adding flange points and triangles directly
+                from the original surface edges, and will no retriangulate the input surface. If False the surface must not
+                contain tears
+
+        returns:
+            a new surface, and a boolean array of length N, where N is the number of triangles on the surface. This boolean
+            array is False on original triangle points, and True for extended flange triangles
+
+        notes:
+            a boolean array is created for the surface, with a value per triangle, set to False (zero) for non-flange
+            triangles and True (one) for flange triangles; this array is suitable for adding as a property for the
+            surface, with indexable element 'faces';
+            when flange extension occurs, the radius is the greater of the values determined from the radial factor
+            and radial distance arguments;
+            the saucer_parameter is interpreted in one of two ways: (1) +ve fractoinal values between zero and one
+            are the fractional distance from the centre of the points to its rim at which to sample the surface for
+            extrapolation and thereby modify the recumbent z of flange points; 0 will usually give shallower and
+            smoother saucer; larger values (must be less than one) will lead to stronger and more erratic saucer
+            shape in flange; (2) other values between -90.0 and 90.0 are interpreted as an angle to apply out of
+            the plane of the original points, to give a simple (and less computationally demanding) saucer shape;
+            +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
+            the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
+            to the average plane of the original points
+        """
+        prev_t, prev_p = self.triangles_and_points()
+        point_set = rqs.PointSet(self.model, crs_uuid = self.crs_uuid, title = self.title, points_array = prev_p)
+        if retriangulate:
+            out_surf = Surface(self.model, crs_uuid = self.crs_uuid, title = self.title)
+            return out_surf, out_surf.set_from_point_set(point_set, convexity_parameter, reorient, reorient_max_dip,
+                                                         True, flange_point_count, flange_radial_factor,
+                                                         flange_radial_distance, flange_inner_ring, saucer_parameter,
+                                                         make_clockwise)
+        else:
+            simple_saucer_angle = None
+            if saucer_parameter is not None and (saucer_parameter > 1.0 or saucer_parameter < 0.0):
+                assert -90.0 < saucer_parameter < 90.0, f'simple saucer angle parameter must be less than 90 degrees; too big: {saucer_parameter}'
+                simple_saucer_angle = saucer_parameter
+                saucer_parameter = None
+            assert saucer_parameter is None or 0.0 <= saucer_parameter < 1.0
+            crs = rqc.Crs(self.model, uuid = point_set.crs_uuid)
+            assert prev_p.ndim >= 2
+            assert prev_p.shape[-1] == 3
+            p = prev_p.reshape((-1, 3))
+            if crs.xy_units == crs.z_units or not reorient:
+                unit_adjusted_p = p
+            else:
+                unit_adjusted_p = p.copy()
+                wam.convert_lengths(unit_adjusted_p[:, 2], crs.z_units, crs.xy_units)
+            if reorient:
+                p_xy, normal, reorient_matrix = triangulate.reorient(unit_adjusted_p, max_dip = reorient_max_dip)
+            else:
+                p_xy = unit_adjusted_p
+                normal = self.normal()
+                reorient_matrix = None
+
+            centre_point = np.nanmean(p_xy.reshape((-1, 3)), axis = 0)  # work out the radius for the flange points
+            p_radius_v = np.nanmax(np.abs(p.reshape((-1, 3)) - np.expand_dims(centre_point, axis = 0)), axis = 0)[:2]
+            p_radius = maths.sqrt(np.sum(p_radius_v * p_radius_v))
+            radius = p_radius * flange_radial_factor
+            if flange_radial_distance is not None and flange_radial_distance > radius:
+                radius = flange_radial_distance
+
+            de, dc = self.distinct_edges_and_counts()  # find the distinct edges and counts
+            unique_edge = de[dc == 1]  # find hull edges (edges on only a single triangle)
+            hull_points = p_xy[unique_edge]  # find points defining the hull edges
+            hull_centres = np.mean(hull_points, axis = 1)  # find the centre of each edge
+
+            flange_points = np.empty(
+                shape = (hull_centres.shape), dtype = float
+            )  # loop over all the hull centres, generating a flange point and finding the azimuth from the centre to the hull centre point
+            az = np.empty(shape = len(hull_centres), dtype = float)
+            for i, c in enumerate(hull_centres):
+                v = [centre_point[0] - c[0], centre_point[1] - c[1], centre_point[2] - c[2]]
+                uv = -vec.unit_vector(v)
+                az[i] = vec.azimuth(uv)
+                flange_point = centre_point + radius * uv
+                if simple_saucer_angle is not None:
+                    z_shift = radius * maths.tan(vec.radians_from_degrees(simple_saucer_angle))
+                    if reorient:
+                        flange_point[2] -= z_shift
+                    else:
+                        flange_point -= (-vec.unit_vector(normal) * z_shift)
+                flange_points[i] = flange_point
+
+            sort_az_ind = np.argsort(np.array(az))  # sort by azimuth, to run through the hull points
+            new_points = np.empty(shape = (len(flange_points), 3), dtype = float)
+            new_triangles = np.empty(shape = (len(flange_points) * 2, 3), dtype = int)
+            point_offset = len(p_xy)  # the indices of the new triangles will begin after this
+            for i, ind in enumerate(sort_az_ind):  # loop over each point in azimuth order
+                new_points[i] = flange_points[ind]
+                this_hull_edge = unique_edge[ind]
+
+                def az_for_point(c):
+                    v = [centre_point[0] - c[0], centre_point[1] - c[1], centre_point[2] - c[2]]
+                    uv = -vec.unit_vector(v)
+                    return vec.azimuth(uv)
+
+                this_edge_az_sort = np.array(
+                    [az_for_point(p_xy[this_hull_edge[0]]),
+                     az_for_point(p_xy[this_hull_edge[1]])])
+                if np.min(this_edge_az_sort) < az[ind] < np.max(this_edge_az_sort):
+                    first, second = np.argsort(this_edge_az_sort)
+                else:
+                    second, first = np.argsort(this_edge_az_sort)
+                if i != len(sort_az_ind) - 1:
+                    new_triangles[2 * i] = np.array(
+                        [this_hull_edge[first], this_hull_edge[second],
+                         i + point_offset])  # add a triangle between the two hull points and the flange point
+                    new_triangles[(2 * i) + 1] = np.array(
+                        [this_hull_edge[second], i + point_offset,
+                         i + point_offset + 1])  # for all but the last point, hookup triangle to the next flange point
+                else:
+                    new_triangles[2 * i] = np.array(
+                        [this_hull_edge[first], this_hull_edge[second],
+                         i + point_offset])  # add a triangle between the two hull points and the first flange point
+                    new_triangles[(2 * i) + 1] = np.array(
+                        [this_hull_edge[second], point_offset,
+                         i + point_offset])  # add in the final triangle between the first and last flange points
+
+            all_points = np.concatenate((p_xy, new_points))  # concatenate triangle and points arrays
+            all_triangles = np.concatenate((prev_t, new_triangles))
+
+            flange_array = np.zeros(shape = all_triangles.shape[0], dtype = bool)
+            flange_array[
+                len(prev_t):] = True  # make a flange bool array, where all new triangles are flange and therefore True
+
+            assert len(all_points) == (
+                point_offset + len(flange_points)), "New point count should be old point count + flange point count"
+            assert len(all_triangles) == (
+                len(prev_t) +
+                2 * len(flange_points)), "New triangle count should be old triangle count + 2 x #flange points"
+
+            if saucer_parameter is not None:
+                _adjust_flange_z(self.model, crs.uuid, all_points, len(all_points), all_triangles, flange_array,
+                                 saucer_parameter)  # adjust the flange points if in saucer mode
+            if reorient:
+                all_points = vec.rotate_array(reorient_matrix.T, all_points)
+            if crs.xy_units != crs.z_units and reorient:
+                wam.convert_lengths(all_points[:, 2], crs.xy_units, crs.z_units)
+
+            if make_clockwise:
+                triangulate.make_all_clockwise_xy(all_triangles, all_points)  # modifies t in situ
+
+            out_surf = Surface(self.model, crs_uuid = self.crs_uuid, title = self.title)
+            out_surf.set_from_triangles_and_points(all_triangles, all_points)  # create the new surface
+            return out_surf, flange_array
+
     def make_all_clockwise_xy(self, reorient = False):
         """Reorders cached triangles data such that all triangles are clockwise when viewed from -ve z axis.
 
@@ -845,7 +1021,7 @@ class Surface(rqsb.BaseSurface):
 
     def set_to_multi_cell_faces_from_corner_points(self, cp, quad_triangles = True):
         """Populates this (empty) surface to represent faces of a set of cells.
-        
+
         From corner points of shape (N, 2, 2, 2, 3).
         """
         assert cp.size % 24 == 0
@@ -881,7 +1057,7 @@ class Surface(rqsb.BaseSurface):
 
     def set_to_horizontal_plane(self, depth, box_xyz, border = 0.0, quad_triangles = False):
         """Populate this (empty) surface with a patch of two triangles.
-        
+
         Triangles define a flat, horizontal plane at a given depth.
 
         arguments:
@@ -985,7 +1161,7 @@ class Surface(rqsb.BaseSurface):
 
     def vertical_rescale_points(self, ref_depth = None, scaling_factor = 1.0):
         """Modify the z values of points by rescaling.
-        
+
         Stretches the distance from reference depth by scaling factor.
         """
         if scaling_factor == 1.0:
@@ -1170,11 +1346,11 @@ class Surface(rqsb.BaseSurface):
         return resampled
 
     def resample_surface_unique_edges(self):
-        """Returns a new surface, with the same model, title and crs as the original surface, but with additional refined points along original surface tears and edges. 
-        
+        """Returns a new surface, with the same model, title and crs as the original surface, but with additional refined points along original surface tears and edges.
+
         Each edge forming a tear or outer edge in the surface will have 3 additional points added, with 2 additional points on each edge of the original triangle. The output surface is re-triangulated using these new points (tears will be filled)
 
-        returns: 
+        returns:
             resqpy.surface.Surface object with extra_metadata ('unique edges resampled from surface': uuid), where uuid is for the original surface uuid
         """
         _, op = self.triangles_and_points()

resqpy/time_series/_any_time_series.py

@@ -34,14 +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 is not None:
-                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):