resqpy 4.5.0__py3-none-any.whl → 4.6.3__py3-none-any.whl

resqpy/olio/write_hdf5.py

@@ -15,7 +15,7 @@ import numpy as np
 import resqpy.olio.uuid as bu
 
 resqml_path_head = '/RESQML/'  # note: latest fesapi code uses RESQML20
-write_bool_as_int8 = True  # Nexus read fails if bool used as hdf5 element dtype; also better for NullValue handling
+write_bool_as_uint8 = True  # Nexus read fails if bool used as hdf5 element dtype
 write_int_as_int32 = True  # only applies if registered dtype is None
 
 
@@ -37,7 +37,8 @@ class H5Register():
            group_tail (string): the remainder of the hdf5 internal path (following RESQML and
               uuid elements)
            a (numpy array): the dataset (array) to be registered for writing
-           dtype (type or string): the required type of the individual elements within the dataset
+           dtype (type or string): the required type of the individual elements within the dataset;
+              special value of 'pack' may be used to cause a bool array to be packed before writing
            hdf5_internal_path (string, optional): if present, a full hdf5 internal path to use
               instead of the default generated from the uuid
            copy (boolean, default False): if True, a copy of the array will be made at the time of
@@ -50,14 +51,21 @@ class H5Register():
         notes:
            several arrays might belong to the same object;
            if a dtype is given and necessitates a conversion of the array data, the behaviour will
