Merge branch 'SC-1127' into 'master'

SC-1127: Fix horizons mismatch in TVT-ROP Heatmap script

See merge request SOLO-band/python-sdk!51

Author: tmestan-zade-rogii

examples/interpretation_dip_calculation.py

@@ -42,13 +42,13 @@ def calc_interpretation_dip():
 
     segments = get_segments(
         well=well_data,
-        assembled_segments=interpretation.get_assembled_segments_data()['segments'],
+        assembled_segments=interpretation.assembled_segments['segments'],
         calculated_trajectory=calculated_trajectory,
         measure_units=MEASURE_UNITS
     )
     segments_with_dip = get_segments_with_dip(
         segments=segments,
-        assembled_horizons=interpretation.get_assembled_segments_data()['horizons']
+        assembled_horizons=interpretation.assembled_segments['horizons']
     )
 
     calculated_dips = DataFrame(segments_with_dip, columns=['md', 'dip'])

examples/tvt_rop_heatmap/tvt_rop_heatmap.py

@@ -10,30 +10,12 @@
 
 import rogii_solo.well
 from rogii_solo import SoloClient
+from rogii_solo.calculations.base import get_nearest_values
 from rogii_solo.calculations.interpretation import interpolate_trajectory_point
 from rogii_solo.calculations.trajectory import calculate_trajectory
 from rogii_solo.interpretation import Interpretation
 
 
