pyetp 0.0.28__py3-none-any.whl → 0.0.30__py3-none-any.whl

pyetp/client.py

@@ -7,6 +7,7 @@ import uuid
 from collections import defaultdict
 from contextlib import asynccontextmanager
 from types import TracebackType
+import time
 
 import numpy as np
 import websockets
@@ -148,6 +149,7 @@ class ETPClient(ETPConnection):
         # ok
         return bodies[0]
 
+
     @staticmethod
     def _parse_error_info(bodies: list[ETPModel]) -> list[ErrorInfo]:
         # returns all error infos from bodies
@@ -379,12 +381,9 @@ class ETPClient(ETPConnection):
     async def put_resqml_objects(self, *objs: ro.AbstractObject, dataspace: T.Union[DataspaceURI, str, None] = None):
         from etptypes.energistics.etp.v12.datatypes.object.resource import \
             Resource
-
         time = self.timestamp
         duri = self.get_dataspace_or_default_uri(dataspace)
-
         uris = [DataObjectURI.from_obj(duri, obj) for obj in objs]
-
         dobjs = [DataObject(
             format="xml",
             data=utils_xml.resqml_to_xml(obj),
@@ -448,7 +447,7 @@ class ETPClient(ETPConnection):
         return round(x_ind), round(y_ind)
 
     async def get_surface_value_x_y(self, epc_uri: T.Union[DataObjectURI, str], gri_uri: T.Union[DataObjectURI, str], x: T.Union[int, float], y: T.Union[int, float], method: T.Literal["bilinear", "nearest"]):
-        gri, = await self.get_resqml_objects(gri_uri)  # parallelized using subarray
+        gri, = await self.get_resqml_objects(gri_uri) # parallelized using subarray
         xori = gri.grid2d_patch.geometry.points.supporting_geometry.origin.coordinate1
         yori = gri.grid2d_patch.geometry.points.supporting_geometry.origin.coordinate2
         xinc = gri.grid2d_patch.geometry.points.supporting_geometry.offset[0].spacing.value
@@ -460,8 +459,8 @@ class ETPClient(ETPConnection):
             logger.info(f"Points not inside {x}:{y} {gri}")
             return
         uid = DataArrayIdentifier(
-            uri=str(epc_uri), pathInResource=gri.grid2d_patch.geometry.points.zvalues.values.path_in_hdf_file
-        )
+                    uri=str(epc_uri), pathInResource=gri.grid2d_patch.geometry.points.zvalues.values.path_in_hdf_file
+                )
         if max_x_index_in_gri <= 10 or max_y_index_in_gri <= 10:
             surf = await self.get_xtgeo_surface(epc_uri, gri_uri)
             return surf.get_value_from_xy((x, y), sampling=method)
@@ -632,7 +631,7 @@ class ETPClient(ETPConnection):
     async def get_epc_mesh_property_x_y(self, epc_uri: T.Union[DataObjectURI, str], uns_uri: T.Union[DataObjectURI, str], prop_uri: T.Union[DataObjectURI, str], x: float, y: float):
         uns, = await self.get_resqml_objects(uns_uri)
         points = await self.get_array(
-            DataArrayIdentifier(uri=str(epc_uri), pathInResource=uns.geometry.points.coordinates.path_in_hdf_file))
+                    DataArrayIdentifier(uri=str(epc_uri), pathInResource=uns.geometry.points.coordinates.path_in_hdf_file))
         chk = self.check_bound(points, x, y)
         if chk == False:
             return None
@@ -671,7 +670,7 @@ class ETPClient(ETPConnection):
         cprop, = await self.get_resqml_objects(prop_uri)
         assert str(cprop.indexable_element) == 'IndexableElements.NODES'
         props_uid = DataArrayIdentifier(
-            uri=str(epc_uri), pathInResource=cprop.patch_of_values[0].values.values.path_in_hdf_file)
+                    uri=str(epc_uri), pathInResource=cprop.patch_of_values[0].values.values.path_in_hdf_file)
         meta, = await self.get_array_metadata(props_uid)
         filtered_points = np.zeros((total_points_filtered, 3), dtype=np.float64)
         all_values = np.empty(total_points_filtered, dtype=np.float64)
@@ -704,8 +703,35 @@ class ETPClient(ETPConnection):
         response_filtered = response[:, ~np.isnan(response[1])]
         return {"depth": response_filtered[0], "values": response_filtered[1]}
 
+    async def put_rddms_property(self, epc_uri: T.Union[DataObjectURI , str], 
+            cprop0: T.Union[ro.ContinuousProperty, ro.DiscreteProperty], 
+            propertykind0: ro.PropertyKind, 
+            array_ref: np.ndarray, dataspace: T.Union[DataspaceURI , str , None] ):
+
+        assert isinstance(cprop0, ro.ContinuousProperty) or isinstance(cprop0, ro.DiscreteProperty), "prop must be a Property"
+        assert len(cprop0.patch_of_values) == 1, "property obj must have exactly one patch of values"
+
+        st = time.time()
+        propkind_uri = [""] if (propertykind0 is None) else (await self.put_resqml_objects(propertykind0, dataspace=dataspace))
+        cprop_uri = await self.put_resqml_objects(cprop0, dataspace=dataspace)
+        delay = time.time() - st
+        logger.debug(f"pyetp: put_rddms_property: put objects took {delay} s")
+        
+        st = time.time()
+        response = await self.put_array(
+            DataArrayIdentifier(
+                uri=epc_uri.raw_uri if isinstance(epc_uri, DataObjectURI) else epc_uri,
+                pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,
+            ),
+            array_ref,  # type: ignore
+        )
+        delay = time.time() - st
+        logger.debug(f"pyetp: put_rddms_property: put array ({array_ref.shape}) took {delay} s")
+        return cprop_uri, propkind_uri
+
     async def put_epc_mesh(
-        self, epc_filename, title_in, property_titles, projected_epsg, dataspace
+        self, epc_filename: str, title_in: str, property_titles: T.List[str], projected_epsg: int, 
+        dataspace: T.Union[DataspaceURI , str , None]
     ):
         uns, crs, epc, timeseries, hexa = utils_xml.convert_epc_mesh_to_resqml_mesh(epc_filename, title_in, projected_epsg)
         epc_uri, crs_uri, uns_uri = await self.put_resqml_objects(epc, crs, uns, dataspace=dataspace)
@@ -713,9 +739,7 @@ class ETPClient(ETPConnection):
         if timeseries is not None:
             timeseries_uris = await self.put_resqml_objects(timeseries, dataspace=dataspace)
             timeseries_uri = list(timeseries_uris)[0] if (len(list(timeseries_uris)) > 0) else ""
-
-        logger.debug(f"put_epc_mesh property_titles {property_titles}")
-
+        
         #
         # mesh geometry (six arrays)
         #
@@ -784,19 +808,7 @@ class ETPClient(ETPConnection):
 
             cprop_uris = []
             for cprop0, prop, time_index in zip(cprop0s, props, time_indices):
-                assert isinstance(cprop0, ro.ContinuousProperty) or isinstance(cprop0, ro.DiscreteProperty), "prop must be a Property"
-                assert len(cprop0.patch_of_values) == 1, "property obj must have exactly one patch of values"
-
-                propkind_uri = [""] if (propertykind0 is None) else (await self.put_resqml_objects(propertykind0, dataspace=dataspace))
-                cprop_uri = await self.put_resqml_objects(cprop0, dataspace=dataspace)
-
-                response = await self.put_array(
-                    DataArrayIdentifier(
-                        uri=epc_uri.raw_uri if isinstance(epc_uri, DataObjectURI) else epc_uri,
-                        pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,
-                    ),
-                    prop.array_ref(),  # type: ignore
-                )
+                cprop_uri, propkind_uri = await self.put_rddms_property(epc_uri, cprop0, propertykind0, prop.array_ref(), dataspace)
                 cprop_uris.extend(cprop_uri)
             prop_rddms_uris[propname] = [propkind_uri, cprop_uris]
 
