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

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

@@ -0,0 +1,123 @@
+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 7', () => {
+    test('test case 7 - vessel leak calculation', async () => {
+        // Set the case properties
+        const materialName = 'TOLUENE';
+        const stateTemperature = 280.0;
+        const statePressure = 1.50E+05;
+        const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+        const vesselLength = 5.0;
+        const vesselDiameter = 2.0;
+        const leakHoleDiameter = 0.05;
+        const timeVaryingOption = TimeVaryingOption.TIME_VARYING_RATE;
+        const leakHoleHeightFraction = 0.0;
+
+        // 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
+        console.log('Running 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,
+            length: vesselLength,
+            shape: vesselShape,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.5
+        });
+
+        // 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
+        console.log('Running 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(900);
+
+        // Check mass flow regression
+        const expectedMassFlow = 12.605655881613954;
+        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 = 12.154668210488419;
+        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.002048354602442208;
+        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/testCase8.test.ts

@@ -0,0 +1,102 @@
+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 8', () => {
+    test('Vessel leak calculation for Carbon Dioxide (Toxic)', async () => {
+        // Set the case properties
+        const materialName = 'CARBON DIOXIDE (TOXIC)';
+        const stateTemperature = 280.0;
+        const statePressure = 8.0E+06;
+        const vesselShape = VesselShape.VESSEL_SPHERE;
+        const vesselDiameter = 5.0;
+        const leakHoleDiameter = 0.008;
+        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);
+        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,
+            diameter: vesselDiameter,
+            shape: vesselShape,
+            liquidFillFractionByVolume: 0.8,
+            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 = 4.015328433666382;
+        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 = 141.10842725286392;
+        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 = 1.1446905156710795e-05;
+        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/testCase9.test.ts

@@ -0,0 +1,106 @@
+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 9', () => {
+    test('Vessel leak calculation for N-Octane + N-Heptane', async () => {
+        // Set the case properties
+        const stateTemperature = 250.0;
+        const statePressure = 5.00E+05;
+        const vesselShape = VesselShape.VERTICAL_CYLINDER;
+        const vesselHeight = 3.0;
+        const vesselDiameter = 1.5;
+        const leakHoleDiameter = 0.1;
+        const timeVaryingOption = TimeVaryingOption.TIME_VARYING_RATE;
+        const leakHoleHeightFraction = 0.0;
+
+        // 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: 'N-OCTANE+N-HEPTANE',
+            components: [
+                new MaterialComponent({ name: 'N-OCTANE', moleFraction: 0.5 }),
+                new MaterialComponent({ name: 'N-HEPTANE', moleFraction: 0.5 })
+            ],
+            componentCount: 2
+        });
+
+        // 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,
+            diameter: vesselDiameter,
+            height: vesselHeight,
+            shape: vesselShape,
+            liquidFillFractionByVolume: 0.8,
+            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(698);
+
+        // Check mass flow regression
+        const expectedMassFlow = 125.74564365679295;
+        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 = 36.48936892716285;
+        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.0001917147651424711;
+        const actualDropletDiameter = dischargeRecords ? dischargeRecords[0].dropletDiameter : undefined;
+        expect(actualDropletDiameter).toBeDefined();
+        expect(Math.abs(((actualDropletDiameter as number) - expectedDropletDiameter) / expectedDropletDiameter)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-line-rupture-calculation/vlr-ammonia.test.ts

@@ -0,0 +1,84 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { Material, MaterialComponent, State, Vessel, LineRupture, 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 - VLR AMMONIA', () => {
+    test('Vessel line rupture calculation for AMMONIA', async () => {
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 290.0,
+            pressure: 7.0e6,
+            liquidFraction: 1.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "AMMONIA",
+            components: [new MaterialComponent({ name: "AMMONIA", 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 the result of vessel state calculation
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Create a vessel for the line rupture calculation (cuboid: 2m height, 1m width, 3m length)
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_CUBOID,
+            height: 2,
+            width: 1,
+            length: 3
+        });
+
+        // Create a line rupture
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.1,
+            pipeLength: 1.0,
+            pipeHeightFraction: 0.1
+        });
+
+        // Create the vessel line rupture calculation
+        const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+
+        // Run the calculation
+        const lineRuptureResultCode = await vesselLineRuptureCalculation.run();
+
+        // Check result
+        expect(lineRuptureResultCode).toBe(ResultCode.SUCCESS);
+
+        // Output messages
+        if (vesselLineRuptureCalculation.messages.length > 0) {
+            console.log('Messages:');
+            vesselLineRuptureCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        // Validate output values
+        const dischargeRecords = vesselLineRuptureCalculation.dischargeRecords!;
+        const dischargeResult = vesselLineRuptureCalculation.dischargeResult!;
+
+        expect(dischargeRecords.length).toBe(2);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 489.84382051168984) / 489.84382051168984)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalState.temperature! - 239.747566488825) / 239.747566488825)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 242.1191558154253) / 242.1191558154253)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeResult.releaseMass! - 2578.8221114859684) / 2578.8221114859684)).toBeLessThan(1e-3);
+
+        console.log(`vessel_line_rupture_calculation.discharge_result.release_mass: ${dischargeResult.releaseMass} [kg]`);
+        console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-line-rupture-calculation/vlr-ethaneMethane.test.ts

