Implement Well Log Viewer Module

backend_py/primary/primary/routers/well/converters.py

@@ -120,6 +120,9 @@ def convert_wellbore_perforation_to_schema(
 def convert_wellbore_log_curve_header_to_schema(
     wellbore_log_curve_header: WellboreLogCurveHeader,
 ) -> schemas.WellboreLogCurveHeader:
+    if wellbore_log_curve_header.log_name is None:
+        raise AttributeError("Missing log name is not allowed")
+
     return schemas.WellboreLogCurveHeader(
         logName=wellbore_log_curve_header.log_name,
         curveName=wellbore_log_curve_header.curve_name,
@@ -131,6 +134,9 @@ def convert_wellbore_log_curve_data_to_schema(
     wellbore_log_curve_data: WellboreLogCurveData,
 ) -> schemas.WellboreLogCurveData:
     return schemas.WellboreLogCurveData(
+        name=wellbore_log_curve_data.name,
+        unit=wellbore_log_curve_data.unit,
+        curveUnitDesc=wellbore_log_curve_data.curve_unit_desc,
         indexMin=wellbore_log_curve_data.index_min,
         indexMax=wellbore_log_curve_data.index_max,
         minCurveValue=wellbore_log_curve_data.min_curve_value,

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

@@ -216,6 +216,8 @@ async def get_wellbore_log_curve_headers(
     return [
         converters.convert_wellbore_log_curve_header_to_schema(wellbore_log_curve_header)
         for wellbore_log_curve_header in wellbore_log_curve_headers
+        # Missing log name implies garbage data, so we simply drop them
+        if wellbore_log_curve_header.log_name is not None
     ]
 
 

backend_py/primary/primary/routers/well/schemas.py

@@ -103,16 +103,19 @@ class WellborePerforation(BaseModel):
 class WellboreLogCurveHeader(BaseModel):
     logName: str
     curveName: str
-    curveUnit: str
+    curveUnit: str | None
 
 
 class WellboreLogCurveData(BaseModel):
+    name: str
     indexMin: float
     indexMax: float
     minCurveValue: float
     maxCurveValue: float
-    dataPoints: list[list[float | None]]
-    curveAlias: str
-    curveDescription: str
+    curveAlias: str | None
+    curveDescription: str | None
     indexUnit: str
-    noDataValue: float
+    noDataValue: float | None
+    unit: str
+    curveUnitDesc: str | None
+    dataPoints: list[list[float | None]]

backend_py/primary/primary/services/ssdl_access/types.py

@@ -1,3 +1,4 @@
+from typing import Any
 from pydantic import BaseModel
 
 
@@ -34,18 +35,33 @@ class WellborePerforation(BaseModel):
 
 
 class WellboreLogCurveHeader(BaseModel):
-    log_name: str
+    log_name: str | None
     curve_name: str
-    curve_unit: str
+    curve_unit: str | None
+
+    # Defining a hash-function to facilitate usage in Sets
+    def __hash__(self) -> int:
+        # No globally unique field, but curve-name should be unique (per wellbore)
+        return hash(self.curve_name + (self.log_name or "N/A"))
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, WellboreLogCurveHeader):
+            # delegate to the other item in the comparison
+            return NotImplemented
+
+        return (self.curve_name, self.log_name) == (other.curve_name, other.log_name)
 
 
 class WellboreLogCurveData(BaseModel):
+    name: str
     index_min: float
     index_max: float
     min_curve_value: float
     max_curve_value: float
-    DataPoints: list[list[float | None]]
-    curve_alias: str
-    curve_description: str
+    curve_alias: str | None
+    curve_description: str | None
     index_unit: str
-    no_data_value: float
+    no_data_value: float | None
+    unit: str
+    curve_unit_desc: str | None
+    DataPoints: list[list[float | None]]

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

@@ -51,10 +51,12 @@ async def get_log_curve_headers_for_wellbore(self, wellbore_uuid: str) -> List[t
         endpoint = f"WellLog/{wellbore_uuid}"
         ssdl_data = await fetch_from_ssdl(access_token=self._ssdl_token, endpoint=endpoint, params=None)
         try:
-            result = [types.WellboreLogCurveHeader.model_validate(log_curve) for log_curve in ssdl_data]
+            # This endpoint is a bit weird, and MIGHT return duplicates which, as far as I can tell, are the exact same. Using a set to drop duplicates. See data model for comparator
+            result_set = {types.WellboreLogCurveHeader.model_validate(log_curve) for log_curve in ssdl_data}
+
         except ValidationError as error:
             raise InvalidDataError(f"Invalid log curve headers for wellbore {wellbore_uuid}", Service.SSDL) from error
-        return result
+        return list(result_set)
 
     async def get_log_curve_headers_for_field(self, field_uuid: str) -> List[types.WellboreLogCurveHeader]:
         endpoint = f"WellLog/field/{field_uuid}"

frontend/package.json

@@ -29,6 +29,7 @@
         "@types/geojson": "^7946.0.14",
         "@webviz/group-tree-plot": "^1.1.14",
         "@webviz/subsurface-viewer": "^0.25.2",
+        "@webviz/well-log-viewer": "^1.12.7",
         "@webviz/well-completions-plot": "^1.5.11",
         "animate.css": "^4.1.1",
         "axios": "^1.6.5",

frontend/src/api/models/WellboreLogCurveData.ts

@@ -3,14 +3,17 @@
 /* tslint:disable */
 /* eslint-disable */
 export type WellboreLogCurveData = {
+    name: string;
     indexMin: number;
     indexMax: number;
     minCurveValue: number;
     maxCurveValue: number;
-    dataPoints: Array<Array<(number | null)>>;
-    curveAlias: string;
-    curveDescription: string;
+    curveAlias: (string | null);
+    curveDescription: (string | null);
     indexUnit: string;
-    noDataValue: number;
+    noDataValue: (number | null);
+    unit: string;
+    curveUnitDesc: (string | null);
+    dataPoints: Array<Array<(number | null)>>;
 };
 

frontend/src/api/models/WellboreLogCurveHeader.ts

@@ -5,6 +5,6 @@
 export type WellboreLogCurveHeader = {
     logName: string;
     curveName: string;
-    curveUnit: string;
+    curveUnit: (string | null);
 };
 

frontend/src/framework/utils/arrays.ts

@@ -0,0 +1,14 @@
+/**
+ * Util method to do an immutable item move in an array
+ * @param array The array to move items in
+ * @param from The index of the first item being moved
+ * @param to The index the item(s) should be moved to
+ * @param moveAmt The amount of items (from the start-index) that should be moved
+ * @returns A copy of the original array, with it's items moved accordingly
+ */
+export function arrayMove<t>(array: t[], from: number, to: number, moveAmt = 1): t[] {
+    const newArrray = [...array];
+    const movedItems = newArrray.splice(from, moveAmt);
+
+    return newArrray.toSpliced(to, 0, ...movedItems);
+}

frontend/src/framework/utils/atomUtils.ts

@@ -1,3 +1,4 @@
+import { CurrentModuleInstanceIdAtom } from "@framework/GlobalAtoms";
 import { DefaultError, QueryClient, QueryKey, QueryObserverOptions, QueryObserverResult } from "@tanstack/query-core";
 
 import { Atom, Getter, atom } from "jotai";
@@ -57,3 +58,54 @@ export function atomWithQueries<
         return results as TCombinedResult;
     });
 }
+
+/**
+ * Creates an writeable atom that persists it's value in localstorage, but keeps it unique per module instance. **Note: must only be used within a module instances own store**
+ * @param storageKey Prefix for the key. Should be unique among a module's atoms. Actual storage key will be: `<prefix>:<moduleInstanceId>`
+ * @param initialValue Initial atom value
+ * @returns A get/set atom
+ */
+export function atomWithModuleInstanceStorage<T>(storageKey: string, initialValue: T) {
+    // simple atom, needed to trigger new lookups
+    const instanceValueAtom = atom<T | null>(null);
+
+    return atom<T, [T], void>(
+        (get) => {
+            const instanceId = getIntanceId(get);
+            const fullStorageKey = makeInstanceStorageKey(instanceId, storageKey);
+            const instanceValue = get(instanceValueAtom);
+            const storedValue = localStorage.getItem(fullStorageKey);
+
+            if (instanceValue !== null) return instanceValue;
+            else if (storedValue !== null) return JSON.parse(storedValue);
+            else return initialValue;
+        },
+        (get, set, newVal: T) => {
+            const instanceId = getIntanceId(get);
+            const fullStorageKey = makeInstanceStorageKey(instanceId, storageKey);
+
+            localStorage.setItem(fullStorageKey, JSON.stringify(newVal));
+            set(instanceValueAtom, newVal);
+        }
+    );
+}
+
+export function clearModuleInstanceStorage(instanceId: string, key: string) {
+    const fullKey = makeInstanceStorageKey(instanceId, key);
+    localStorage.removeItem(fullKey);
+}
+
+function makeInstanceStorageKey(instanceId: string, key: string): string {
+    // ! Be mindful about changing this; existing stored values will dissapear!
+    return `${key}:${instanceId}`;
+}
+
+function getIntanceId(get: Getter): string {
+    const id = get(CurrentModuleInstanceIdAtom);
+
+    if (id === null) {
+        throw new Error("Module instance not set. Make sure this atom is only used within a module storage");
+    }
+
+    return id;
+}