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

package/tests/vessel-catastrophic-rupture-calculation/testCase1.test.ts

@@ -0,0 +1,83 @@
+import {
+    VesselCatastrophicRuptureCalculation,
+    VesselStateCalculation,
+} from "../../src/calculations/discharge";
+
+import {
+    Material,
+    MaterialComponent,
+    State,
+    Vessel,
+    DischargeParameters
+} from "../../src/entities";
+
+import { 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 - Vessel Catastrophic Rupture Calculation for AMMONIA", () => {
+    test("should correctly compute release mass and expansion energy", async () => {
+        const material = new Material({
+            name: "AMMONIA",
+            components: [
+                new MaterialComponent({
+                    name: "AMMONIA",
+                    moleFraction: 1.0
+                })
+            ]
+        });
+
+        const state = new State({
+            temperature: 250.0,
+            pressure: 5.0e6,
+            liquidFraction: 0.8
+        });
+
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResult = await vesselStateCalculation.run();
+
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.8,
+            diameter: 2.0,
+            length: 5,
+            shape: VesselShape.HORIZONTAL_CYLINDER
+        });
+
+        const dischargeParameters = new DischargeParameters();
+        const catastrophicRupture = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+
+        console.log("Running vessel_catastrophic_rupture_calculation...");
+        const resultCode = await catastrophicRupture.run();
+
+        if (catastrophicRupture.messages.length > 0) {
+            console.log("Messages:");
+            catastrophicRupture.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        const releaseMass = catastrophicRupture.dischargeResult!.releaseMass!;
+        const expansionEnergy = catastrophicRupture.dischargeResult!.expansionEnergy!;
+
+        expect(Math.abs((releaseMass - 8403.10476066265) / 8403.10476066265)).toBeLessThan(1e-3);
+        expect(Math.abs((expansionEnergy - 399.5722780225985) / 399.5722780225985)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${catastrophicRupture.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-catastrophic-rupture-calculation/testCase2.test.ts

@@ -0,0 +1,82 @@
+import {
+    VesselCatastrophicRuptureCalculation,
+    VesselStateCalculation,
+} from "../../src/calculations/discharge";
+
+import {
+    Material,
+    MaterialComponent,
+    State,
+    Vessel,
+    DischargeParameters
+} from "../../src/entities";
+
+import { 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 - Vessel Catastrophic Rupture Calculation for CHLORINE", () => {
+    test("should correctly compute release mass and expansion energy", async () => {
+        const material = new Material({
+            name: "CHLORINE",
+            components: [
+                new MaterialComponent({
+                    name: "CHLORINE",
+                    moleFraction: 1.0
+                })
+            ]
+        });
+
+        const state = new State({
+            temperature: 300.0,
+            pressure: 5.0e6,
+            liquidFraction: 0.8
+        });
+
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResult = await vesselStateCalculation.run();
+
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.8,
+            diameter: 2.0,
+            shape: VesselShape.VESSEL_SPHERE
+        });
+
+        const dischargeParameters = new DischargeParameters();
+        const catastrophicRupture = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+
+        console.log("Running vessel_catastrophic_rupture_calculation...");
+        const resultCode = await catastrophicRupture.run();
+
+        if (catastrophicRupture.messages.length > 0) {
+            console.log("Messages:");
+            catastrophicRupture.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        const releaseMass = catastrophicRupture.dischargeResult!.releaseMass!;
+        const expansionEnergy = catastrophicRupture.dischargeResult!.expansionEnergy!;
+
+        expect(Math.abs((releaseMass - 4651.875667954904) / 4651.875667954904)).toBeLessThan(1e-3);
+        expect(Math.abs((expansionEnergy - 385.60331992903724) / 385.60331992903724)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${catastrophicRupture.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-catastrophic-rupture-calculation/testCase3.test.ts

@@ -0,0 +1,91 @@
+import {
+    VesselCatastrophicRuptureCalculation,
+    VesselStateCalculation,
+} from "../../src/calculations/discharge";
+
+import {
+    Material,
+    MaterialComponent,
+    State,
+    Vessel,
+    DischargeParameters
+} from "../../src/entities";
+
+import { 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 - Vessel Catastrophic Rupture Calculation for ETHANE_BUTANE_PROPANE", () => {
+    test("should correctly compute release mass and expansion energy", async () => {
+        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
+        });
+
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResult = await vesselStateCalculation.run();
+
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.8,
+            shape: VesselShape.VERTICAL_CYLINDER,
+            diameter: 2.0
+        });
+
+        const dischargeParameters = new DischargeParameters();
+        const catastrophicRupture = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+
+        console.log("Running vessel_catastrophic_rupture_calculation...");
+        const resultCode = await catastrophicRupture.run();
+
+        if (catastrophicRupture.messages.length > 0) {
+            console.log("Messages:");
+            catastrophicRupture.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        const releaseMass = catastrophicRupture.dischargeResult!.releaseMass!;
+        const expansionEnergy = catastrophicRupture.dischargeResult!.expansionEnergy!;
+
+        expect(Math.abs((releaseMass - 131.31770718737567) / 131.31770718737567)).toBeLessThan(1e-3);
+        expect(Math.abs((expansionEnergy - 2833.902840039733) / 2833.902840039733)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${catastrophicRupture.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-catastrophic-rupture-calculation/testCase4.test.ts

@@ -0,0 +1,85 @@
+import {
+    VesselCatastrophicRuptureCalculation,
+    VesselStateCalculation,
+} from "../../src/calculations/discharge";
+
+import {
+    Material,
+    MaterialComponent,
+    State,
+    Vessel,
+    DischargeParameters
+} from "../../src/entities";
+
+import { 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 - Vessel Catastrophic Rupture Calculation for HEXANE", () => {
+    test("should correctly compute release mass and expansion energy", async () => {
+        const material = new Material({
+            name: "HEXANE",
+            components: [
+                new MaterialComponent({
+                    name: "N-HEXANE",
+                    moleFraction: 1.0
+                })
+            ],
+            componentCount: 1
+        });
+
+        const state = new State({
+            temperature: 280.0,
+            pressure: 2.0e5,
+            liquidFraction: 0.8
+        });
+
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResult = await vesselStateCalculation.run();
+
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.8,
+            shape: VesselShape.VESSEL_CUBOID,
+            height: 2.0,
+            width: 1.0,
+            length: 3.0
+        });
+
+        const dischargeParameters = new DischargeParameters();
+        const catastrophicRupture = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+
+        console.log("Running vessel_catastrophic_rupture_calculation...");
+        const resultCode = await catastrophicRupture.run();
+
+        if (catastrophicRupture.messages.length > 0) {
+            console.log("Messages:");
+            catastrophicRupture.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        const releaseMass = catastrophicRupture.dischargeResult!.releaseMass;
+        const expansionEnergy = catastrophicRupture.dischargeResult!.expansionEnergy;
+
+        expect(Math.abs((releaseMass! - 3225.8372574404343) / 3225.8372574404343)).toBeLessThan(1e-3);
+        expect(Math.abs((expansionEnergy! - 6.579403395934496) / 6.579403395934496)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${catastrophicRupture.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-catastrophic-rupture-calculation/testCase5.test.ts

@@ -0,0 +1,84 @@
+import {
+    VesselCatastrophicRuptureCalculation,
+    VesselStateCalculation,
+} from "../../src/calculations/discharge";
+
+import {
+    Material,
+    MaterialComponent,
+    State,
+    Vessel,
+    DischargeParameters
+} from "../../src/entities";
+
+import { 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 - Vessel Catastrophic Rupture Calculation for HYDROGEN", () => {
+    test("should correctly compute release mass and expansion energy", async () => {
+        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
+        });
+
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResult = await vesselStateCalculation.run();
+
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.8,
+            shape: VesselShape.VESSEL_SPHERE,
+            diameter: 5.0
+        });
+
+        const dischargeParameters = new DischargeParameters();
+        const catastrophicRupture = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+
+        console.log("Running vessel_catastrophic_rupture_calculation...");
+        const resultCode = await catastrophicRupture.run();
+
+        if (catastrophicRupture.messages.length > 0) {
+            console.log("Messages:");
+            catastrophicRupture.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        const releaseMass = catastrophicRupture.dischargeResult!.releaseMass!;
+        const expansionEnergy = catastrophicRupture.dischargeResult!.expansionEnergy!;
+
+        expect(Math.abs((releaseMass - 442.9319348311668) / 442.9319348311668)).toBeLessThan(1e-3);
+        expect(Math.abs((expansionEnergy - 111410.44845369669) / 111410.44845369669)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${catastrophicRupture.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-leak-calculation/testCase10.test.ts

@@ -0,0 +1,108 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Leak, Material, MaterialComponent, State, Vessel } from "../../src/entities";
+import { ResultCode, TimeVaryingOption, 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('Vessel Leak Calculation - Test Case 10', () => {
+    test('Vessel leak calculation for N-Butane', async () => {
+        // Set the case properties
+        const materialName = 'N-BUTANE';
+        const stateTemperature = 300.0;
+        const statePressure = 3.0E+05;
+        const vesselShape = VesselShape.VESSEL_CUBOID;
+        const vesselHeight = 2.0;
+        const vesselWidth = 1.0;
+        const vesselLength = 3.0;
+        const leakHoleDiameter = 0.05;
+        const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+        const leakHoleHeightFraction = 0.2;
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: stateTemperature,
+            pressure: statePressure,
+            liquidFraction: 0.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: materialName,
+            components: [
+                new MaterialComponent({ name: materialName, moleFraction: 1.0 })
+            ]
+        });
+
+        // Create a vessel state calculation using the material and state
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        // Check vessel state calculation result
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+
+        // Create a vessel to use in the leak calculation
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            height: vesselHeight,
+            width: vesselWidth,
+            length: vesselLength,
+            shape: vesselShape,
+            liquidFillFractionByVolume: 0.5,
+            vesselConditions: vesselStateCalculation.vesselConditions
+        });
+
+        // Create a leak to use in the vessel leak calculation
+        const leak = new Leak({
+            holeDiameter: leakHoleDiameter,
+            timeVaryingOption: timeVaryingOption,
+            holeHeightFraction: leakHoleHeightFraction,
+        });
+
+        // Create discharge parameters to use in the vessel leak calculation
+        const dischargeParameters = new DischargeParameters();
+
+        // Create a vessel leak calculation using the vessel, leak, and discharge parameters
+        const vesselLeakCalculation = new VesselLeakCalculation(
+            vessel,
+            leak,
+            dischargeParameters
+        );
+
+        // Run the vessel leak calculation
+        const vesselLeakResultCode = await vesselLeakCalculation.run();
+
+        // Check vessel leak calculation result
+        expect(vesselLeakResultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression tests for discharge records
+        const dischargeRecords = vesselLeakCalculation.dischargeRecords;
+        expect(dischargeRecords).toBeDefined();
+        expect(dischargeRecords!.length).toBe(2);
+
+        // Check mass flow regression
+        const expectedMassFlow = 18.596151455819438;
+        const actualMassFlow = dischargeRecords ? dischargeRecords[0].massFlow : undefined;
+        expect(actualMassFlow).toBeDefined();
+        expect(Math.abs(((actualMassFlow as number) - expectedMassFlow) / expectedMassFlow)).toBeLessThan(1e-3);
+
+        // Check final velocity regression
+        const expectedFinalVelocity = 82.9875939245342;
+        const actualFinalVelocity = dischargeRecords ? dischargeRecords[0].finalVelocity : undefined;
+        expect(actualFinalVelocity).toBeDefined();
+        expect(Math.abs(((actualFinalVelocity as number) - expectedFinalVelocity) / expectedFinalVelocity)).toBeLessThan(1e-3);
+
+        // Check droplet diameter regression
+        const expectedDropletDiameter = 0.00024867091738833337;
+        const actualDropletDiameter = dischargeRecords ? dischargeRecords[0].dropletDiameter : undefined;
+        expect(actualDropletDiameter).toBeDefined();
+        expect(Math.abs(((actualDropletDiameter as number) - expectedDropletDiameter) / expectedDropletDiameter)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-leak-calculation/testCase6.test.ts

@@ -0,0 +1,113 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Leak, LocalPosition, Material, MaterialComponent, SafetySystem, State, Vessel } from "../../src/entities";
+import { ResultCode, TimeVaryingOption, 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('Vessel Leak Calculation', () => {
+    test('test case 6 - vessel leak calculation', async () => {
+      // Set the case properties
+      const materialName = 'METHANE';
+      const stateTemperature = 280.0;
+      const statePressure = 1.0E+06;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 3.0;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+      const leakHoleHeightFraction = 0.5;
+  
+      // Define the initial state of the vessel
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0
+      });
+  
+      // Define the material contained by the vessel
+      const material = new Material({
+        name: materialName, 
+        components: [new MaterialComponent({name: materialName, moleFraction:1.0})]
+      });
+  
+      // Create a vessel state calculation using the material and state
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+  
+      // Run the vessel state calculation
+      const vesselStateResultCode = await vesselStateCalculation.run();
+  
+      // Check vessel state calculation result
+      expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+      
+      // Optional: Log messages if any
+      if (vesselStateCalculation.messages.length > 0) {
+        vesselStateCalculation.messages.forEach(message => {
+          console.log(message);
+        });
+      }
+  
+      // Create a vessel to use in the leak calculation
+      const vessel = new Vessel({
+        state: vesselStateCalculation.outputState!,
+        material: vesselStateCalculation.material,
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        vesselConditions: vesselStateCalculation.vesselConditions
+      });
+  
+      // Create a leak to use in the vessel leak calculation
+      const leak = new Leak({
+        holeDiameter:leakHoleDiameter,
+        timeVaryingOption: timeVaryingOption,
+        holeHeightFraction:leakHoleHeightFraction,
+      });
+  
+      // Create discharge parameters to use in the vessel leak calculation
+      const dischargeParameters = new DischargeParameters();
+  
+      // Create a vessel leak calculation using the vessel, leak, and discharge parameters
+      const vesselLeakCalculation = new VesselLeakCalculation(
+        vessel, 
+        leak, 
+        dischargeParameters
+      );
+  
+      // Run the vessel leak calculation
+      const vesselLeakResultCode = await vesselLeakCalculation.run();
+  
+      // Check vessel leak calculation result
+      expect(vesselLeakResultCode).toBe(ResultCode.SUCCESS);
+      
+      // Optional: Log messages if any
+      if (vesselLeakCalculation.messages.length > 0) {
+        vesselLeakCalculation.messages.forEach(message => {
+          console.log(message);
+        });
+      }
+  
+      // Regression tests for discharge records
+      const dischargeRecords = vesselLeakCalculation.dischargeRecords;
+  
+      // Check number of discharge records
+      expect(dischargeRecords).toBeDefined();
+      expect(dischargeRecords!.length).toBe(2);
+  
+      // Check mass flow regression
+      const expectedMassFlow = 12.033250169270818;
+      const actualMassFlow = dischargeRecords ? dischargeRecords[0].massFlow : undefined;
+      expect(actualMassFlow).toBeDefined();
+      expect(Math.abs(((actualMassFlow as number) - expectedMassFlow) / expectedMassFlow)).toBeLessThan(1e-3);
+  
+      // Check final velocity regression
+      const expectedFinalVelocity = 649.4227509851291;
+      const actualFinalVelocity = dischargeRecords ? dischargeRecords[0].finalVelocity : undefined;
+      expect(actualFinalVelocity).toBeDefined();
+      expect(Math.abs(((actualFinalVelocity as number) - expectedFinalVelocity) / expectedFinalVelocity)).toBeLessThan(1e-3);
+    });
+  });