@@ -805,10 +817,10 @@ class ETPClient(ETPConnection):
     async def get_mesh_points(self, epc_uri: T.Union[DataObjectURI, str], uns_uri: T.Union[DataObjectURI, str]):
         uns, = await self.get_resqml_objects(uns_uri)
         points = await self.get_array(
-            DataArrayIdentifier(
-                uri=str(epc_uri), pathInResource=uns.geometry.points.coordinates.path_in_hdf_file
+                DataArrayIdentifier(
+                    uri=str(epc_uri), pathInResource=uns.geometry.points.coordinates.path_in_hdf_file
+                )
             )
-        )
         return points
 
     async def get_epc_property_surface_slice_node(self, epc_uri: T.Union[DataObjectURI, str], cprop0: ro.AbstractObject, points: np.ndarray, node_index: int, n_node_per_pos: int):
@@ -816,8 +828,8 @@ class ETPClient(ETPConnection):
         indexing_array = np.arange(node_index, points.shape[0], n_node_per_pos, dtype=np.int32)
         results = points[indexing_array, :]
         arr = await asyncio.gather(*[self.get_subarray(DataArrayIdentifier(
-            uri=str(epc_uri), pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,),
-            [i], [1]) for i in indexing_array])
+                uri=str(epc_uri), pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,),
+                [i], [1]) for i in indexing_array])
         arr = np.array(arr).flatten()
         assert results.shape[0] == arr.size
         results[:, 2] = arr
@@ -825,7 +837,7 @@ class ETPClient(ETPConnection):
 
     async def get_epc_property_surface_slice_cell(self, epc_uri: T.Union[DataObjectURI, str], cprop0: ro.AbstractObject, points: np.ndarray, node_index: int, n_node_per_pos: int, get_cell_pos=True):
         m, = await self.get_array_metadata(DataArrayIdentifier(
-            uri=str(epc_uri), pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,))
+                    uri=str(epc_uri), pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,))
         n_cells = m.dimensions[0]
         layers_per_sediment_unit = 2
         n_cell_per_pos = n_node_per_pos - 1
@@ -835,8 +847,8 @@ class ETPClient(ETPConnection):
         else:
             results = np.zeros((int(n_cells/n_cell_per_pos), 3), dtype=np.float64)
         arr = await asyncio.gather(*[self.get_subarray(DataArrayIdentifier(
-            uri=str(epc_uri), pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,),
-            [i], [1]) for i in indexing_array])
+                uri=str(epc_uri), pathInResource=cprop0.patch_of_values[0].values.values.path_in_hdf_file,),
+                [i], [1]) for i in indexing_array])
         arr = np.array(arr).flatten()
         assert results.shape[0] == arr.size
         results[:, 2] = arr
@@ -960,9 +972,9 @@ class ETPClient(ETPConnection):
 
         # starts [start_X, starts_Y]
         # counts [count_X, count_Y]
-        starts = np.array(starts).astype(np.int64)  # len = 2 [x_start_index, y_start_index]
-        counts = np.array(counts).astype(np.int64)  # len = 2
-        ends = starts + counts  # len = 2
+        starts = np.array(starts).astype(np.int64) # len = 2 [x_start_index, y_start_index]
+        counts = np.array(counts).astype(np.int64) # len = 2
+        ends = starts + counts # len = 2
         if put_uninitialized:
             transport_array_type = utils_arrays.get_transport(data.dtype)
             await self._put_uninitialized_data_array(uid, data.shape, transport_array_type=transport_array_type)

pyetp/uri.py

@@ -69,16 +69,18 @@ class DataObjectURI(_DataObjectURI, _Mixin):
     def from_obj(cls, dataspace: Union[DataspaceURI , str], obj: ro.AbstractObject):
 
         objname = obj.__class__.__name__
-        namespace: str = getattr(obj.Meta, 'namespace', None) or getattr(obj.Meta, 'target_namespace')
-        namespace = namespace.lower()
-
-        # TODO: we can rather look at citation.format - which could be used for xmlformat ? - however to be backward capatiable we check namespaces instead
-        if namespace.endswith('resqmlv2'):
-            domain = "resqml20"
-        elif namespace.endswith('data/commonv2'):
-            domain = "eml20"
+        if getattr(obj, 'Meta', None):
+            namespace: str = getattr(obj.Meta, 'namespace', None) or getattr(obj.Meta, 'target_namespace')
+            namespace = namespace.lower()
+            # TODO: we can rather look at citation.format - which could be used for xmlformat ? - however to be backward capatiable we check namespaces instead
+            if namespace.endswith('resqmlv2'):
+                domain = "resqml20"
+            elif namespace.endswith('data/commonv2'):
+                domain = "eml20"
+            else:
+                raise TypeError(f"Could not parse domain from namespace ({namespace})")
         else:
-            raise TypeError(f"Could not parse domain from namespace ({namespace})")
+            domain = "eml20"  # fallback to eml20 for backwards compatibility. 
 
         return cls.from_parts(dataspace, domain, objname, obj.uuid)
 

pyetp/utils_xml.py

@@ -208,6 +208,312 @@ def instantiate_resqml_grid(name: str, rotation: float, x0: float, y0: float, dx
     return epc, crs, gri
 
 
+def uom_for_prop_title(pt: str):
+    if (pt == "Age"):
+        return ro.ResqmlUom.A_1
+    if (pt == "Temperature"):
+        return ro.ResqmlUom.DEG_C
+    if (pt == "LayerID"):
+        return ro.ResqmlUom.EUC
+    if (pt == "Porosity_initial"):
+        return ro.ResqmlUom.M3_M3
+    if (pt == "Porosity_decay"):
+        return ro.ResqmlUom.VALUE_1_M
+    if (pt == "Density_solid"):
+        return ro.ResqmlUom.KG_M3
+    if (pt == "insulance_thermal"):
+        return ro.ThermalInsulanceUom.DELTA_K_M2_W
+    if (pt == "Radiogenic_heat_production"):
+        return ro.ResqmlUom.U_W_M3
+    if (pt == 'dynamic nodes') or (pt=='points'):
+        return ro.ResqmlUom.M
+    if (pt == 'thermal_conductivity'):
+        return ro.ResqmlUom.W_M_K
+    if (pt == 'Vitrinite reflectance' or pt == '%Ro'):
+        return ro.ResqmlUom.VALUE
+    if ("Expelled" in pt):
+        return ro.ResqmlUom.KG_M3
+    if ("Transformation" in pt):
+        return ro.ResqmlUom.VALUE
+    return ro.ResqmlUom.EUC
+
+def create_resqml_property(prop_title, continuous, indexable_element, uns, epc, min_val=0.0, max_val=1.0, 
+                           timeseries=None, time_index=-1, pre_existing_propertykind = None):
+    timeindex_ref = None
+    use_timeseries = timeseries is not None
+    if use_timeseries:
+        # time_index = time_indices[i]
+        timeindex_ref = ro.TimeIndex(
+            index = time_index,
+            time_series = ro.DataObjectReference(
+                content_type=f"application/x-resqml+xml;version={schema_version};type={get_data_object_type(timeseries)}",
+                title=timeseries.citation.title,
+                uuid=timeseries.uuid,
+            )
+        )
+
+    r_uom = ro.ResqmlUom( value= uom_for_prop_title(prop_title) )
+    # r_uom = ro.ResqmlUom( uom )
+
+    if (pre_existing_propertykind is None):
+        pk_uuid = uuid4()
+        propertykind0 = ro.PropertyKind(
+            schema_version=schema_version,
+            citation=create_common_citation(f"{prop_title}"),
+            naming_system="urn:resqml:bp.com:resqpy",
+            is_abstract=False,
+            representative_uom=uom_for_prop_title(prop_title),
+            parent_property_kind=ro.StandardPropertyKind(
+                kind=ro.ResqmlPropertyKind.CONTINUOUS if continuous else ro.ResqmlPropertyKind.DISCRETE
+            ),
+            uuid=str(pk_uuid),
+        )
+    else:
+        propertykind0 = pre_existing_propertykind
+
+    prop_uuid = uuid4()
+
+    pov = ro.PatchOfValues(
+        values=ro.DoubleHdf5Array(
+            values=ro.Hdf5Dataset(
+                path_in_hdf_file=f"/RESQML/{str(prop_uuid)}/values",
+                hdf_proxy=ro.DataObjectReference(
+                    content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                    title=epc.citation.title,
+                    uuid=str(epc.uuid),
+                ),
+            )
+        ) if continuous else
+        ro.IntegerHdf5Array(
+            values=ro.Hdf5Dataset(
+                path_in_hdf_file=f"/RESQML/{str(prop_uuid)}/values",
+                hdf_proxy=ro.DataObjectReference(
+                    content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                    title=epc.citation.title,
+                    uuid=str(epc.uuid),
+                ),
+            ),
+            null_value=int(1e30),
+        )
+    )
+
+    if (continuous):
+        cprop0 = ro.ContinuousProperty(
+            schema_version=schema_version,
+            citation=create_common_citation(f"{prop_title}"),
+            uuid=str(prop_uuid),
+            uom = r_uom,
+            count=1,
+            indexable_element=indexable_element,
+            supporting_representation=ro.DataObjectReference(
+                content_type=f"application/x-resqml+xml;version={schema_version};type={get_data_object_type(uns)}",
+                title=uns.citation.title,
+                uuid=uns.uuid,
+            ),
+            property_kind= propertykind0 if pre_existing_propertykind is True else ro.LocalPropertyKind(
+                local_property_kind=ro.DataObjectReference(
+                    content_type=f"application/x-resqml+xml;version={schema_version};type={get_data_object_type(propertykind0)}",
+                    title=propertykind0.citation.title,
+                    uuid=propertykind0.uuid,
+                )
+            ), # if (propertykind0 is not None) else ro.StandardPropertyKind(kind=prop.property_kind()),
+            minimum_value=[min_val],
+            maximum_value=[max_val],
+            facet=[ro.PropertyKindFacet(
+                facet=ro.Facet.WHAT,
+                value=prop_title,  # prop.facet(),
+            )],
+            patch_of_values=[pov],
+            time_index=timeindex_ref,
+        )
+    else:
+        cprop0 = ro.DiscreteProperty(
+            schema_version=schema_version,
+            citation=create_common_citation(f"{prop_title}"),
+            uuid=str(prop_uuid),
+            # uom = prop.uom(),
+            count=1,
+            indexable_element=indexable_element,
+            supporting_representation=ro.DataObjectReference(
+                content_type=f"application/x-resqml+xml;version={schema_version};type={get_data_object_type(uns)}",
+                title=uns.citation.title,
+                uuid=uns.uuid,
+            ),
+            property_kind=propertykind0 if pre_existing_propertykind is True else ro.LocalPropertyKind(
+                local_property_kind=ro.DataObjectReference(
+                    content_type=f"application/x-resqml+xml;version={schema_version};type={get_data_object_type(propertykind0)}",
+                    title=propertykind0.citation.title,
+                    uuid=propertykind0.uuid,
+                )
+            ), # if (propertykind0 is not None) else ro.StandardPropertyKind(kind=prop.property_kind()),
+            minimum_value=[int(min_val)],
+            maximum_value=[int(max_val)],
+            facet=[ro.PropertyKindFacet(
+                facet=ro.Facet.WHAT,
+                value=prop_title,  # prop.facet(),
+            )],
+            patch_of_values=[pov],
+            time_index=timeindex_ref,
+        )
+    return cprop0, propertykind0
+
+def create_resqml_mesh(rmdi, rmdts, geotimes, projected_epsg):  #(rddms_mesh_data_initial, rddms_upload_data_timestep)
+    import numpy as np
+    ro_timestamps = []
+    for i in geotimes:
+        ro_timestamps.append(
+            ro.Timestamp(
+                date_time=XmlDateTime.from_string("0001-01-01T00:00:00.00+00:00"),
+                year_offset=int(i),
+            )
+        )    
+
+    gts_citation_title = "warmth simulation"
+    gts_uuid = uuid4()
+
+    timeseries = ro.TimeSeries(
+        citation=create_common_citation(str(gts_citation_title)),
+        schema_version=schema_version,
+        uuid=str(gts_uuid),
+        time = ro_timestamps,
+    )    
+    crs = create_common_crs(gts_citation_title, projected_epsg)
+    epc = ro.EpcExternalPartReference(
+        citation=create_common_citation("Hdf Proxy"),
+        schema_version=schema_version,
+        uuid=str(uuid4()),
+        mime_type="application/x-hdf5",
+    )
+    cellshape = ro.CellShape.HEXAHEDRAL ## if (hexa.cell_shape == "hexahedral") else ro.CellShape.TETRAHEDRAL
+    cells = rmdi.hexa_renumbered
+    nodes_time_0 = rmdts.points_cached
+    node_count = nodes_time_0.shape[0]
+    faces_per_cell = []
+    nodes_per_face = []
+    faces_dict = {}
+    faces_repeat = np.zeros(node_count*100, dtype = bool)
+    cell_face_is_right_handed = np.zeros( len(cells)*6, dtype = bool)
+
+    for ih,hexa in enumerate(cells):
+        faces= [[0,3,2,1], [0,1,5,4], [1,2,6,5], [2,3,7,6], [3,0,4,7], [4,5,6,7]]
+        for iq,quad in enumerate(faces):
+            face0 = [hexa[x] for x in quad ]
+            assert -1 not in face0
+            fkey0 = ( x for x in sorted(face0) )
+            #
+            # keep track of which faces are encountered once vs. more than once
+            # faces that are encountered the second time will need to use the reverse handedness
+            #
+            face_is_repeated = False
+            if (fkey0 not in faces_dict):
+                faces_dict[fkey0] = len(nodes_per_face)
+                nodes_per_face.extend(face0)
+                cell_face_is_right_handed[(ih*6 + iq)] = False
+            else:
+                face_is_repeated = True
+                cell_face_is_right_handed[(ih*6 + iq)] = True
+            fidx0 = faces_dict.get(fkey0)            
+            faces_per_cell.append(fidx0/4)
+            faces_repeat[int(fidx0/4)] = face_is_repeated
+    set_cell_count = int(len(faces_per_cell)/6)
+    face_count = int(len(nodes_per_face)/4)
+
+    node_count=node_count
+    face_count=face_count
+    cell_count=set_cell_count
+
+    hexa_uuid = uuid4()
+    geom = ro.UnstructuredGridGeometry(
+        local_crs=ro.DataObjectReference(
+            content_type=f"application/x-resqml+xml;version={schema_version};type={get_data_object_type(crs)}",
+            title=crs.citation.title,
+            uuid=crs.uuid,
+        ),
+        node_count=node_count,
+        face_count=face_count,
+        cell_shape=cellshape,
+        points=ro.Point3dHdf5Array(
+            coordinates=ro.Hdf5Dataset(
+                path_in_hdf_file=f"/RESQML/{str(hexa_uuid)}/points",
+                hdf_proxy=ro.DataObjectReference(
+                    content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                    title=epc.citation.title,
+                    uuid=str(epc.uuid),
+                ),
+            )
+        ),
+        nodes_per_face=ro.ResqmlJaggedArray(
+            elements=ro.IntegerHdf5Array(
+                null_value=-1,
+                values=ro.Hdf5Dataset(
+                    path_in_hdf_file=f"/RESQML/{str(hexa_uuid)}/nodes_per_face",
+                    hdf_proxy=ro.DataObjectReference(
+                        content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                        title=epc.citation.title,
+                        uuid=str(epc.uuid),
+                    ),
+                )
+            ),
+            cumulative_length=ro.IntegerHdf5Array(
+                null_value=-1,
+                values=ro.Hdf5Dataset(
+                    path_in_hdf_file=f"/RESQML/{str(hexa_uuid)}/nodes_per_face_cl",
+                    hdf_proxy=ro.DataObjectReference(
+                        content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                        title=epc.citation.title,
+                        uuid=str(epc.uuid),
+                    ),
+                )
+            ),
+        ),
+        faces_per_cell=ro.ResqmlJaggedArray(
+            elements=ro.IntegerHdf5Array(
+                null_value=-1,
+                values=ro.Hdf5Dataset(
+                    path_in_hdf_file=f"/RESQML/{str(hexa_uuid)}/faces_per_cell",
+                    hdf_proxy=ro.DataObjectReference(
+                        content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                        title=epc.citation.title,
+                        uuid=str(epc.uuid),
+                    ),
+                )
+            ),
+            cumulative_length=ro.IntegerHdf5Array(
+                null_value=-1,
+                values=ro.Hdf5Dataset(
+                    path_in_hdf_file=f"/RESQML/{str(hexa_uuid)}/faces_per_cell_cl",
+                    hdf_proxy=ro.DataObjectReference(
+                        content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                        title=epc.citation.title,
+                        uuid=str(epc.uuid),
+                    ),
+                )
+            ),
+        ),
+        cell_face_is_right_handed=ro.BooleanHdf5Array(
+            values=ro.Hdf5Dataset(
+                path_in_hdf_file=f"/RESQML/{str(hexa_uuid)}/cell_face_is_right_handed",
+                hdf_proxy=ro.DataObjectReference(
+                    content_type=f"application/x-eml+xml;version={schema_version};type={get_data_object_type(epc)}",
+                    title=epc.citation.title,
+                    uuid=str(epc.uuid),
+                ),
+            )
+        )
+    )
+
+    #
+    uns = ro.UnstructuredGridRepresentation(
+        uuid=str(hexa_uuid),
+        schema_version=schema_version,
+        # surface_role=resqml_objects.SurfaceRole.MAP,
+        citation=create_common_citation(gts_citation_title),
+        cell_count=cell_count,
+        geometry=geom,
+    )
+    return uns, crs, epc, timeseries
+
+
 def convert_epc_mesh_to_resqml_mesh(epc_filename, title_in, projected_epsg):
     import resqpy.model as rq
     import resqpy.time_series as rts
@@ -232,12 +538,9 @@ def convert_epc_mesh_to_resqml_mesh(epc_filename, title_in, projected_epsg):
     # ts_uuid_2 = model.uuid(obj_type='GeologicTimeSeries')
     # logger.debug(f"TS UUIDs: {ts_uuid} {ts_uuid_2}")
     gts = rts.GeologicTimeSeries(model, uuid=ts_uuid)
-
     logger.debug(f"gts: {gts}")
     timeseries = None
-    # dynamic_points = []
     if (ts_uuid is not None) and (gts is not None):
-
         ro_timestamps = []
         for i in gts.iter_timestamps(as_string=False):
             ro_timestamps.append(
@@ -246,9 +549,7 @@ def convert_epc_mesh_to_resqml_mesh(epc_filename, title_in, projected_epsg):
                     year_offset=int(i),
                 )
             )