@@ -0,0 +1,82 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { Material, MaterialComponent, State, Vessel, LineRupture, 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 - VLR ETHANE + METHANE + HYDROGEN", () => {
+    test("Vessel line rupture calculation for ETHANE_METHANE_HY", async () => {
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 260.0,
+            pressure: 5e5,
+            liquidFraction: 1.0
+        });
+
+        // Define the material composition
+        const material = new Material({
+            name: "ETHANE_METHANE_HY",
+            components: [
+                new MaterialComponent({ name: "ETHANE", moleFraction: 0.15 }),
+                new MaterialComponent({ name: "METHANE", moleFraction: 0.8 }),
+                new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.05 })
+            ],
+            componentCount: 3
+        });
+
+        // Run the vessel state calculation
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Define the vessel (sphere with 3m diameter)
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_SPHERE,
+            diameter: 3
+        });
+
+        // Define line rupture (0.5m diameter, 1m length, height fraction 0.5)
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.5,
+            pipeLength: 1.0,
+            pipeHeightFraction: 0.5
+        });
+
+        // Run the vessel line rupture calculation
+        const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        const lineRuptureResultCode = await vesselLineRuptureCalculation.run();
+
+        expect(lineRuptureResultCode).toBe(ResultCode.SUCCESS);
+
+        // Output messages
+        if (vesselLineRuptureCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselLineRuptureCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        // Validate outputs
+        const dischargeRecords = vesselLineRuptureCalculation.dischargeRecords!;
+        const dischargeResult = vesselLineRuptureCalculation.dischargeResult!;
+
+        expect(dischargeRecords.length).toBe(2);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 158.64730421749067) / 158.64730421749067)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalState.temperature! - 190.35560483348553) / 190.35560483348553)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 556.7861619546059) / 556.7861619546059)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeResult.releaseMass! - 58.02291202254755) / 58.02291202254755)).toBeLessThan(1e-3);
+
+        console.log(`vessel_line_rupture_calculation.discharge_result.release_mass: ${dischargeResult.releaseMass} [kg]`);
+        console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/vessel-line-rupture-calculation/vlr-nDecane.test.ts

@@ -0,0 +1,79 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { Material, MaterialComponent, State, Vessel, LineRupture, 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 - VLR N-DECANE", () => {
+    test("Vessel line rupture calculation for N-DECANE", async () => {
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 280.0,
+            pressure: 1.5e5,
+            liquidFraction: 1.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "N-DECANE",
+            components: [
+                new MaterialComponent({ name: "N-DECANE", moleFraction: 1.0 })
+            ]
+        });
+
+        // Run the vessel state calculation
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Define the vessel (vertical cylinder, 3m height, 1.5m diameter)
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VERTICAL_CYLINDER,
+            height: 3,
+            diameter: 1.5
+        });
+
+        // Define the line rupture (0.02m diameter, 10m length, height fraction 0)
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.02,
+            pipeLength: 10.0,
+            pipeHeightFraction: 0
+        });
+
+        // Run the vessel line rupture calculation
+        const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        const lineRuptureResultCode = await vesselLineRuptureCalculation.run();
+
+        expect(lineRuptureResultCode).toBe(ResultCode.SUCCESS);
+
+        if (vesselLineRuptureCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselLineRuptureCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        const dischargeRecords = vesselLineRuptureCalculation.dischargeRecords!;
+        const dischargeResult = vesselLineRuptureCalculation.dischargeResult!;
+
+        expect(dischargeRecords.length).toBe(2);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 0.8312460349563479) / 0.8312460349563479)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalState.temperature! - 280.0421759165028) / 280.0421759165028)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 3.569757805283587) / 3.569757805283587)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeResult.releaseMass! - 2750.746981948948) / 2750.746981948948)).toBeLessThan(1e-3);
+
+        console.log(`vessel_line_rupture_calculation.discharge_result.release_mass: ${dischargeResult.releaseMass} [kg]`);
+        console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+        console.log(`final velocity = ${dischargeRecords[0].finalVelocity}`);
+    });
+});

package/tests/vessel-line-rupture-calculation/vlr-oxygen.test.ts

@@ -0,0 +1,77 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { Material, MaterialComponent, State, Vessel, LineRupture, 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 - VLR OXYGEN", () => {
+    test("Vessel line rupture calculation for OXYGEN", async () => {
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 300.0,
+            pressure: 1e7,
+            liquidFraction: 1.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "OXYGEN",
+            components: [
+                new MaterialComponent({ name: "OXYGEN", moleFraction: 1.0 })
+            ]
+        });
+
+        // Run the vessel state calculation
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Define the vessel (sphere with 5m diameter)
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_SPHERE,
+            diameter: 5
+        });
+
+        // Define the line rupture (0.5m diameter, 10m length, pipe height fraction 1)
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.5,
+            pipeLength: 10.0,
+            pipeHeightFraction: 1
+        });
+
+        // Run the vessel line rupture calculation
+        const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        const lineRuptureResultCode = await vesselLineRuptureCalculation.run();
+
+        expect(lineRuptureResultCode).toBe(ResultCode.SUCCESS);
+
+        if (vesselLineRuptureCalculation.messages.length > 0) {
+            console.log("Messages:");
+            vesselLineRuptureCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        const dischargeRecords = vesselLineRuptureCalculation.dischargeRecords!;
+        const dischargeResult = vesselLineRuptureCalculation.dischargeResult!;
+
+        expect(dischargeRecords.length).toBe(2);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 4351.317585307134) / 4351.317585307134)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalState.temperature! - 147.19547540940934) / 147.19547540940934)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 510.5081623160129) / 510.5081623160129)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeResult.releaseMass! - 8699.938240300542) / 8699.938240300542)).toBeLessThan(1e-3);
+
+        console.log(`vessel_line_rupture_calculation.discharge_result.release_mass: ${dischargeResult.releaseMass} [kg]`);
+        console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+    });
+});