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

@@ -30,6 +30,7 @@
         "@webviz/group-tree-plot": "^1.1.14",
         "@webviz/subsurface-viewer": "^0.25.2",
         "@webviz/well-completions-plot": "^1.4.1",
+        "@webviz/well-log-viewer": "^1.12.7",
         "animate.css": "^4.1.1",
         "axios": "^1.6.5",
         "culori": "^3.2.0",

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/AtomStoreMaster.ts

@@ -1,5 +1,7 @@
 import { WritableAtom, createStore } from "jotai";
 
+import { CurrentModuleInstanceIdAtom } from "./GlobalAtoms";
+
 export type AtomStore = ReturnType<typeof createStore>;
 
 export class AtomStoreMaster {
@@ -16,6 +18,8 @@ export class AtomStoreMaster {
 
     makeAtomStoreForModuleInstance(moduleInstanceId: string) {
         const atomStore = createStore();
+        // Make the module's own id available within each module's store
+        atomStore.set(CurrentModuleInstanceIdAtom, moduleInstanceId);
         this._atomStores.set(moduleInstanceId, atomStore);
 
         const atomStates = Array.from(this._atomStates.entries());

frontend/src/framework/GlobalAtoms.ts

@@ -8,6 +8,10 @@ import { RealizationFilterSet } from "./RealizationFilterSet";
 import { EnsembleRealizationFilterFunction } from "./WorkbenchSession";
 import { atomWithCompare } from "./utils/atomUtils";
 
+/** A module's instance-id. Available in the jotai-store of each module, otherwise null */
+// ? Should this one be moved to `AtomStoreMaster.ts`?
+export const CurrentModuleInstanceIdAtom = atom<string | null>(null);
+
 export const EnsembleSetAtom = atomWithCompare<EnsembleSet>(new EnsembleSet([]), isEqual);
 
 /**

frontend/src/framework/Module.tsx

@@ -15,6 +15,8 @@ import { WorkbenchServices } from "./WorkbenchServices";
 import { WorkbenchSession } from "./WorkbenchSession";
 import { WorkbenchSettings } from "./WorkbenchSettings";
 
+export type OnInstanceUnloadFunc = (instanceId: string) => void;
+
 export enum ModuleCategory {
     MAIN = "main",
     SUB = "sub",
@@ -105,6 +107,7 @@ export interface ModuleOptions {
     description?: string;
     channelDefinitions?: ChannelDefinition[];
     channelReceiverDefinitions?: ChannelReceiverDefinition[];
+    onUnloadInstanceFunc?: OnInstanceUnloadFunc;
 }
 
 export class Module<TInterfaceTypes extends ModuleInterfaceTypes> {
@@ -127,6 +130,7 @@ export class Module<TInterfaceTypes extends ModuleInterfaceTypes> {
     private _workbench: Workbench | null = null;
     private _syncableSettingKeys: SyncSettingKey[];
     private _drawPreviewFunc: DrawPreviewFunc | null;
+    private _onUnloadInstanceFunc: OnInstanceUnloadFunc | null;
     private _description: string | null;
     private _channelDefinitions: ChannelDefinition[] | null;
     private _channelReceiverDefinitions: ChannelReceiverDefinition[] | null;
@@ -143,6 +147,7 @@ export class Module<TInterfaceTypes extends ModuleInterfaceTypes> {
         this.settingsFC = () => <div>Not defined</div>;
         this._syncableSettingKeys = options.syncableSettingKeys ?? [];
         this._drawPreviewFunc = options.drawPreviewFunc ?? null;
+        this._onUnloadInstanceFunc = options.onUnloadInstanceFunc ?? null;
         this._description = options.description ?? null;
         this._channelDefinitions = options.channelDefinitions ?? null;
         this._channelReceiverDefinitions = options.channelReceiverDefinitions ?? null;
@@ -242,6 +247,10 @@ export class Module<TInterfaceTypes extends ModuleInterfaceTypes> {
         return instance;
     }
 
+    onInstanceUnload(instanceId: string) {
+        this._onUnloadInstanceFunc?.(instanceId);
+    }
+
     private setImportState(state: ImportState): void {
         this._importState = state;
         this._moduleInstances.forEach((instance) => {

frontend/src/framework/ModuleInstance.ts

@@ -347,6 +347,10 @@ export class ModuleInstance<TInterfaceTypes extends ModuleInterfaceTypes> {
     getInitialSettings(): InitialSettings | null {
         return this._initialSettings;
     }
+
+    unload() {
+        this._module.onInstanceUnload(this._id);
+    }
 }
 
 export function useModuleInstanceTopicValue<T extends ModuleInstanceTopic>(

frontend/src/framework/ModuleRegistry.ts

@@ -1,5 +1,12 @@
 import { ChannelDefinition, ChannelReceiverDefinition } from "./DataChannelTypes";
-import { InterfaceEffects, Module, ModuleCategory, ModuleDevState, ModuleInterfaceTypes } from "./Module";
+import {
+    InterfaceEffects,
+    Module,
+    ModuleCategory,
+    ModuleDevState,
+    ModuleInterfaceTypes,
+    OnInstanceUnloadFunc,
+} from "./Module";
 import { ModuleDataTagId } from "./ModuleDataTags";
 import { DrawPreviewFunc } from "./Preview";
 import { SyncSettingKey } from "./SyncSettings";
@@ -17,6 +24,7 @@ export type RegisterModuleOptions = {
     channelReceiverDefinitions?: ChannelReceiverDefinition[];
     preview?: DrawPreviewFunc;
     description?: string;
+    onUnloadInstance?: OnInstanceUnloadFunc;
 };
 
 export class ModuleNotFoundError extends Error {
@@ -49,6 +57,7 @@ export class ModuleRegistry {
             channelDefinitions: options.channelDefinitions,
             channelReceiverDefinitions: options.channelReceiverDefinitions,
             drawPreviewFunc: options.preview,
+            onUnloadInstanceFunc: options.onUnloadInstance,
             description: options.description,
         });
         this._registeredModules[options.moduleName] = module;

frontend/src/framework/Workbench.ts

@@ -182,8 +182,12 @@ export class Workbench {
     }
 
     removeModuleInstance(moduleInstanceId: string): void {
-        const manager = this.getModuleInstance(moduleInstanceId)?.getChannelManager();
-        if (manager) {
+        const moduleInstance = this.getModuleInstance(moduleInstanceId);
+
+        if (moduleInstance) {
+            const manager = moduleInstance.getChannelManager();
+
+            moduleInstance.unload();
             manager.unregisterAllChannels();
             manager.unregisterAllReceivers();
         }

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);
+}