Well log viewer - implement layer system

backend_py/primary/primary/routers/surface/router.py

@@ -74,7 +74,9 @@ async def get_realization_surfaces_metadata(
         surf_meta_task = tg.create_task(access.get_realization_surfaces_metadata_async())
         surf_meta_task.add_done_callback(lambda _: perf_metrics.record_lap_no_reset("get-meta"))
 
-        strat_units_task = tg.create_task(_get_stratigraphic_units_for_case_async(authenticated_user, case_uuid))
+        strat_units_task = tg.create_task(
+            _get_stratigraphic_units_for_strat_column_async(authenticated_user, case_uuid)
+        )
         strat_units_task.add_done_callback(lambda _: perf_metrics.record_lap_no_reset("get-strat"))
 
     perf_metrics.reset_lap_timer()
@@ -106,7 +108,9 @@ async def get_observed_surfaces_metadata(
         surf_meta_task = tg.create_task(access.get_observed_surfaces_metadata_async())
         surf_meta_task.add_done_callback(lambda _: perf_metrics.record_lap_no_reset("get-meta"))
 
-        strat_units_task = tg.create_task(_get_stratigraphic_units_for_case_async(authenticated_user, case_uuid))
+        strat_units_task = tg.create_task(
+            _get_stratigraphic_units_for_strat_column_async(authenticated_user, case_uuid)
+        )
         strat_units_task.add_done_callback(lambda _: perf_metrics.record_lap_no_reset("get-strat"))
 
     perf_metrics.reset_lap_timer()
@@ -314,8 +318,8 @@ async def get_wellbore_stratigraphic_columns(
     return [converters.to_api_stratigraphic_column(col) for col in strat_columns]
 
 
-@router.get("/stratigraphic_units")
-async def get_stratigraphic_units(
+@router.get("/stratigraphic_units_for_case")
+async def get_stratigraphic_units_for_case(
     # fmt:off
     response: Response,
     authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
@@ -324,23 +328,41 @@ async def get_stratigraphic_units(
 ) -> list[schemas.StratigraphicUnit]:
     perf_metrics = ResponsePerfMetrics(response)
 
-    strat_units = await _get_stratigraphic_units_for_case_async(authenticated_user, case_uuid)
+    case_inspector = CaseInspector.from_case_uuid(authenticated_user.get_sumo_access_token(), case_uuid)
+    strat_column_identifier = await case_inspector.get_stratigraphic_column_identifier_async()
+    perf_metrics.record_lap("get-strat-ident")
+
+    strat_units = await _get_stratigraphic_units_for_strat_column_async(authenticated_user, strat_column_identifier)
+    api_strat_units = [converters.to_api_stratigraphic_unit(strat_unit) for strat_unit in strat_units]
+
+    LOGGER.info(f"Got stratigraphic units in: {perf_metrics.to_string()}")
+
+    return api_strat_units
+
+
+@router.get("/stratigraphic_units_for_strat_column")
+async def get_stratigraphic_units_for_strat_column(
+    # fmt:off
+    response: Response,
+    authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
+    strat_column: Annotated[str, Query(description="SMDA stratigraphic column identifier")],
+    # fmt:on
+) -> list[schemas.StratigraphicUnit]:
+    perf_metrics = ResponsePerfMetrics(response)
+
+    strat_units = await _get_stratigraphic_units_for_strat_column_async(authenticated_user, strat_column)
     api_strat_units = [converters.to_api_stratigraphic_unit(strat_unit) for strat_unit in strat_units]
 
     LOGGER.info(f"Got stratigraphic units in: {perf_metrics.to_string()}")
 
     return api_strat_units
 
 
-async def _get_stratigraphic_units_for_case_async(
-    authenticated_user: AuthenticatedUser, case_uuid: str
+async def _get_stratigraphic_units_for_strat_column_async(
+    authenticated_user: AuthenticatedUser, strat_column_identifier: str
 ) -> list[StratigraphicUnit]:
     perf_metrics = PerfMetrics()
 
-    case_inspector = CaseInspector.from_case_uuid(authenticated_user.get_sumo_access_token(), case_uuid)
-    strat_column_identifier = await case_inspector.get_stratigraphic_column_identifier_async()
-    perf_metrics.record_lap("get-strat-ident")
-
     smda_access: SmdaAccess | DrogonSmdaAccess
     if is_drogon_identifier(strat_column_identifier=strat_column_identifier):
         smda_access = DrogonSmdaAccess()

backend_py/primary/primary/routers/well/router.py

@@ -316,14 +316,13 @@ async def get_log_curve_data(
     # Handle DROGON
     if is_drogon_identifier(wellbore_uuid=wellbore_uuid):
         well_access_drogon = DrogonWellAccess(authenticated_user.get_ssdl_access_token())
-        curve_data = await well_access_drogon.get_log_curve_data_async(wellbore_uuid, curve_name)
+        curve_data = await well_access_drogon.get_log_curve_data_async(wellbore_uuid, curve_name, log_name)
 
         return converters.convert_wellbore_log_curve_data_to_schema(curve_data)
 
     if source == schemas.WellLogCurveSourceEnum.SSDL_WELL_LOG:
-        # Note that log name is not used on SSDL; but afaik curve names are not unique across all logs...
         well_access = SsdlWellAccess(authenticated_user.get_ssdl_access_token())
-        log_curve = await well_access.get_log_curve_data_async(wellbore_uuid, curve_name)
+        log_curve = await well_access.get_log_curve_data_async(wellbore_uuid, curve_name, log_name)
 
         return converters.convert_wellbore_log_curve_data_to_schema(log_curve)
 

backend_py/primary/primary/services/ssdl_access/drogon/_drogon_well_data.py

@@ -8,6 +8,8 @@
 
 well_log_headers_2 = [
     types.WellboreLogCurveHeader(curve_name="BS", curve_unit="IN", log_name="DROGON_CONTINUOUS"),
+    types.WellboreLogCurveHeader(curve_name="BS", curve_unit="IN", log_name="DROGON_CONTINUOUS_2"),
+    types.WellboreLogCurveHeader(curve_name="DROGON_COMMENTS", curve_unit="UNITLESS", log_name="DROGON_DISCRETE"),
 ]
 
 
@@ -151,4 +153,61 @@
             (1000, None),
         ],
     ),
+    # Curve name is *not* unique across all logs in a well, since some log runs might present the same data.
+    # This is an example of such a curve.
+    "BS_2": types.WellboreLogCurveData(
+        name="BS",
+        log_name="DROGON_CONTINUOUS_2",
+        index_min=100,
+        index_max=1000,
+        index_unit="m",
+        unit="IN",
+        curve_alias=None,
+        curve_description=None,
+        curve_unit_desc=None,
+        min_curve_value=200,
+        max_curve_value=1000,
+        no_data_value=None,
+        DataPoints=[
+            (100, 100),
+            (150, 200),
+            (250, 200),
+            (300, 300),
+            (350, 300),
+            (400, 400),
+            (450, 400),
+            (500, 500),
+            (550, 600),
+            (600, 600),
+            (650, 700),
+            (700, 700),
+            (750, 800),
+            (800, 800),
+            (850, 900),
+            (900, 900),
+            (950, 600),
+            (1000, 600),
+        ],
+    ),
+    "DROGON_COMMENTS": types.WellboreLogCurveData(
+        name="DROGON_COMMENTS",
+        log_name="DROGON_DISCRETE",
+        index_min=100,
+        index_max=1000,
+        index_unit="m",
+        unit="UNITLESS",
+        curve_alias="TEXT",
+        curve_description=None,
+        curve_unit_desc=None,
+        min_curve_value=None,
+        max_curve_value=None,
+        no_data_value=None,
+        DataPoints=[
+            (150, "High quality"),
+            (200, "Good quality"),
+            (600, "No seal"),
+            (800, "High quality"),
+            (1000, "High quality"),
+        ],
+    ),
 }

backend_py/primary/primary/services/ssdl_access/drogon/drogon_ssdl_access.py

@@ -33,10 +33,15 @@ async def get_log_curve_headers_for_field_async(self, field_uuid: str) -> list[t
         raise NotImplementedError
 
     # pylint: disable=unused-argument
-    async def get_log_curve_data_async(self, wellbore_uuid: str, curve_name: str) -> types.WellboreLogCurveData:
+    async def get_log_curve_data_async(
+        self, wellbore_uuid: str, curve_name: str, log_name: str
+    ) -> types.WellboreLogCurveData:
         if wellbore_uuid == "drogon_vertical":
             return _drogon_well_data.well_log_data_map_1[curve_name]
         if wellbore_uuid == "drogon_horizontal":
-            return _drogon_well_data.well_log_data_map_2[curve_name]
+            for curve in _drogon_well_data.well_log_data_map_2.values():
+                if curve.name == curve_name and curve.log_name == log_name:
+                    return curve
+            raise ValueError(f"No curve {curve_name=} found for log {log_name=}!")
 
         raise ValueError(f"Unexpected drogon well name: {wellbore_uuid=}!")

backend_py/primary/primary/services/ssdl_access/well_access.py

@@ -67,8 +67,13 @@ async def get_log_curve_headers_for_field_async(self, field_uuid: str) -> List[t
             raise InvalidDataError(f"Invalid log curve headers for field {field_uuid}", Service.SSDL) from error
         return result
 
-    async def get_log_curve_data_async(self, wellbore_uuid: str, curve_name: str) -> types.WellboreLogCurveData:
-        params = {"normalized_data": False}
+    async def get_log_curve_data_async(
+        self, wellbore_uuid: str, curve_name: str, log_name: str
+    ) -> types.WellboreLogCurveData:
+        # ! Note: SSDL does not actually take the curve name into account when fetching data, but curve names are not unique across
+        # ! all logs, and there's no documentation about how one should specify the log, when picking curves. For now, I'm including
+        # ! log name as an argument, since we should fix that at some point in the future.
+        params = {"normalized_data": False, "log_name": log_name}
         endpoint = f"WellLog/{wellbore_uuid}/{curve_name}"
         ssdl_data = await ssdl_get_request_async(access_token=self._ssdl_token, endpoint=endpoint, params=params)
         try: