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

package/tests/fireball-calculation/testCase89.test.ts

@@ -0,0 +1,151 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation, } from "../../src/calculations/discharge";
+import { FireballCalculation } from "../../src/calculations/fireball";
+import { RadiationTransectCalculation,  } from "../../src/calculations/radiation";
+import { DischargeParameters, FlammableOutputConfig, FlammableParameters, LocalPosition, Material, MaterialComponent, State, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, VesselShape, VesselConditions } 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("Test Case 89 - Vessel and Fireball Scenario", () => {
+    test("should run vessel and fireball calculations with regression checks", async () => {
+      // Define material and state
+      const material = new Material({
+        name: "AMMONIA",
+        components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: 250.0,
+        pressure: 5.0e6,
+        liquidFraction: 0.8,
+      });
+  
+      // Vessel state calculation
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      
+      console.log("Running vessel_state_calculation...");
+      const vesselStateResult = await vesselStateCalc.run();
+  
+      if (vesselStateCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+  
+      // Define vessel
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        diameter: 2.0,
+        length: 5,
+        shape: VesselShape.HORIZONTAL_CYLINDER,
+        vesselConditions: vesselStateCalc.vesselConditions as VesselConditions,
+      });
+  
+      // Vessel catastrophic rupture calculation
+      const dischargeParams = new DischargeParameters();
+      const vesselRuptureCalc = new VesselCatastrophicRuptureCalculation(
+        vessel,
+        dischargeParams
+      );
+  
+      console.log("Running vessel_catastrophic_rupture_calculation...");
+      const ruptureResult = await vesselRuptureCalc.run();
+  
+      if (vesselRuptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselRuptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselRuptureCalc.calculationElapsedTime}ms)`);
+  
+      const exitMaterial = vesselRuptureCalc.exitMaterial;
+  
+      // Define weather
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+      });
+  
+      // Fireball calculation
+      const fireballCalc = new FireballCalculation(
+        exitMaterial!,
+        state,
+        vesselRuptureCalc.dischargeRecords!,
+        vesselRuptureCalc.dischargeRecords!.length,
+        vesselRuptureCalc.dischargeResult!,
+        weather,
+      );
+  
+      console.log("Running fireball_calculation...");
+      const fireballResult = await fireballCalc.run();
+  
+      if (fireballCalc.messages.length > 0) {
+        console.log("Messages:");
+        fireballCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(fireballResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: fireball_calculation (${fireballCalc.calculationElapsedTime}ms)`);
+  
+      // Radiation transect calculation
+      const radiationResolution = Resolution.MEDIUM;
+      const transect = new Transect({
+        transectStartPoint: new LocalPosition({ x: 10.0, y: 0.0, z: 1.0 }),
+        transectEndPoint: new LocalPosition({ x: 10.0, y: 0.0, z: 50.0 }),
+      });
+  
+      const flammableOutputConfig = new FlammableOutputConfig({
+        position: new LocalPosition(),
+        transect,
+        radiationResolution,
+      });
+  
+      const radiationCalc = new RadiationTransectCalculation(
+        fireballCalc.flameResult!,
+        fireballCalc.flameRecords!,
+        fireballCalc.flameRecords!.length,
+        weather,
+        new FlammableParameters(),
+        flammableOutputConfig,
+      );
+  
+      console.log("Running radiation_transect_calculation...");
+      const radiationResult = await radiationCalc.run();
+  
+      if (radiationCalc.messages.length > 0) {
+        console.log("Messages:");
+        radiationCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(radiationResult).toBe(ResultCode.SUCCESS);
+  
+      // Regression checks
+      const flameDiameterError = Math.abs(
+        (fireballCalc.flameResult!.flameDiameter! - 56.27145004272461) /
+          56.27145004272461
+      );
+      expect(flameDiameterError).toBeLessThan(1e-3);
+  
+      expect(radiationCalc.radiationRecords!.length).toBe(50);
+  
+      const radiationResultError = Math.abs(
+        (radiationCalc.radiationRecords![0].radiationResult! - 27343.376825044117) /
+          27343.376825044117
+      );
+      expect(radiationResultError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: radiation_transect_calculation (${radiationCalc.calculationElapsedTime}ms)`);
+    });
+  });

package/tests/fireball-calculation/testCase90.test.ts

@@ -0,0 +1,153 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { FireballCalculation } from "../../src/calculations/fireball";
+import { RadiationTransectCalculation } from "../../src/calculations/radiation";
+import {  DischargeParameters,  FlammableOutputConfig,  FlammableParameters,  LocalPosition,  Material,  MaterialComponent,  State,  Transect,  Vessel,  Weather } from "../../src/entities";
+import {  AtmosphericStabilityClass,  Resolution,  ResultCode,  VesselShape,  VesselConditions } 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("Test Case 90 - Vessel and Fireball Scenario", () => {
+  test("should run vessel and fireball calculations with regression checks", async () => {
+    // Define material and state
+    const material = new Material({
+      name: "ETHANE_BUTANE_PROPANE",
+      components: [
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.5 }),
+        new MaterialComponent({ name: "N-BUTANE", moleFraction: 0.3 }),
+        new MaterialComponent({ name: "PROPANE", moleFraction: 0.2 })
+      ],
+      componentCount: 3,
+    });
+
+    const state = new State({
+      temperature: 265.0,
+      pressure: 5.0e5,
+      liquidFraction: 0.8,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vessel_state_calculation...");
+    const vesselStateResult = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state,
+      material,
+      liquidFillFractionByVolume: 0.8,
+      shape: VesselShape.VERTICAL_CYLINDER,
+      vesselConditions: vesselStateCalc.vesselConditions as VesselConditions,
+    });
+
+    // Vessel catastrophic rupture calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselRuptureCalc = new VesselCatastrophicRuptureCalculation(
+      vessel,
+      dischargeParams
+    );
+
+    console.log("Running vessel_catastrophic_rupture_calculation...");
+    const ruptureResult = await vesselRuptureCalc.run();
+
+    if (vesselRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselRuptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(ruptureResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselRuptureCalc.calculationElapsedTime}ms)`);
+
+    const exitMaterial = vesselRuptureCalc.exitMaterial;
+
+    // Define weather
+    const weather = new Weather({
+      windSpeed: 2.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_E,
+    });
+
+    // Fireball calculation
+    const fireballCalc = new FireballCalculation(
+      exitMaterial!,
+      state,
+      vesselRuptureCalc.dischargeRecords!,
+      vesselRuptureCalc.dischargeRecords!.length,
+      vesselRuptureCalc.dischargeResult!,
+      weather,
+    );
+
+    console.log("Running fireball_calculation...");
+    const fireballResult = await fireballCalc.run();
+
+    if (fireballCalc.messages.length > 0) {
+      console.log("Messages:");
+      fireballCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(fireballResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: fireball_calculation (${fireballCalc.calculationElapsedTime}ms)`);
+
+    // Radiation transect calculation
+    const radiationResolution = Resolution.MEDIUM;
+    const transect = new Transect({
+      transectStartPoint: new LocalPosition({ x: 10.0, y: 0.0, z: 5.0 }),
+      transectEndPoint: new LocalPosition({ x: 100.0, y: 0.0, z: 5.0 }),
+    });
+
+    const flammableOutputConfig = new FlammableOutputConfig({
+      position: new LocalPosition(),
+      transect,
+      radiationResolution,
+    });
+
+    const radiationCalc = new RadiationTransectCalculation(
+      fireballCalc.flameResult!,
+      fireballCalc.flameRecords!,
+      fireballCalc.flameRecords!.length,
+      weather,
+      new FlammableParameters(),
+      flammableOutputConfig,
+    );
+
+    console.log("Running radiation_transect_calculation...");
+    const radiationResult = await radiationCalc.run();
+
+    if (radiationCalc.messages.length > 0) {
+      console.log("Messages:");
+      radiationCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(radiationResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameDiameterError = Math.abs(
+      (fireballCalc.flameResult!.flameDiameter! - 31.624965667724611) /
+      31.624965667724611
+    );
+    expect(flameDiameterError).toBeLessThan(1e-3);
+
+    expect(radiationCalc.radiationRecords!.length).toBe(50);
+
+    const radiationResultError = Math.abs(
+      (radiationCalc.radiationRecords![0].radiationResult! - 36402.50812563037) /
+      36402.50812563037
+    );
+    expect(radiationResultError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: radiation_transect_calculation (${radiationCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/fireball-calculation/testCase91.test.ts

@@ -0,0 +1,152 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { FireballCalculation } from "../../src/calculations/fireball";
+import { RadiationTransectCalculation } from "../../src/calculations/radiation";
+import { DischargeParameters, FlammableOutputConfig, FlammableParameters, LocalPosition, Material, MaterialComponent, State, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, VesselShape } 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("Test Case 91 - Vessel and Fireball Scenario", () => {
+  test("should run vessel and fireball calculations with regression checks", async () => {
+    // Define material and state
+    const material = new Material({
+      name: "PROPANE",
+      components: [new MaterialComponent({ name: "PROPANE", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: 280.0,
+      pressure: 2.0e5,
+      liquidFraction: 0.8,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vessel_state_calculation...");
+    const vesselStateResult = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state,
+      material,
+      liquidFillFractionByVolume: 0.8,
+      height: 2.0,
+      width: 1.0,
+      length: 3.0,
+      shape: VesselShape.VESSEL_CUBOID,
+      vesselConditions: vesselStateCalc.vesselConditions,
+    });
+
+    // Vessel catastrophic rupture calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselRuptureCalc = new VesselCatastrophicRuptureCalculation(
+      vessel,
+      dischargeParams
+    );
+
+    console.log("Running vessel_catastrophic_rupture_calculation...");
+    const ruptureResult = await vesselRuptureCalc.run();
+
+    if (vesselRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselRuptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(ruptureResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselRuptureCalc.calculationElapsedTime}ms)`);
+
+    const exitMaterial = vesselRuptureCalc.exitMaterial;
+
+    // Define weather
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+    });
+
+    // Fireball calculation
+    const fireballCalc = new FireballCalculation(
+      exitMaterial!,
+      state,
+      vesselRuptureCalc.dischargeRecords!,
+      vesselRuptureCalc.dischargeRecords!.length,
+      vesselRuptureCalc.dischargeResult!,
+      weather,
+    );
+
+    console.log("Running fireball_calculation...");
+    const fireballResult = await fireballCalc.run();
+
+    if (fireballCalc.messages.length > 0) {
+      console.log("Messages:");
+      fireballCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(fireballResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: fireball_calculation (${fireballCalc.calculationElapsedTime}ms)`);
+
+    // Radiation transect calculation
+    const radiationResolution = Resolution.MEDIUM;
+    const transect = new Transect({
+      transectStartPoint: new LocalPosition({ x: 10.0, y: -20.0, z: 5.0 }),
+      transectEndPoint: new LocalPosition({ x: 10.0, y: 20.0, z: 5.0 }),
+    });
+
+    const flammableOutputConfig = new FlammableOutputConfig({
+      position: new LocalPosition(),
+      transect,
+      radiationResolution,
+    });
+
+    const radiationCalc = new RadiationTransectCalculation(
+      fireballCalc.flameResult!,
+      fireballCalc.flameRecords!,
+      fireballCalc.flameRecords!.length,
+      weather,
+      new FlammableParameters(),
+      flammableOutputConfig,
+    );
+
+    console.log("Running radiation_transect_calculation...");
+    const radiationResult = await radiationCalc.run();
+
+    if (radiationCalc.messages.length > 0) {
+      console.log("Messages:");
+      radiationCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(radiationResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameDiameterError = Math.abs(
+      (fireballCalc.flameResult!.flameDiameter! - 18.108844757080078) /
+        18.108844757080078
+    );
+    expect(flameDiameterError).toBeLessThan(1e-3);
+
+    expect(radiationCalc.radiationRecords!.length).toBe(50);
+
+    const radiationResultError = Math.abs(
+      (radiationCalc.radiationRecords![0].radiationResult! - 9018.900488875195) /
+        9018.900488875195
+    );
+    expect(radiationResultError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: radiation_transect_calculation (${radiationCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/fireball-calculation/testCse92.test.ts

@@ -0,0 +1,150 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { FireballCalculation } from "../../src/calculations/fireball";
+import { RadiationTransectCalculation } from "../../src/calculations/radiation";
+import { DischargeParameters, FlammableOutputConfig, FlammableParameters, LocalPosition,  Material,  MaterialComponent,  State,  Transect,  Vessel,  Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, VesselShape, VesselConditions } 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("Test Case 92 - Vessel and Fireball Scenario", () => {
+  test("should run vessel and fireball calculations with regression checks", async () => {
+    // Define material and state
+    const material = new Material({
+      name: "HYDROGEN",
+      components: [new MaterialComponent({ name: "HYDROGEN", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: 270.0,
+      pressure: 8.0e6,
+      liquidFraction: 0.8,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vessel_state_calculation...");
+    const vesselStateResult = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state,
+      material,
+      liquidFillFractionByVolume: 0.8,
+      diameter: 5.0,
+      shape: VesselShape.VESSEL_SPHERE,
+      vesselConditions: vesselStateCalc.vesselConditions as VesselConditions,
+    });
+
+    // Vessel catastrophic rupture calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselRuptureCalc = new VesselCatastrophicRuptureCalculation(
+      vessel,
+      dischargeParams
+    );
+
+    console.log("Running vessel_catastrophic_rupture_calculation...");
+    const ruptureResult = await vesselRuptureCalc.run();
+
+    if (vesselRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselRuptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(ruptureResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselRuptureCalc.calculationElapsedTime}ms)`);
+
+    const exitMaterial = vesselRuptureCalc.exitMaterial;
+
+    // Define weather
+    const weather = new Weather({
+      windSpeed: 1.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_C,
+    });
+
+    // Fireball calculation
+    const fireballCalc = new FireballCalculation(
+      exitMaterial!,
+      state,
+      vesselRuptureCalc.dischargeRecords!,
+      vesselRuptureCalc.dischargeRecords!.length,
+      vesselRuptureCalc.dischargeResult!,
+      weather,
+    );
+
+    console.log("Running fireball_calculation...");
+    const fireballResult = await fireballCalc.run();
+
+    if (fireballCalc.messages.length > 0) {
+      console.log("Messages:");
+      fireballCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(fireballResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: fireball_calculation (${fireballCalc.calculationElapsedTime}ms)`);
+
+    // Radiation transect calculation
+    const radiationResolution = Resolution.MEDIUM;
+    const transect = new Transect({
+      transectStartPoint: new LocalPosition({ x: 10.0, y: 0.0, z: 5.0 }),
+      transectEndPoint: new LocalPosition({ x: 50.0, y: 0.0, z: 0.0 }),
+    });
+
+    const flammableOutputConfig = new FlammableOutputConfig({
+      position: new LocalPosition(),
+      transect,
+      radiationResolution,
+    });
+
+    const radiationCalc = new RadiationTransectCalculation(
+      fireballCalc.flameResult!,
+      fireballCalc.flameRecords!,
+      fireballCalc.flameRecords!.length,
+      weather,
+      new FlammableParameters(),
+      flammableOutputConfig,
+    );
+
+    console.log("Running radiation_transect_calculation...");
+    const radiationResult = await radiationCalc.run();
+
+    if (radiationCalc.messages.length > 0) {
+      console.log("Messages:");
+      radiationCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(radiationResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameDiameterError = Math.abs(
+      (fireballCalc.flameResult!.flameDiameter! - 46.949886322021484) /
+      46.949886322021484
+    );
+    expect(flameDiameterError).toBeLessThan(1e-3);
+
+    expect(radiationCalc.radiationRecords!.length).toBe(50);
+
+    const radiationResultError = Math.abs(
+      (radiationCalc.radiationRecords![0].radiationResult! - 97828.68190075974) /
+      97828.68190075974
+    );
+    expect(radiationResultError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: radiation_transect_calculation (${radiationCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/flash-calculation/testCase26.test.ts

@@ -0,0 +1,71 @@
+import { Material, MaterialComponent, State } from "../../src/entities";
+import { FlashCalculation } from "../../src/calculations/properties";
+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("Flash Calculation Scenario - Test Case 26", () => {
+  test("should run the flash calculation and perform regression check", async () => {
+    // Set the case properties
+    const stateTemperature = 270.0;
+    const statePressure = 8.0e6;
+    const stateLiquidFraction = 0.8;
+
+    // Define the initial state of the vessel
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: stateLiquidFraction
+    });
+
+    // Define the material
+    const material = new Material({
+      name: "Case26_Material",
+      components: [
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.2 }),
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.2 }),
+        new MaterialComponent({ name: "PROPANE", moleFraction: 0.2 }),
+        new MaterialComponent({ name: "N-BUTANE", moleFraction: 0.2 }),
+        new MaterialComponent({ name: "N-PENTANE", moleFraction: 0.2 })
+      ],
+      componentCount: 5
+    });
+
+    // Create and run flash calculation
+    const flashCalc = new FlashCalculation(material, state);
+
+    console.log("Running flashCalculation...");
+    const resultCode = await flashCalc.run();
+
+    if (flashCalc.messages.length > 0) {
+      console.log("Messages:");
+      flashCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const totalFluidDensityError = Math.abs(
+      (flashCalc.flashResult!.totalFluidDensity! - 483.1833445460695) / 483.1833445460695
+    );
+    const bubblePointTempError = Math.abs(
+      (flashCalc.flashResult!.bubblePointTemperature! - 319.5331124566492) / 319.5331124566492
+    );
+    const bubblePointPressureError = Math.abs(
+      (flashCalc.flashResult!.bubblePointPressure! - 4479259.631949412) / 4479259.631949412
+    );
+
+    expect(totalFluidDensityError).toBeLessThan(1e-3);
+    expect(flashCalc.flashResult!.fluidPhase).toBe(3);
+    expect(bubblePointTempError).toBeLessThan(1e-3);
+    expect(bubblePointPressureError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: flashCalculation (${flashCalc.calculationElapsedTime}ms)`);
+  });
+});