@dnv-plant/typescriptpws 1.0.70 → 1.0.73-alpha.1902013

package/tests/radiation-contour-calculation/testCase51.test.ts

@@ -0,0 +1,127 @@
+import { VesselStateCalculation,VesselLeakCalculation} from "../../src/calculations/discharge";
+import { JetFireCalculation} from "../../src/calculations/jetFire";
+import { RadiationContourCalculation} from "../../src/calculations/radiation";
+import {State,Material,MaterialComponent,Vessel,Leak,DischargeParameters,Weather,Substrate,FlammableParameters,FlammableOutputConfig,Transect,LocalPosition,} from "../../src/entities";
+import {AtmosphericStabilityClass,ResultCode,Resolution,TimeVaryingOption,VesselShape, ContourType} from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+  
+  describe("RadiationContourCalculation Integration", () => {
+    test("should perform full pipeline and produce expected flame and contour data", async () => {
+      // Initial parameters
+      const materialName = "METHANE";
+      const stateTemperature = 280.0;
+      const statePressure = 1.0e6;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 3.0;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+      const leakHoleHeightFraction = 0.5;
+      const liquidFillFraction = 0.0;
+      const windSpeed = 2.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+      const timeOfInterest = 3600.0;
+      const radiationResolution = Resolution.MEDIUM;
+  
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+      });
+  
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      console.log("Running vesselStateCalculation...");
+      let resultCode = await vesselStateCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState,
+        material: vesselStateCalc.material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        location: new LocalPosition(),
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        liquidFillFractionByVolume: liquidFillFraction,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption: timeVaryingOption,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+      console.log("Running vesselLeakCalculation...");
+      resultCode = await vesselLeakCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({ windSpeed, stabilityClass });
+      const substrate = new Substrate();
+      const flammableParams = new FlammableParameters({ timeOfInterest });
+  
+      const jetFireCalc = new JetFireCalculation(
+        vesselLeakCalc.exitMaterial!,
+        vesselLeakCalc.dischargeRecords!,
+        vesselLeakCalc.dischargeRecords!.length,
+        vesselLeakCalc.dischargeResult!,
+        weather,
+        substrate,
+        flammableParams
+      );
+      console.log("Running jetFireCalculation...");
+      resultCode = await jetFireCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [0, 1, 2].map((z) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({x: 0.0, y: 0.0, z: z}),
+          transect: new Transect({
+            transectStartPoint: new LocalPosition(),
+            transectEndPoint: new LocalPosition(),
+          }),
+          radiationResolution,
+          contourType: ContourType.SIDEVIEW
+        });
+      });
+  
+      const radiationContourCalc = new RadiationContourCalculation(
+        jetFireCalc.flameResult!,
+        jetFireCalc.flameRecords!,
+        jetFireCalc.flameRecords!.length,
+        weather,
+        jetFireCalc.flammableParameters,
+        flammableOutputConfigs[0]
+      );
+  
+      console.log("Running radiationContourCalculation...");
+      resultCode = await radiationContourCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Regression tests
+      expect(radiationContourCalc.contourPoints!.length).toBe(182);
+  
+      const xCoord = radiationContourCalc.contourPoints!.at(-2)?.x!;
+      expect(Math.abs((xCoord - 0.3857580731049737) / 0.3857580731049737)).toBeLessThan(1e-3);
+  
+      const flameLength = radiationContourCalc.flameResult.flameLength!;
+      expect(Math.abs((flameLength - 33.750426875730376) / 33.750426875730376)).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: radiation_contour_calculation (${radiationContourCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/radiation-contour-calculation/testCase52.test.ts

@@ -0,0 +1,126 @@
+import { VesselStateCalculation,VesselLeakCalculation} from "../../src/calculations/discharge";
+import { JetFireCalculation} from "../../src/calculations/jetFire";
+import { RadiationContourCalculation} from "../../src/calculations/radiation";
+import {State,Material,MaterialComponent,Vessel,Leak,DischargeParameters,Weather,Substrate,FlammableParameters,FlammableOutputConfig,Transect,LocalPosition,} from "../../src/entities";
+import {AtmosphericStabilityClass,ResultCode,Resolution,TimeVaryingOption,VesselShape, ContourType} from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+  
+  describe("RadiationContourCalculation Integration - Test Case 52", () => {
+    test("should produce correct radiation contour results for N-BUTANE", async () => {
+      const materialName = "N-BUTANE";
+      const stateTemperature = 220.0;
+      const statePressure = 1.0e6;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 3.0;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+      const leakHoleHeightFraction = 0.5;
+      const liquidFillFraction = 0.5;
+      const windSpeed = 2.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+      const timeOfInterest = 2600.0;
+      const radiationResolution = Resolution.HIGH;
+  
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+      });
+  
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      console.log("Running vesselStateCalculation...");
+      let resultCode = await vesselStateCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState,
+        material: vesselStateCalc.material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        location: new LocalPosition(),
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        liquidFillFractionByVolume: liquidFillFraction,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption: timeVaryingOption,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+      console.log("Running vesselLeakCalculation...");
+      resultCode = await vesselLeakCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({ windSpeed, stabilityClass });
+      const substrate = new Substrate();
+      const flammableParams = new FlammableParameters({ timeOfInterest });
+  
+      const jetFireCalc = new JetFireCalculation(
+        vesselLeakCalc.exitMaterial!,
+        vesselLeakCalc.dischargeRecords!,
+        vesselLeakCalc.dischargeRecords!.length,
+        vesselLeakCalc.dischargeResult!,
+        weather,
+        substrate,
+        flammableParams
+      );
+      console.log("Running jetFireCalculation...");
+      resultCode = await jetFireCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [2.0, 4.0, 5.0].map((z) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({ x: 0.0, y: 0.0, z }),
+          transect: new Transect({
+            transectStartPoint: new LocalPosition(),
+            transectEndPoint: new LocalPosition(),
+          }),
+          radiationResolution,
+          contourType: ContourType.SIDEVIEW
+        });
+      });
+  
+      const radiationContourCalc = new RadiationContourCalculation(
+        jetFireCalc.flameResult!,
+        jetFireCalc.flameRecords!,
+        jetFireCalc.flameRecords!.length,
+        weather,
+        jetFireCalc.flammableParameters,
+        flammableOutputConfigs[0]
+      );
+      
+      console.log("Running radiationContourCalculation...");
+      resultCode = await radiationContourCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Regression checks
+      expect(radiationContourCalc.contourPoints!.length).toBe(360);
+  
+      const xCoord = radiationContourCalc.contourPoints!.at(-2)?.x!;
+      expect(Math.abs((xCoord - (-42.092296747468765)) / -42.092296747468765)).toBeLessThan(1e-3);
+  
+      const flameLength = radiationContourCalc.flameResult.flameLength!;
+      expect(Math.abs((flameLength - 138.4978616734956) / 138.4978616734956)).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: radiation_contour_calculation (${radiationContourCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/radiation-contour-calculation/testCase53.test.ts

@@ -0,0 +1,126 @@
+import { VesselStateCalculation,VesselLeakCalculation} from "../../src/calculations/discharge";
+import { JetFireCalculation} from "../../src/calculations/jetFire";
+import { RadiationContourCalculation} from "../../src/calculations/radiation";
+import {State,Material,MaterialComponent,Vessel,Leak,DischargeParameters,Weather,Substrate,FlammableParameters,FlammableOutputConfig,Transect,LocalPosition,} from "../../src/entities";
+import {AtmosphericStabilityClass,ResultCode,Resolution,TimeVaryingOption,VesselShape, ContourType} from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+  
+  describe("RadiationContourCalculation Integration - Test Case 53", () => {
+    test("should produce correct radiation contour results for PROPANE", async () => {
+      const materialName = "PROPANE";
+      const stateTemperature = 290.0;
+      const statePressure = 5.0e5;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 3.0;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+      const leakHoleHeightFraction = 0.3;
+      const liquidFillFraction = 0.4;
+      const windSpeed = 2.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+      const timeOfInterest = 2600.0;
+      const radiationResolution = Resolution.LOW;
+  
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+      });
+  
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      console.log("Running vesselStateCalculation...");
+      let resultCode = await vesselStateCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState,
+        material: vesselStateCalc.material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        location: new LocalPosition(),
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        liquidFillFractionByVolume: liquidFillFraction,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption: timeVaryingOption,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+      console.log("Running vesselLeakCalculation...");
+      resultCode = await vesselLeakCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({ windSpeed, stabilityClass });
+      const substrate = new Substrate();
+      const flammableParams = new FlammableParameters({ timeOfInterest });
+  
+      const jetFireCalc = new JetFireCalculation(
+        vesselLeakCalc.exitMaterial!,
+        vesselLeakCalc.dischargeRecords!,
+        vesselLeakCalc.dischargeRecords!.length,
+        vesselLeakCalc.dischargeResult!,
+        weather,
+        substrate,
+        flammableParams
+      );
+      console.log("Running jetFireCalculation...");
+      resultCode = await jetFireCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [2.0, 3.0, 6.0].map((z) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({ x: 0.0, y: 0.0, z }),
+          transect: new Transect({
+            transectStartPoint: new LocalPosition(),
+            transectEndPoint: new LocalPosition(),
+          }),
+          radiationResolution,
+          contourType: ContourType.FOOTPRINT
+        });
+      });
+  
+      const radiationContourCalc = new RadiationContourCalculation(
+        jetFireCalc.flameResult!,
+        jetFireCalc.flameRecords!,
+        jetFireCalc.flameRecords!.length,
+        weather,
+        jetFireCalc.flammableParameters,
+        flammableOutputConfigs[0]
+      );
+  
+      console.log("Running radiationContourCalculation...");
+      resultCode = await radiationContourCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Regression checks
+      expect(radiationContourCalc.contourPoints!.length).toBe(99);
+  
+      const xCoord = radiationContourCalc.contourPoints!.at(-2)?.x!;
+      expect(Math.abs((xCoord - 7.78359999167067) / 7.78359999167067)).toBeLessThan(1e-3);
+  
+      const flameLength = radiationContourCalc.flameResult.flameLength!;
+      expect(Math.abs((flameLength - 31.712372512867706) / 31.712372512867706)).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: radiation_contour_calculation (${radiationContourCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/radiation-contour-calculation/testCase54.test.ts

@@ -0,0 +1,131 @@
+import { VesselStateCalculation,VesselLeakCalculation} from "../../src/calculations/discharge";
+import { JetFireCalculation} from "../../src/calculations/jetFire";
+import { RadiationContourCalculation} from "../../src/calculations/radiation";
+import {State,Material,MaterialComponent,Vessel,Leak,DischargeParameters,Weather,Substrate,FlammableParameters,FlammableOutputConfig,Transect,LocalPosition,} from "../../src/entities";
+import {AtmosphericStabilityClass,ResultCode,Resolution,TimeVaryingOption,VesselShape, ContourType} from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+  describe("RadiationContourCalculation Integration - Test Case 54", () => {
+    test("should produce correct radiation contour results for ETHANE_METHANE_HYDROGEN", async () => {
+      const materialName = "ETHANE_METHANE_HYDROGEN";
+      const stateTemperature = 360.0;
+      const statePressure = 3.0e6;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 3.0;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+      const leakHoleHeightFraction = 0.3;
+      const liquidFillFraction = 0.4;
+      const windSpeed = 2.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+      const timeOfInterest = 2600.0;
+      const radiationResolution = Resolution.HIGH;
+  
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+  
+      const material = new Material({
+        name: materialName,
+        components: [
+          new MaterialComponent({ name: "ETHANE", moleFraction: 0.5 }),
+          new MaterialComponent({ name: "METHANE", moleFraction: 0.3 }),
+          new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.2 }),
+        ],
+        componentCount: 3,
+      });
+  
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      console.log("Running vesselStateCalculation...");
+      let resultCode = await vesselStateCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState,
+        material: vesselStateCalc.material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        location: new LocalPosition(),
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        liquidFillFractionByVolume: liquidFillFraction,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption: timeVaryingOption,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+      console.log("Running vesselLeakCalculation...");
+      resultCode = await vesselLeakCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({ windSpeed, stabilityClass });
+      const substrate = new Substrate();
+      const flammableParams = new FlammableParameters({ timeOfInterest });
+  
+      const jetFireCalc = new JetFireCalculation(
+        vesselLeakCalc.exitMaterial!,
+        vesselLeakCalc.dischargeRecords!,
+        vesselLeakCalc.dischargeRecords!.length,
+        vesselLeakCalc.dischargeResult!,
+        weather,
+        substrate,
+        flammableParams
+      );
+      console.log("Running jetFireCalculation...");
+      resultCode = await jetFireCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [2.0, 5.0, 6.0].map((z) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({ x: 0.0, y: 0.0, z }),
+          transect: new Transect({
+            transectStartPoint: new LocalPosition(),
+            transectEndPoint: new LocalPosition(),
+          }),
+          radiationResolution,
+          contourType: ContourType.FOOTPRINT
+        });
+      });
+  
+      const radiationContourCalc = new RadiationContourCalculation(
+        jetFireCalc.flameResult!,
+        jetFireCalc.flameRecords!,
+        jetFireCalc.flameRecords!.length,
+        weather,
+        jetFireCalc.flammableParameters,
+        flammableOutputConfigs[0]
+      );
+  
+      console.log("Running radiationContourCalculation...");
+      resultCode = await radiationContourCalc.run();
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Regression checks
+      expect(radiationContourCalc.contourPoints!.length).toBe(463);
+  
+      const xCoord = radiationContourCalc.contourPoints!.at(-2)?.x!;
+      expect(Math.abs((xCoord - 26.0094272142727627) / 26.009427214272762)).toBeLessThan(1e-3);
+  
+      const flameLength = radiationContourCalc.flameResult.flameLength!;
+      expect(Math.abs((flameLength - 52.44271020259119) / 52.44271020259119)).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: radiation_contour_calculation (${radiationContourCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/relief-valve-min-temperature-calculation/testCase140.test.ts

@@ -0,0 +1,49 @@
+import { ReliefValveMinTemperatureCalculation } from "../../src/calculations/utilities";
+import { Material, MaterialComponent } from "../../src/entities";
+import { ResultCode } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("ReliefValveMinTemperatureCalculation", () => {
+  test("should correctly compute minimum temperature for PROPANE at 1e6 Pa", async () => {
+    const material = new Material({
+      name: "PROPANE",
+      components: [
+        new MaterialComponent({
+          name: "PROPANE",
+          moleFraction: 1.0,
+        }),
+      ],
+    });
+
+    const pressure = 1e6;
+
+    const calc = new ReliefValveMinTemperatureCalculation(material, pressure);
+
+    console.log("Running relief_valve_min_temperature_calculation...");
+    const resultCode = await calc.run();
+
+    if (calc.messages.length > 0) {
+      console.log("Messages:");
+      calc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedMinTemp = 300.04391253626204;
+    const actualMinTemp = calc.minTemperature!;
+    const tolerance = 1e-3;
+
+    expect(Math.abs((actualMinTemp - expectedMinTemp) / expectedMinTemp)).toBeLessThan(tolerance);
+
+    console.log(
+      `SUCCESS: relief_valve_min_temperature_calculation (${calc.calculationElapsedTime}ms)`
+    );
+  });
+});

package/tests/set-mixing-layer-height/testCase100.test.ts

@@ -0,0 +1,36 @@
+import { SetMixingLayerHeightCalculation } from "../../src/calculations/utilities";
+import { Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("SetMixingLayerHeightCalculation", () => {
+  test("should correctly set mixing layer height based on stability class and wind speed", async () => {
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+    });
+
+    const calc = new SetMixingLayerHeightCalculation(weather);
+
+    console.log("Running set_mixing_layer_height_calculation...");
+    const resultCode = await calc.run();
+    calc.messages.forEach((msg) => console.log(msg));
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedMixingLayerHeight = 1300.0;
+    const actualMixingLayerHeight = calc.updatedWeather!.mixingLayerHeight!;
+    expect(actualMixingLayerHeight).toBeCloseTo(expectedMixingLayerHeight, 6);
+
+    console.log(
+      `SUCCESS: set_mixing_layer_height_calculation (${calc.calculationElapsedTime}ms)`
+    );
+  });
+});

package/tests/set-mixing-layer-height/testCase101.test.ts

@@ -0,0 +1,36 @@
+import { SetMixingLayerHeightCalculation } from "../../src/calculations/utilities";
+import { Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("SetMixingLayerHeightCalculation", () => {
+  test("should correctly set mixing layer height for stability class D and wind speed 5.0", async () => {
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+    });
+
+    const calc = new SetMixingLayerHeightCalculation(weather);
+
+    console.log("Running set_mixing_layer_height_calculation...");
+    const resultCode = await calc.run();
+    calc.messages.forEach((msg) => console.log(msg));
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedMixingLayerHeight = 800.0;
+    const actualMixingLayerHeight = calc.updatedWeather!.mixingLayerHeight!;
+    expect(actualMixingLayerHeight).toBeCloseTo(expectedMixingLayerHeight, 6);
+
+    console.log(
+      `SUCCESS: set_mixing_layer_height_calculation (${calc.calculationElapsedTime}ms)`
+    );
+  });
+});

package/tests/set-mixing-layer-height/testCase102.test.ts

@@ -0,0 +1,36 @@
+import { SetMixingLayerHeightCalculation } from "../../src/calculations/utilities";
+import { Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("SetMixingLayerHeightCalculation", () => {
+  test("should correctly set mixing layer height for stability class F and wind speed 5.0", async () => {
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+    });
+
+    const calc = new SetMixingLayerHeightCalculation(weather);
+
+    console.log("Running set_mixing_layer_height_calculation...");
+    const resultCode = await calc.run();
+    calc.messages.forEach((msg) => console.log(msg));
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedMixingLayerHeight = 100.0;
+    const actualMixingLayerHeight = calc.updatedWeather!.mixingLayerHeight!;
+    expect(actualMixingLayerHeight).toBeCloseTo(expectedMixingLayerHeight, 6);
+
+    console.log(
+      `SUCCESS: set_mixing_layer_height_calculation (${calc.calculationElapsedTime}ms)`
+    );
+  });
+});