-           be as if the copy argument is True regardless of its setting
+           be as if the copy argument is True regardless of its setting;
+           the use of 'pack' as dtype will result in hdf5 data that will not generally be readable
+           by non-resqpy applications; when reading packed data, the required shape must be specified;
+           packing only takes place over the last axis; do not use packing if the array needs to be
+           read or updated in slices, or read a single value at a time with index values
         """
 
-        #     print('registering dataset with uuid ' + str(object_uuid) + ' and group tail ' + group_tail)
+        # log.debug('registering dataset with uuid ' + str(object_uuid) + ' and group tail ' + group_tail)
         assert (len(group_tail) > 0)
         assert a is not None
         assert isinstance(a, np.ndarray)
-        if dtype is not None:
+        if str(dtype) == 'pack':
+            a = np.packbits(a, axis = -1)  # todo: check this returns uint8 array
+            dtype = 'uint8'
+        elif dtype is not None:
             a = a.astype(dtype, copy = copy)
         elif copy:
             a = a.copy()
@@ -66,7 +74,7 @@ class H5Register():
         if group_tail[-1] == '/':
             group_tail = group_tail[:-1]
         if (object_uuid, group_tail) in self.dataset_dict.keys():
-            pass  # todo: warn of re-registration?
+            log.warning(f'multiple hdf5 registrations for uuid: {object_uuid}; group: {group_tail}')
         self.dataset_dict[(object_uuid, group_tail)] = (a, dtype)
         if hdf5_internal_path:
             self.hdf5_path_dict[(object_uuid, group_tail)] = hdf5_internal_path
@@ -99,8 +107,8 @@ class H5Register():
                 dtype = a.dtype
                 if use_int32 and str(dtype) == 'int64':
                     dtype = 'int32'
-            if write_bool_as_int8 and str(dtype).lower().startswith('bool'):
-                dtype = 'int8'
+            if write_bool_as_uint8 and str(dtype).lower().startswith('bool'):
+                dtype = 'uint8'
             # log.debug('Writing hdf5 dataset ' + internal_path + ' of size ' + str(a.size) + ' type ' + str(dtype))
             fp.create_dataset(internal_path, data = a, dtype = dtype)
 

resqpy/olio/xml_et.py

@@ -301,7 +301,7 @@ def cut_extra_metadata(root):
     """Removes all the extra metadata children under root node."""
 
     for child in root:
-        if child.tag == 'ExtraMetadata':
+        if match(child.tag, 'ExtraMetadata'):
             root.remove(child)
 
 
@@ -413,7 +413,7 @@ def print_xml_tree(root,
                                     log_level = log_level,
                                     max_lines = max_lines,
                                     line_count = line_count)
-        if line_count > max_lines:
+        if max_lines and line_count > max_lines:
             break
     return line_count
 
@@ -730,7 +730,7 @@ def write_xml_node(xml_fp, root, level = 0, namespace_keys = []):
     else:
         line += '>'
         text = root.text
-        if (not text or text.isspace()) and tag == 'Title':
+        if (not text or text.isspace()) and tag.endswith('Title'):
             text = 'untitled'
         if text and not text.isspace():
             line += text.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')

resqpy/property/_collection_get_attributes.py

@@ -525,17 +525,15 @@ def _get_indexable_element(indexable_element, support_type):
     return indexable_element
 
 
-def _cached_part_array_ref_get_array(collection, part, dtype, model, cached_array_name):
+def _cached_part_array_ref_get_array(collection, part, dtype, model, cached_array_name, use_pack):
     const_value = collection.constant_value_for_part(part)
     if const_value is None:
-        _cached_part_array_ref_const_none(collection, part, dtype, model, cached_array_name)
+        _cached_part_array_ref_const_none(collection, part, dtype, model, cached_array_name, use_pack)
     else:
         _cached_part_array_ref_const_notnone(collection, part, const_value, cached_array_name)
-    if not hasattr(collection, cached_array_name):
-        return None
 
 
-def _cached_part_array_ref_const_none(collection, part, dtype, model, cached_array_name):
+def _cached_part_array_ref_const_none(collection, part, dtype, model, cached_array_name, use_pack):
     part_node = collection.node_for_part(part)
     if part_node is None:
         return None
@@ -544,6 +542,13 @@ def _cached_part_array_ref_const_none(collection, part, dtype, model, cached_arr
     else:
         first_values_node, tag, dtype = _cached_part_array_ref_get_node_values(part_node, dtype)
 
+    # the required shape is required if a bool array may need to be unpacked from bits
+    required_shape = None
+    str_dtype = str(dtype)
+    if use_pack and ('bool' in str_dtype or 'int8' in str_dtype):
+        required_shape = collection.supporting_shape(indexable_element = collection.indexable_for_part(part),
+                                                     direction = _part_direction(collection, part))
+
     h5_key_pair = model.h5_uuid_and_path_for_node(first_values_node, tag = tag)
     if h5_key_pair is None:
         return None
@@ -552,6 +557,7 @@ def _cached_part_array_ref_const_none(collection, part, dtype, model, cached_arr
                            cache_array = True,
                            object = collection,
                            array_attribute = cached_array_name,
+                           required_shape = required_shape,
                            dtype = dtype)
 
 

resqpy/property/_property.py

@@ -124,6 +124,7 @@ class Property(BaseResqpy):
                    find_local_property_kind = True,
                    expand_const_arrays = False,
                    dtype = None,
+                   use_pack = False,
                    extra_metadata = {}):
         """Populates a new Property from a numpy array and metadata; NB. Writes data to hdf5 and adds part to model.
 
@@ -168,6 +169,8 @@ class Property(BaseResqpy):
            expand_const_arrays (boolean, default False): if True, and a const_value is given, the array will be fully
               expanded and written to the hdf5 file; the xml will then not indicate that it is constant
            dtype (numpy dtype, optional): if present, the elemental data type to use when writing the array to hdf5
+           use_pack (bool, default False): if True, a bool array will be packed along its last axis; this
+              will generally result in hdf5 data that is not readable by non-resqpy applications
            extra_metadata (optional): if present, a dictionary of extra metadata to be added for the part
 
         returns:
@@ -213,7 +216,7 @@ class Property(BaseResqpy):
                             count = count,
                             points = points,
                             const_value = const_value)
-        prop.write_hdf5(expand_const_arrays = expand_const_arrays, dtype = dtype)
+        prop.write_hdf5(expand_const_arrays = expand_const_arrays, dtype = dtype, use_pack = use_pack)
         prop.create_xml(support_uuid = support_uuid,
                         time_series_uuid = time_series_uuid,
                         string_lookup_uuid = string_lookup_uuid,
@@ -223,7 +226,7 @@ class Property(BaseResqpy):
                         extra_metadata = extra_metadata)
         return prop
 
-    def array_ref(self, dtype = None, masked = False, exclude_null = False):
+    def array_ref(self, dtype = None, masked = False, exclude_null = False, use_pack = True):
         """Returns a (cached) numpy array containing the property values.
 
         arguments:
@@ -232,6 +235,8 @@ class Property(BaseResqpy):
               the inactive cell mask in the case of a Grid property
            exclude_null (boolean, default False): if True and masked is True, elements whose value is the null value
               (NaN for floats) will be masked out
+           use_pack (boolean, default True): if True, and the property is a boolean array, the hdf5 data will
+              be unpacked if its shape indicates that it has been packed into bits for storage
 
         returns:
            numpy array
@@ -242,7 +247,8 @@ class Property(BaseResqpy):
         return self.collection.cached_part_array_ref(self.part,
                                                      dtype = dtype,
                                                      masked = masked,
-                                                     exclude_null = exclude_null)
+                                                     exclude_null = exclude_null,
+                                                     use_pack = use_pack)
 
     def is_continuous(self):
         """Returns boolean indicating that the property contains continuous (ie. float) data.
@@ -383,7 +389,7 @@ class Property(BaseResqpy):
                                                           const_value = const_value,
                                                           points = points)
 
-    def write_hdf5(self, file_name = None, mode = 'a', expand_const_arrays = False, dtype = None):
+    def write_hdf5(self, file_name = None, mode = 'a', expand_const_arrays = False, dtype = None, use_pack = False):
         """Writes the array data to the hdf5 file; not usually called directly.
 
         arguments:
@@ -393,6 +399,8 @@ class Property(BaseResqpy):
            expand_const_arrays (bool, default False): if True and the array is a constant array then a fully populated
               array is generated and stored (otherwise the constant value is held in xml and no hdf5 data is needed)
            dtype (numpy dtype, optional): if present, the elemental data type to use when writing the array to hdf5
+           use_pack (bool, default False): if True, a bool array will be packed along its last axis; this
+              will generally result in hdf5 data that is not readable by non-resqpy applications
 
         notes:
            see the documentation for the convenience method from_array()
@@ -400,10 +408,13 @@ class Property(BaseResqpy):
         if not self.collection.imported_list:
             log.warning('no imported Property array to write to hdf5')
             return
+        if str(dtype) == 'pack':
+            use_pack = True
         self.collection.write_hdf5_for_imported_list(file_name = file_name,
                                                      mode = mode,
                                                      expand_const_arrays = expand_const_arrays,
-                                                     dtype = dtype)
+                                                     dtype = dtype,
+                                                     use_pack = use_pack)
 
     def create_xml(self,
                    ext_uuid = None,

resqpy/property/property_collection.py

@@ -58,7 +58,8 @@ class PropertyCollection():
         """
 
         assert property_set_root is None or support is not None, \
-            'support (grid, wellbore frame, blocked well, mesh, or grid connection set) must be specified when populating property collection from property set'
+            'support (grid, wellbore frame, blocked well, mesh, or grid connection set) must be specified ' + \
+            'when populating property collection from property set'
 
         self.dict = {}  # main dictionary of model property parts which are members of the collection
         # above is mapping from part_name to:
@@ -802,7 +803,8 @@ class PropertyCollection():
                          multiple_handling = 'exception',
                          title = None,
                          title_mode = None,