-
         logger.info(f"Generating time series with {len(ro_timestamps)} indices, year offsets: {ro_timestamps[0].year_offset} -- {ro_timestamps[-1].year_offset}.")
-
         timeseries = ro.TimeSeries(
             citation=create_common_citation(str(gts.citation_title)),
             schema_version=schema_version,
@@ -256,6 +557,7 @@ def convert_epc_mesh_to_resqml_mesh(epc_filename, title_in, projected_epsg):
             time=ro_timestamps,
         )
 
+
     crs = create_common_crs(title, projected_epsg)
 
     epc = ro.EpcExternalPartReference(
@@ -363,35 +665,6 @@ def convert_epc_mesh_property_to_resqml_mesh(epc_filename, hexa, prop_title, uns
     import resqpy.model as rq
     import resqpy.property as rqp
 
-    def uom_for_prop_title(pt: str):
-        if (pt == "Age"):
-            return ro.ResqmlUom.A_1
-        if (pt == "Temperature"):
-            return ro.ResqmlUom.DEG_C
-        if (pt == "LayerID"):
-            return ro.ResqmlUom.EUC
-        if (pt == "Porosity_initial"):
-            return ro.ResqmlUom.M3_M3
-        if (pt == "Porosity_decay"):
-            return ro.ResqmlUom.VALUE_1_M
-        if (pt == "Density_solid"):
-            return ro.ResqmlUom.KG_M3
-        if (pt == "insulance_thermal"):
-            return ro.ThermalInsulanceUom.DELTA_K_M2_W
-        if (pt == "Radiogenic_heat_production"):
-            return ro.ResqmlUom.U_W_M3
-        if (pt == 'dynamic nodes') or (pt == 'points'):
-            return ro.ResqmlUom.M
-        if (pt == 'thermal_conductivity'):
-            return ro.ResqmlUom.W_M_K
-        if (pt == 'Vitrinite reflectance' or pt == '%Ro'):
-            return ro.ResqmlUom.VALUE
-        if ("Expelled" in pt):
-            return ro.ResqmlUom.KG_M3
-        if ("Transformation" in pt):
-            return ro.ResqmlUom.VALUE
-        return ro.ResqmlUom.EUC
-
     model = rq.Model(epc_filename)
     assert model is not None
     prop_types = ['obj_ContinuousProperty', 'obj_DiscreteProperty', 'obj_CategoricalProperty', 'obj_PointsProperty']
@@ -438,6 +711,8 @@ def convert_epc_mesh_property_to_resqml_mesh(epc_filename, hexa, prop_title, uns
             prop_uuid = prop_uuids[time_indices[i]]
             prop = rqp.Property(model, uuid=prop_uuid)
 
+        # def create_resqml_property(prop_title, continuous, indexable_element, uns, epc, min_val=0.0, max_val=1.0, timeseries=None, time_index=-1):
+
         pov = ro.PatchOfValues(
             values=ro.DoubleHdf5Array(
                 values=ro.Hdf5Dataset(

{pyetp-0.0.28.dist-info → pyetp-0.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyetp
-Version: 0.0.28
+Version: 0.0.30
 Summary: Interface with OSDU RDDMS using ETP protocol
 Author: Adam Cheng
 Author-email: 52572642+adamchengtkc@users.noreply.github.com

{pyetp-0.0.28.dist-info → pyetp-0.0.30.dist-info}/RECORD

@@ -1,14 +1,14 @@
 pyetp/__init__.py,sha256=FSlPJ3AXoMe3vDQ0z8k417aKJWwt7sxbNPsLgdc21tI,123
-pyetp/client.py,sha256=qW1vN8EWPk5TZFmvv2LWf2MxmuUCJn3I3fDsmPxbsj0,48891
+pyetp/client.py,sha256=MJmS-HfQKmbcfMriakDcwwoBdVgMQAF6LcpgdFx20TU,49638
 pyetp/config.py,sha256=Z0Q3dH0olM4CKLckDA_EV23XK_al2Ey8D9JrKb3s5R0,949
 pyetp/resqml_objects/__init__.py,sha256=Sr_1bktzS8JMmE9oi6pcW6BuERm7gH0u50rBs58zI7Q,50492
 pyetp/resqml_objects/generated.py,sha256=P-hfL8btOE6uAmtaGXbSdWMl8Z9iJx-r6FRzSvmzHvU,783914
 pyetp/types.py,sha256=E-CvzI74kiQ52J42DQ-5wGUC84l3-glYs3NQ36HIs1I,2559
-pyetp/uri.py,sha256=td4ksTWvG4LULtg5H3DKiDl0D6hIr1d-WEUJLW_gdu4,2795
+pyetp/uri.py,sha256=57wTOH7EAGXluDiGxIe34DAiftPR91jEnbRB5thaG8k,2963
 pyetp/utils.py,sha256=WxfG13bItprl457H3EEsckF1uDwF-hzPhVG7QRX0LB8,158
 pyetp/utils_arrays.py,sha256=HHhw23La4SG7UJyd5Q_OJ5WlMq98QpwHBk553YyyYOk,4331
-pyetp/utils_xml.py,sha256=bCL5mdxplid_lrGaNeZMMXBNR8PK6NNaKdhO27XL8BY,22032
-pyetp-0.0.28.dist-info/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyetp-0.0.28.dist-info/METADATA,sha256=tGWwKD16bHrQ_sDUDhTqxfAu0a3X--EoCyh-5QRqh5o,2393
-pyetp-0.0.28.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-pyetp-0.0.28.dist-info/RECORD,,
+pyetp/utils_xml.py,sha256=_sczOVws6h60dQXkUyV7z_OJrVgcGQw2zQlvUA8jI4A,33639
+pyetp-0.0.30.dist-info/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyetp-0.0.30.dist-info/METADATA,sha256=xF1KaKkQuMw4nY_XDpD54KMpgQk71aoRdpbc15pP01M,2393
+pyetp-0.0.30.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+pyetp-0.0.30.dist-info/RECORD,,