Renaming/refactoring

rubenthoms · Oct 9, 2023 · 739a2da · 739a2da
1 parent 3af6571
commit 739a2da
Show file tree

Hide file tree

Showing 5 changed files with 60 additions and 62 deletions.
diff --git a/frontend/src/framework/Ensemble.ts b/frontend/src/framework/Ensemble.ts
@@ -1,12 +1,12 @@
 import { EnsembleIdent } from "./EnsembleIdent";
-import { EnsembleParameters, Parameter } from "./EnsembleParameters";
+import { EnsembleParameterSet, Parameter } from "./EnsembleParameterSet";
 import { EnsembleSensitivities, Sensitivity } from "./EnsembleSensitivities";
 
 export class Ensemble {
     private _ensembleIdent: EnsembleIdent;
     private _caseName: string;
     private _realizationsArr: number[];
-    private _parameters: EnsembleParameters;
+    private _parameterSet: EnsembleParameterSet;
     private _sensitivities: EnsembleSensitivities | null;
 
     constructor(
@@ -20,7 +20,7 @@ export class Ensemble {
         this._ensembleIdent = new EnsembleIdent(caseUuid, ensembleName);
         this._caseName = caseName;
         this._realizationsArr = Array.from(realizationsArr).sort((a, b) => a - b);
-        this._parameters = new EnsembleParameters(parameterArr);
+        this._parameterSet = new EnsembleParameterSet(parameterArr);
 
         this._sensitivities = null;
         if (sensitivityArr && sensitivityArr.length > 0) {
@@ -64,8 +64,8 @@ export class Ensemble {
         return this._realizationsArr[this._realizationsArr.length - 1];
     }
 
-    getParameters(): EnsembleParameters {
-        return this._parameters;
+    getParameterSet(): EnsembleParameterSet {
+        return this._parameterSet;
     }
 
     getSensitivities(): EnsembleSensitivities | null {

diff --git a/frontend/src/framework/EnsembleParameters.ts → ...end/src/framework/EnsembleParameterSet.ts b/frontend/src/framework/EnsembleParameters.ts → ...end/src/framework/EnsembleParameterSet.ts
@@ -1,5 +1,7 @@
 import { MinMax } from "@lib/utils/MinMax";
 
+import { ParameterIdent } from "./ParameterIdent";
+
 export enum ParameterType {
     CONTINUOUS,
     DISCRETE,
@@ -28,52 +30,7 @@ export type DiscreteParameter = {
 
 export type Parameter = ContinuousParameter | DiscreteParameter;
 
-export class ParameterIdent {
-    readonly name: string;
-    readonly groupName: string | null;
-
-    constructor(name: string, groupName: string | null) {
-        this.name = name;
-        this.groupName = groupName;
-    }
-
-    static fromNameAndGroup(name: string, groupName: string | null): ParameterIdent {
-        return new ParameterIdent(name, groupName);
-    }
-
-    static fromString(paramIdentString: string): ParameterIdent {
-        const parts = paramIdentString.split("~@@~");
-        if (parts.length === 1) {
-            return new ParameterIdent(parts[0], null);
-        }
-        if (parts.length === 2) {
-            return new ParameterIdent(parts[0], parts[1]);
-        } 
-
-        throw new Error(`Invalid parameter ident string: ${paramIdentString}`);
-    }
-
-    toString(): string {
-        if (this.groupName) {
-            return `${this.name}~@@~${this.groupName}`;
-        } else {
-            return this.name;
-        }
-    }
-
-    equals(otherIdent: ParameterIdent | null): boolean {
-        if (!otherIdent) {
-            return false;
-        }
-        if (otherIdent === this) {
-            return true;
-        }
-
-        return this.name === otherIdent.name && this.groupName === otherIdent.groupName;
-    }
-}
-
-export class EnsembleParameters {
+export class EnsembleParameterSet {
     private _parameterArr: Parameter[];
 
     constructor(parameterArr: Parameter[]) {

diff --git a/frontend/src/framework/ParameterIdent.ts b/frontend/src/framework/ParameterIdent.ts
@@ -0,0 +1,44 @@
+export class ParameterIdent {
+    readonly name: string;
+    readonly groupName: string | null;
+
+    constructor(name: string, groupName: string | null) {
+        this.name = name;
+        this.groupName = groupName;
+    }
+
+    static fromNameAndGroup(name: string, groupName: string | null): ParameterIdent {
+        return new ParameterIdent(name, groupName);
+    }
+
+    static fromString(paramIdentString: string): ParameterIdent {
+        const parts = paramIdentString.split("~@@~");
+        if (parts.length === 1) {
+            return new ParameterIdent(parts[0], null);
+        }
+        if (parts.length === 2) {
+            return new ParameterIdent(parts[0], parts[1]);
+        }
+
+        throw new Error(`Invalid parameter ident string: ${paramIdentString}`);
+    }
+
+    toString(): string {
+        if (this.groupName) {
+            return `${this.name}~@@~${this.groupName}`;
+        } else {
+            return this.name;
+        }
+    }
+
+    equals(otherIdent: ParameterIdent | null): boolean {
+        if (!otherIdent) {
+            return false;
+        }
+        if (otherIdent === this) {
+            return true;
+        }
+
+        return this.name === otherIdent.name && this.groupName === otherIdent.groupName;
+    }
+}
diff --git a/frontend/src/framework/internal/EnsembleSetLoader.ts b/frontend/src/framework/internal/EnsembleSetLoader.ts
@@ -4,7 +4,7 @@ import { QueryClient } from "@tanstack/react-query";
 
 import { Ensemble } from "../Ensemble";
 import { EnsembleIdent } from "../EnsembleIdent";
-import { Parameter, ParameterType, ContinuousParameter, DiscreteParameter } from "../EnsembleParameters";
+import { ContinuousParameter, DiscreteParameter, Parameter, ParameterType } from "../EnsembleParameterSet";
 import { Sensitivity, SensitivityCase } from "../EnsembleSensitivities";
 import { EnsembleSet } from "../EnsembleSet";
 
@@ -141,8 +141,7 @@ function buildParameterArrFromApiResponse(apiParameterArr: EnsembleParameter_api
                 values: apiPar.values as number[],
             };
             retParameterArr.push(retPar);
-        }
-        else {
+        } else {
             const retPar: DiscreteParameter = {
                 type: ParameterType.DISCRETE,
                 name: apiPar.name,

diff --git a/frontend/tests/unit-tests/EnsembleParameters.test.ts b/frontend/tests/unit-tests/EnsembleParameters.test.ts
@@ -1,4 +1,4 @@
-import { EnsembleParameters, Parameter, ParameterIdent, ParameterType } from "@framework/EnsembleParameters";
+import { EnsembleParameterSet, Parameter, ParameterIdent, ParameterType } from "@framework/EnsembleParameters";
 import { MinMax } from "@lib/utils/MinMax";
 
 // prettier-ignore
@@ -12,10 +12,9 @@ const PARAM_ARR: Parameter[] = [
     {type: ParameterType.DISCRETE, name: "dparam_B", groupName: null, description: "descB", isConstant: false, realizations: [1,2,3], values: ["A", "B", "C"]},
 ];
 
-
 describe("EnsembleParameters tests", () => {
     test("Get list of parameter idents", () => {
-        const ensParams = new EnsembleParameters(PARAM_ARR);
+        const ensParams = new EnsembleParameterSet(PARAM_ARR);
         {
             const allIdents = ensParams.getParameterIdents(null);
             expect(allIdents.length).toEqual(6);
@@ -43,7 +42,7 @@ describe("EnsembleParameters tests", () => {
     });
 
     test("Check for parameter existence", () => {
-        const ensParams = new EnsembleParameters(PARAM_ARR);
+        const ensParams = new EnsembleParameterSet(PARAM_ARR);
 
         expect(ensParams.hasParameter(ParameterIdent.fromNameAndGroup("cparam_10", null))).toBe(true);
         expect(ensParams.hasParameter(ParameterIdent.fromNameAndGroup("cparam_50", "grp1"))).toBe(true);
@@ -56,7 +55,7 @@ describe("EnsembleParameters tests", () => {
     });
 
     test("Get parameters", () => {
-        const ensParams = new EnsembleParameters(PARAM_ARR);
+        const ensParams = new EnsembleParameterSet(PARAM_ARR);
         {
             const par = ensParams.getParameter(ParameterIdent.fromNameAndGroup("cparam_10", null));
             expect(par.type).toEqual(ParameterType.CONTINUOUS);
@@ -81,12 +80,12 @@ describe("EnsembleParameters tests", () => {
     });
 
     test("Check that getting non-existing parameter throws", () => {
-        const ensParams = new EnsembleParameters(PARAM_ARR);
+        const ensParams = new EnsembleParameterSet(PARAM_ARR);
         expect(() => ensParams.getParameter(ParameterIdent.fromNameAndGroup("someBogusName", null))).toThrow();
     });
 
     test("Test getting min/max values for continuous parameter", () => {
-        const ensParams = new EnsembleParameters(PARAM_ARR);
+        const ensParams = new EnsembleParameterSet(PARAM_ARR);
         {
             const minMax = ensParams.getContinuousParameterMinMax(ParameterIdent.fromNameAndGroup("cparam_10", null));
             expect(minMax).toEqual(new MinMax(11, 19));
@@ -98,7 +97,6 @@ describe("EnsembleParameters tests", () => {
     });
 });
 
-
 describe("ParameterIdent tests", () => {
     test("Conversion to/from string", () => {
         {