-                         related_uuid = None):
+                         related_uuid = None,
+                         use_pack = True):
         """Returns the array of data for a single part selected by those arguments which are not None.
 
         arguments:
@@ -814,6 +816,8 @@ class PropertyCollection():
               will also be masked out
            multiple_handling (string, default 'exception'): one of 'exception', 'none', 'first', 'oldest', 'newest'
            title (string, optional): synonym for citation_title argument
+           use_pack (boolean, default True): if True, and the property is a boolean array, the hdf5 data will
+              be unpacked if its shape indicates that it has been packed into bits
 
         Other optional arguments:
         realization, support_uuid, continuous, points, count, indexable, property_kind, facet_type, facet,
@@ -856,7 +860,11 @@ class PropertyCollection():
                               related_uuid = related_uuid)
         if part is None:
             return None
-        return self.cached_part_array_ref(part, dtype = dtype, masked = masked, exclude_null = exclude_null)
+        return self.cached_part_array_ref(part,
+                                          dtype = dtype,
+                                          masked = masked,
+                                          exclude_null = exclude_null,
+                                          use_pack = use_pack)
 
     def number_of_parts(self):
         """Returns the number of parts (properties) in this collection.
@@ -1722,7 +1730,7 @@ class PropertyCollection():
             return None  # could treat as fatal error
         return model.h5_uuid_and_path_for_node(first_values_node, tag = tag)
 
-    def cached_part_array_ref(self, part, dtype = None, masked = False, exclude_null = False):
+    def cached_part_array_ref(self, part, dtype = None, masked = False, exclude_null = False, use_pack = True):
         """Returns a numpy array containing the data for the property part; the array is cached in this collection.
 
         arguments:
@@ -1733,6 +1741,8 @@ class PropertyCollection():
               the mask is set to the inactive array attribute of the support object if present
            exclude_null (boolean, default False): if True, and masked is also True, then elements of the array
               holding the null value will also be masked out
+           use_pack (boolean, default True): if True, and the property is a boolean array, the hdf5 data will
+              be unpacked if its shape indicates that it has been packed into bits for storage
 
         returns:
            reference to a cached numpy array containing the actual property data; multiple calls will return
@@ -1746,7 +1756,8 @@ class PropertyCollection():
            if the indexable element is set to the typical value for the class of supporting representation, eg.
            'cells' for grid objects); if exclude_null is set True then null value elements will also be masked out
            (as long as masked is True); however, it is recommended simply to use np.NaN values in floating point
-           property arrays if the commonality is not needed
+           property arrays if the commonality is not needed;
+           set use_pack True if the hdf5 data may have been written with a similar setting
 
         :meta common:
         """
@@ -1757,7 +1768,7 @@ class PropertyCollection():
             return None
 
         if not hasattr(self, cached_array_name):
-            pcga._cached_part_array_ref_get_array(self, part, dtype, model, cached_array_name)
+            pcga._cached_part_array_ref_get_array(self, part, dtype, model, cached_array_name, use_pack)
 
         if masked:
             exclude_value = self.null_value_for_part(part) if exclude_null else None
@@ -1856,13 +1867,18 @@ class PropertyCollection():
             assert len(patch_list) == 1  # todo: handle more than one patch of values
             return model.h5_uuid_and_path_for_node(rqet.find_tag(patch_list[0], 'Values'))
 
-    def facets_array_ref(self, use_32_bit = False, indexable_element = None):  # todo: add masked argument
+    def facets_array_ref(self,
+                         use_32_bit = False,
+                         indexable_element = None,
+                         use_pack = True):  # todo: add masked argument
         """Returns a +1D array of all parts with first axis being over facet values; Use facet_list() for lookup.
 
         arguments:
            use_32_bit (boolean, default False): if True, the resulting numpy array will use a 32 bit dtype; if False, 64 bit
            indexable_element (string, optional): the indexable element for the properties in the collection; if None, will
               be determined from the data
+           use_pack (boolean, default True): if True, and the property is a boolean array, the hdf5 data will
+              be unpacked if its shape indicates that it has been packed into bits
 
         returns:
            numpy array containing all the data in the collection, the first axis being over facet values and the rest of
@@ -1897,7 +1913,7 @@ class PropertyCollection():
 
         for part in self.parts():
             facet_index = facet_list.index(self.facet_for_part(part))
-            pa = self.cached_part_array_ref(part, dtype = dtype)
+            pa = self.cached_part_array_ref(part, dtype = dtype, use_pack = use_pack)
             a[facet_index] = pa
             self.uncache_part_array(part)
 
@@ -2278,7 +2294,8 @@ class PropertyCollection():
                                      mode = 'a',
                                      expand_const_arrays = False,
                                      dtype = None,
-                                     use_int32 = None):
+                                     use_int32 = None,
+                                     use_pack = False):
         """Create or append to an hdf5 file, writing datasets for the imported arrays.
 
         arguments:
@@ -2293,6 +2310,8 @@ class PropertyCollection():
            use_int32 (bool, optional): if dtype is None, this controls whether 64 bit int arrays are written
               as 32 bit; if None, the system default is to write as 32 bit; if True, 32 bit is used; if
               False, 64 bit data is written; ignored if dtype is not None
+           use_pack (bool, default False): if True, bool arrays will be packed along their last axis; this
+              will generally result in hdf5 data that is not readable by non-resqpy applications
 
         :meta common:
         """
@@ -2315,10 +2334,13 @@ class PropertyCollection():
                 uuid = entry[0]
                 cached_name = entry[3]
             tail = 'points_patch0' if entry[18] else 'values_patch0'
+            if use_pack and (str(dtype).startswith('bool') or
+                             (dtype is None and str(self.__dict__[cached_name].dtype) == 'bool')):
+                dtype = 'pack'
             h5_reg.register_dataset(uuid, tail, self.__dict__[cached_name], dtype = dtype)
         h5_reg.write(file = file_name, mode = mode, use_int32 = use_int32)
 
-    def write_hdf5_for_part(self, part, file_name = None, mode = 'a'):
+    def write_hdf5_for_part(self, part, file_name = None, mode = 'a', use_pack = False):
         """Create or append to an hdf5 file, writing dataset for the specified part."""
 
         if self.constant_value_for_part(part) is not None:
@@ -2326,7 +2348,10 @@ class PropertyCollection():
         h5_reg = rwh5.H5Register(self.model)
         a = self.cached_part_array_ref(part)
         tail = 'points_patch0' if self.points_for_part(part) else 'values_patch0'
-        h5_reg.register_dataset(self.uuid_for_part(part), tail, a)
+        dtype = None
+        if use_pack and 'bool' in str(a.dtype):
+            dtype = 'pack'
+        h5_reg.register_dataset(self.uuid_for_part(part), tail, a, dtype = dtype)
         h5_reg.write(file = file_name, mode = mode)
 
     def create_xml_for_imported_list_and_add_parts_to_model(self,

resqpy/surface/__init__.py

@@ -2,7 +2,7 @@
 
 __all__ = [
     'BaseSurface', 'CombinedSurface', 'Mesh', 'TriangulatedPatch', 'PointSet', 'Surface', 'TriMesh',
-    'distill_triangle_points'
+    'distill_triangle_points', '_adjust_flange_z'
 ]
 
 from ._base_surface import BaseSurface
@@ -10,7 +10,7 @@ from ._combined_surface import CombinedSurface
 from ._mesh import Mesh
 from ._triangulated_patch import TriangulatedPatch
 from ._pointset import PointSet
-from ._surface import Surface, distill_triangle_points
+from ._surface import Surface, distill_triangle_points, _adjust_flange_z
 from ._tri_mesh import TriMesh
 
 # Set "module" attribute of all public objects to this path.

resqpy/surface/_surface.py

@@ -10,6 +10,7 @@ log = logging.getLogger(__name__)
 import numpy as np
 
 import resqpy.crs as rqc
+import resqpy.lines as rql
 import resqpy.olio.intersection as meet
 import resqpy.olio.triangulation as triangulate
 import resqpy.olio.uuid as bu
@@ -394,6 +395,8 @@ class Surface(rqsb.BaseSurface):
                            flange_point_count = 11,
                            flange_radial_factor = 10.0,
                            flange_radial_distance = None,
+                           flange_inner_ring = False,
+                           saucer_parameter = None,
                            make_clockwise = False):
         """Populate this (empty) Surface object with a Delaunay triangulation of points in a PointSet object.
 
@@ -414,6 +417,13 @@ class Surface(rqsb.BaseSurface):
               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