-def get_nearest_values(value: Any, input_list: List[Any]) -> Any:
-    if not input_list:
-        return
-
-    pos = bisect_left(input_list, value)
-
-    if pos == 0:
-        values = [input_list[0]]
-    elif pos == len(input_list):
-        values = [input_list[-1]]
-    else:
-        values = [
-            input_list[pos - 1],
-            input_list[pos]
-        ]
-
-    return values
-
-
 def get_interpolated_trajectory(solo_client: SoloClient, well: 'rogii_solo.well.Well') -> List[Dict[str, float]]:
     well_data = well.to_dict()
     calculated_trajectory = calculate_trajectory(
@@ -75,14 +57,30 @@ def get_interpolated_trajectory(solo_client: SoloClient, well: 'rogii_solo.well.
 
 
 def get_horizons(interpretation: Interpretation, md_step: int) -> List[Dict[str, Any]]:
-    horizons = interpretation.get_horizons_tvt_data(md_step=md_step)
+    horizons = interpretation.get_tvt_data(md_step)
 
     if not horizons:
         raise Exception('Horizons\' data not found.')
 
     return horizons
 
 
+def get_horizon_tvts(interpretation: Interpretation) -> List[Dict[str, Any]]:
+    horizon_tvts = []
+    horizons_data = interpretation.assembled_segments['horizons'].values()
+
+    for horizon in horizons_data:
+        horizon_tvts.append(
+            {
+                'name': horizon['name'],
+                'uuid': horizon['uuid'],
+                'tvt': horizon['tvd'],
+            }
+        )
+
+    return horizon_tvts
+
+
 def get_horizons_data_by_md(horizons: List[Dict[str, Any]], md: float) -> Dict[str, Any]:
     mds = [horizon_data['md'] for horizon_data in horizons]
     idx = bisect_left(mds, md)
@@ -172,7 +170,6 @@ def get_heatmap_data(trajectory: List[Dict[str, float]],
 def get_horizon_scatters(xedges2: Any,
                          yedges2: Any,
                          horizons: List[Dict[str, Any]],
-                         kb: float,
                          zero_horizon_uuid: str
                          ) -> List[go.Scatter]:
     tvt_margin = 0.1
@@ -183,11 +180,11 @@ def get_horizon_scatters(xedges2: Any,
 
     for horizon in horizons:
         if horizon['uuid'] == zero_horizon_uuid:
-            zero_tvt = kb - horizon['tvdss']
+            zero_tvt = horizon['tvt']
             break
 
     for horizon in horizons:
-        tvt = kb - horizon['tvdss'] - zero_tvt
+        tvt = horizon['tvt'] - zero_tvt
 
         if y_min - tvt_margin <= tvt <= y_max + tvt_margin:
             data.append(
@@ -275,12 +272,12 @@ def build_tvt_rop_heatmap(script_settings: Dict[str, Any]):
         bins=bins
     )
     data.append(go.Heatmap(x=xedges2, y=yedges2, z=histogram2d, showscale=False))
-    well_data = well.to_dict()
+
+    horizon_tvts = get_horizon_tvts(interpretation)
     horizon_scatters = get_horizon_scatters(
         xedges2=xedges2,
         yedges2=yedges2,
-        horizons=horizons[0]['horizons'],
-        kb=well_data['kb'],
+        horizons=horizon_tvts,
         zero_horizon_uuid=interpretation_data['meta']['properties']['zero_horizon_uuid']
     )
     data.extend(horizon_scatters)

src/rogii_solo/base.py

@@ -47,15 +47,14 @@ def to_df(self, get_converted: bool = True) -> DataFrame:
         """
         pass
 
-    def _find_by_path(
-            self,
-            obj: Dict or Iterable[Dict],
-            path: str or Iterable[str],
-            default: Any = None,
-            divider: str = None,
-            check_none: bool = False,
-            to_list: bool = False,
-    ) -> Any:
+    def _find_by_path(self,
+                      obj: Dict or Iterable[Dict],
+                      path: str or Iterable[str],
+                      default: Any = None,
+                      divider: str = None,
+                      check_none: bool = False,
+                      to_list: bool = False,
+                      ) -> Any:
         """
         Find nested key value in dict
         :param obj:
@@ -94,15 +93,14 @@ def _find_by_path(
 
         return result
 
-    def __find_by_path(
-            self,
-            obj: Dict,
-            path: str,
-            default: Any = None,
-            divider: str = None,
-            check_none: bool = False,
-            to_list: bool = False,
-    ) -> Any:
+    def __find_by_path(self,
+                       obj: Dict,
+                       path: str,
+                       default: Any = None,
+                       divider: str = None,
+                       check_none: bool = False,
+                       to_list: bool = False,
+                       ) -> Any:
         if not obj:
             return None if not to_list else []
 

src/rogii_solo/horizon.py

@@ -44,7 +44,7 @@ def _get_data(self, get_converted: bool):
     def _calculate_points(self, get_converted: bool):
         well_data = self.interpretation.well.to_dict(get_converted=False)
         trajectory_data = self.interpretation.well.trajectory.to_dict(get_converted=False)
-        assembled_segments_data = self.interpretation.get_assembled_segments_data()
+        assembled_segments_data = self.interpretation.assembled_segments
         measure_units = self.interpretation.well.project.measure_unit
 
         calculated_trajectory = calculate_trajectory(

src/rogii_solo/interpretation.py

@@ -4,12 +4,16 @@
 
 import rogii_solo.well
 from rogii_solo.base import ComplexObject, ObjectRepository
+from rogii_solo.calculations.converters import meters_to_feet
+from rogii_solo.calculations.enums import EMeasureUnits
 from rogii_solo.horizon import Horizon
 from rogii_solo.papi.client import PapiClient
 from rogii_solo.papi.types import PapiAssembledSegments
 from rogii_solo.types import DataList
 from rogii_solo.types import Interpretation as InterpretationType
 
+TVT_DATA_MAX_MD_STEP = 100000
+
 
 class Interpretation(ComplexObject):
     def __init__(self, papi_client: PapiClient, well: 'rogii_solo.well.Well', **kwargs):
@@ -27,8 +31,6 @@ def __init__(self, papi_client: PapiClient, well: 'rogii_solo.well.Well', **kwar
 
         self._assembled_segments_data: Optional[PapiAssembledSegments] = None
 
-        self._horizons_tvt_data: Optional[DataList] = None
-
         self._horizons_data: Optional[DataList] = None
         self._horizons: Optional[ObjectRepository[Horizon]] = None
 
@@ -44,22 +46,38 @@ def to_df(self, get_converted: bool = True) -> InterpretationType:
             'segments': DataFrame(data['segments']),
         }
 
-    def get_assembled_segments_data(self) -> PapiAssembledSegments:
-        if self._assembled_segments_data is None:
-            self._assembled_segments_data = self._papi_client.get_interpretation_assembled_segments_data(
-                interpretation_id=self.uuid
-            )
+    @property
+    def assembled_segments(self):
+        if self._assembled_segments_data is not None:
+            return {
+                'horizons': self._assembled_segments_data['horizons'],
+                'segments': self._assembled_segments_data['segments']
+            }
 
-        return self._assembled_segments_data
+        self._assembled_segments_data = self._papi_client.get_interpretation_assembled_segments_data(
+            interpretation_id=self.uuid
+        )
 
-    def get_horizons_tvt_data(self, md_step: int = 10) -> DataList:
-        if self._horizons_tvt_data is None:
-            self._horizons_tvt_data = self._papi_client.get_horizons_tvt_data(
-                interpretation_id=self.uuid,
-                md_step=md_step
-            )
+        assembled_horizons_data = self._assembled_segments_data['horizons']
+        measure_units = self.well.project.measure_unit
 
-        return self._horizons_tvt_data
+        for horizon in self._get_horizons_data():
+            assembled_horizons_data[horizon['uuid']]['name'] = horizon['name']
+            if measure_units != EMeasureUnits.METER:
+                assembled_horizons_data[horizon['uuid']]['tvd'] = meters_to_feet(
+                    assembled_horizons_data[horizon['uuid']]['tvd']
+                )
+
+        return {
+            'horizons': self._assembled_segments_data['horizons'],
+            'segments': self._assembled_segments_data['segments']
+        }
+
+    def get_tvt_data(self, md_step: int = 1) -> DataList:
+        return self._papi_client.get_interpretation_tvt_data(
+            interpretation_id=self.uuid,
+            md_step=md_step
+        )
 
     @property
     def horizons(self) -> ObjectRepository[Horizon]:
@@ -77,11 +95,6 @@ def _get_horizons_data(self) -> DataList:
         return self._horizons_data
 
     def _get_data(self):
-        assembled_segments = self.get_assembled_segments_data()
-
-        for horizon in self._get_horizons_data():
-            assembled_segments['horizons'][horizon['uuid']]['name'] = horizon['name']
-
         meta = {
             'uuid': self.uuid,
             'name': self.name,
@@ -92,6 +105,6 @@ def _get_data(self):
 
         return {
             'meta': meta,
-            'horizons': assembled_segments['horizons'],
-            'segments': assembled_segments['segments'],
+            'horizons': self.assembled_segments['horizons'],
+            'segments': self.assembled_segments['segments'],
         }

src/rogii_solo/papi/base.py

@@ -321,11 +321,11 @@ def fetch_interpretation_horizons(self,
             headers=headers
         )
 
-    def fetch_horizons_tvt_data(self,
-                                interpretation_id: str,
-                                md_step: int,
-                                headers: Optional[Dict[str, Any]] = None
-                                ):
+    def fetch_interpretation_horizons_data(self,
+                                           interpretation_id: str,
+                                           md_step: int,
+                                           headers: Optional[Dict[str, Any]] = None
+                                           ):
         """
         Fetches calculated by step horizons data
         :param interpretation_id:

src/rogii_solo/papi/client.py

@@ -98,9 +98,9 @@ def get_interpretation_horizons_data(self, interpretation_id: str, **kwargs) ->
             **kwargs
         ))
 
-    def get_horizons_tvt_data(self, interpretation_id: str, **kwargs) -> PapiDataList:
+    def get_interpretation_tvt_data(self, interpretation_id: str, **kwargs) -> PapiDataList:
         return [
-            self.parse_papi_data(tvt_data) for tvt_data in self.fetch_horizons_tvt_data(
+            self.parse_papi_data(tvt_data) for tvt_data in self.fetch_interpretation_horizons_data(
                 interpretation_id=interpretation_id,
                 **kwargs
             )

tests/conftest.py

@@ -16,7 +16,8 @@
     TARGET_LINES_DATA_RESPONSE,
     NESTED_WELLS_DATA_RESPONSE,
     LOGS_DATA_RESPONSE,
-    LOG_POINTS_DATA_RESPONSE
+    LOG_POINTS_DATA_RESPONSE,
+    HORIZONS_TVT_DATA_RESPONSE
 )
 
 
@@ -48,6 +49,10 @@ def fetch_interpretation_assembled_segments(**kwargs):
     return ASSEMBLED_SEGMENTS_DATA_RESPONSE['assembled_segments']
 
 
+def fetch_interpretation_horizons_data(**kwargs):
+    return HORIZONS_TVT_DATA_RESPONSE['content']
+
+
 def fetch_well_target_lines(**kwargs):
     return TARGET_LINES_DATA_RESPONSE
 
@@ -84,6 +89,7 @@ def solo_client():
     solo_client._papi_client.fetch_nested_well_raw_trajectory = fetch_nested_well_raw_trajectory
     solo_client._papi_client.fetch_well_logs = fetch_well_logs
     solo_client._papi_client.fetch_log_points = fetch_log_points
+    solo_client._papi_client.fetch_interpretation_horizons_data = fetch_interpretation_horizons_data
 
     return solo_client