+           saucer_parameter (float, optional): if present, and extend_with_flange is True, then 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
            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
@@ -430,6 +440,7 @@ class Surface(rqsb.BaseSurface):
            and radial distance arguments
         """
 
+        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()
         if crs.xy_units == crs.z_units or not reorient:
@@ -443,10 +454,13 @@ class Surface(rqsb.BaseSurface):
         else:
             p_xy = unit_adjusted_p
         if extend_with_flange:
+            if not reorient:
+                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)
+                                                            radial_distance = flange_radial_distance,
+                                                            inner_ring = flange_inner_ring)
             p_xy_e = np.concatenate((p_xy, flange_points), axis = 0)
             if reorient:
                 # reorient back extenstion points into original p space
@@ -457,6 +471,7 @@ class Surface(rqsb.BaseSurface):
         else:
             p_xy_e = p_xy
             p_e = unit_adjusted_p
+            flange_array = None
         log.debug('number of points going into dt: ' + str(len(p_xy_e)))
         success = False
         try:
@@ -471,15 +486,18 @@ class Surface(rqsb.BaseSurface):
         log.debug('number of triangles: ' + str(len(t)))
         if make_clockwise:
             triangulate.make_all_clockwise_xy(t, p_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:
+                assert reorient, 'flange saucer mode only available with reorientation active'
+                _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)
         self.crs_uuid = point_set.crs_uuid
         self.set_from_triangles_and_points(t, p_e)
-        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)
-            return flange_array
-        return None
+        return 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.
@@ -1074,3 +1092,48 @@ def distill_triangle_points(t, p):
     assert np.all(triangles_mapped < len(points_distilled))
 
     return triangles_mapped, points_distilled
+
+
+def _adjust_flange_z(model, crs_uuid, p_xy_e, flange_start_index, t, flange_array, saucer_parameter):
+    """Adjust the flange point z values (in recumbent space) by extrapolation of pair of points on original."""
+
+    # reconstruct the hull (could be concave) of original points
+    all_edges, edge_use_count = triangulate.edges(t)
+    inner_edges = triangulate.internal_edges(all_edges, edge_use_count)
+    t_for_inner_edges = triangulate.triangles_using_edges(t, inner_edges)
+    assert np.all(t_for_inner_edges >= 0)
+    flange_pairs = flange_array[t_for_inner_edges]
+    rim_edges = inner_edges[np.where(flange_pairs[:, 0] != flange_pairs[:, 1])]
+    assert rim_edges.ndim == 2 and rim_edges.shape[1] == 2 and len(rim_edges) > 0
+    rim_edge_index_list, rim_point_index_list = triangulate.rims(rim_edges)
+    assert len(rim_edge_index_list) == 1 and len(rim_point_index_list) == 1
+    rim_edge_indices = rim_edge_index_list[0]
+    rim_point_indices = rim_point_index_list[0]  # ordered list of points on original hull (could be concave)
+    rim_pl = rql.Polyline(model,
+                          set_coord = p_xy_e[rim_point_indices],
+                          set_crs = crs_uuid,
+                          is_closed = True,
+                          title = 'rim')
+
+    centre = np.mean(p_xy_e[:flange_start_index], axis = 0)
+    # for each flange point, intersect a line from centre with the rim, and sample surface at saucer parameter
+    for flange_pi in range(flange_start_index, len(p_xy_e)):
+        f_xyz = p_xy_e[flange_pi]
+        pl_seg, rim_x, rim_y = rim_pl.first_line_intersection(centre[0], centre[1], f_xyz[0], f_xyz[1])
+        assert pl_seg is not None
+        rim_xyz = rim_pl.segment_xyz_from_xy(pl_seg, rim_x, rim_y)
+        sample_p = (1.0 - saucer_parameter) * centre + saucer_parameter * rim_xyz
+        p_list = vec.points_in_triangles_njit(np.expand_dims(sample_p, axis = 0), p_xy_e[t], 1)
+        vertical = np.array((0.0, 0.0, 1.0), dtype = float)
+        assert len(p_list) > 0
+        triangle_index, p_index, _ = p_list[0]
+        start_xyz = meet.line_triangle_intersect_numba(sample_p, vertical, p_xy_e[t[triangle_index]], t_tol = 0.05)
+        v_to_rim = rim_xyz - start_xyz
+        v_to_flange_p = f_xyz - start_xyz
+        if abs(v_to_rim[0]) > abs(v_to_rim[1]):
+            f = (v_to_rim[0]) / (v_to_flange_p[0])
+        else:
+            f = (v_to_rim[1]) / (v_to_flange_p[1])
+        assert 0.0 < f < 1.0
+        z = (rim_xyz[2] - start_xyz[2]) / f + start_xyz[2]
+        p_xy_e[flange_pi, 2] = z

resqpy/time_series/__init__.py

@@ -3,13 +3,14 @@
 __all__ = [
     'TimeSeries', 'GeologicTimeSeries', 'AnyTimeSeries', 'TimeDuration', 'selected_time_series', 'simplified_timestamp',
     'cleaned_timestamp', 'time_series_from_list', 'merge_timeseries_from_uuid', 'geologic_time_str',
-    'timeframe_for_time_series_uuid', 'any_time_series', 'time_series_from_nexus_summary', 'check_timestamp'
+    'timeframe_for_time_series_uuid', 'any_time_series', 'time_series_from_nexus_summary', 'check_timestamp',
+    'colloquial_date'
 ]
 
 from ._any_time_series import AnyTimeSeries
 from ._geologic_time_series import GeologicTimeSeries
 from ._time_duration import TimeDuration
-from ._time_series import TimeSeries, check_timestamp
+from ._time_series import TimeSeries, check_timestamp, colloquial_date
 from ._functions import selected_time_series, simplified_timestamp, cleaned_timestamp, time_series_from_list, \
     merge_timeseries_from_uuid, geologic_time_str, timeframe_for_time_series_uuid, any_time_series
 from ._from_nexus_summary import time_series_from_nexus_summary

resqpy/time_series/_time_series.py

@@ -233,3 +233,13 @@ def check_timestamp(timestamp):
     if timestamp.endswith('Z'):
         timestamp = timestamp[:-1]
     _ = dt.datetime.fromisoformat(timestamp)
+
+
+def colloquial_date(timestamp, usa_date_format = False):
+    """Returns date string in format DD/MM/YYYY (or MM/DD/YYYY if usa_date_format is True)."""
+    if timestamp.endswith('Z'):
+        timestamp = timestamp[:-1]
+    date_obj = dt.datetime.fromisoformat(timestamp)
+    if usa_date_format:
+        return f'{date_obj.month:02}/{date_obj.day:02}/{date_obj.year:4}'
+    return f'{date_obj.day:02}/{date_obj.month:02}/{date_obj.year:4}'

{resqpy-4.5.0.dist-info → resqpy-4.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: resqpy
-Version: 4.5.0
+Version: 4.6.3
 Summary: Python API for working with RESQML models
 Home-page: https://github.com/bp/resqpy
 License: MIT
@@ -25,7 +25,7 @@ Requires-Dist: lasio (>=0.30,<0.31)
 Requires-Dist: lxml (>=4.9,<5.0)
 Requires-Dist: numba (>=0.56,<1.0)
 Requires-Dist: numpy (>=1.23,<2.0)
-Requires-Dist: pandas (>=1.5,<2.0)
+Requires-Dist: pandas (>=1.4,<2.0)
 Requires-Dist: scipy (>=1.9,<2.0)
 Project-URL: Documentation, https://resqpy.readthedocs.io/en/latest/
 Project-URL: Repository, https://github.com/bp/resqpy
@@ -52,7 +52,7 @@ The package is written and maintained by bp, and is made available under the MIT
 license as a contribution to the open-source community.
 
 **resqpy** was created by Andy Beer. For enquires about resqpy, please contact
-Nathan Lane (Nathan.Lane@bp.com)
+Emma Nesbit (Emma.Nesbit@uk.bp.com)
 
 ### Documentation