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

package/tests/vessel-line-rupture-calculation/vlr-propane.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 PROPANE", () => {
+    test("Vessel line rupture calculation for PROPANE", async () => {
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 250.0,
+            pressure: 3.0e5,
+            liquidFraction: 1.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "PROPANE",
+            components: [
+                new MaterialComponent({ name: "PROPANE", 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 (horizontal cylinder: 2m diameter, 5m length)
+        const vessel = new Vessel({
+            state: state,
+            material: material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.HORIZONTAL_CYLINDER,
+            diameter: 2,
+            length: 5
+        });
+
+        // Define the line rupture (0.1m diameter, 5m length, height fraction 0.3)
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.1,
+            pipeLength: 5.0,
+            pipeHeightFraction: 0.3
+        });
+
+        // Run the vessel line rupture calculation
+        const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        const resultCode = await vesselLineRuptureCalculation.run();
+
+        expect(resultCode).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! - 67.02362285598161) / 67.02362285598161)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalState.temperature! - 231.07970451768477) / 231.07970451768477)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 63.51263298624852) / 63.51263298624852)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeResult.releaseMass! - 6149.058906744638) / 6149.058906744638)).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-relief-valve-calculation/vrv-chlorine.test.ts

@@ -0,0 +1,99 @@
+import { VesselReliefValveCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Material, MaterialComponent, ReliefValve, State, Vessel} 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('Vessel Relief Valve Calculation - Chlorine', () => {
+    test('Vessel relief valve calculation for Chlorine', async () => {
+        // Set the case properties
+        const materialName = 'CHLORINE';
+        const stateTemperature = 320.0;
+        const statePressure = 1.0E+06;
+        const liquidFraction = 1.0;
+        const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+        const vesselDiameter = 2.0;
+        const vesselLength = 5.0;
+        const reliefValvePipeDiameter = 0.02;
+        const reliefValvePipeLength = 10.0;
+        const reliefValveConstrictionDiameter = 0.02;
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: stateTemperature,
+            pressure: statePressure,
+            liquidFraction: liquidFraction
+        });
+
+        // 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 using the calculated state and material
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            liquidFillFractionByVolume: 0.7,
+            shape: vesselShape,
+            diameter: vesselDiameter,
+            length: vesselLength,
+            vesselConditions: vesselStateCalculation.vesselConditions
+        });
+
+        // Create a relief valve to use in the vessel relief valve calculation
+        const reliefValve = new ReliefValve({
+            pipeDiameter: reliefValvePipeDiameter,
+            pipeLength: reliefValvePipeLength,
+            pipeHeightFraction: 1.0,
+            reliefValveConstrictionDiameter: reliefValveConstrictionDiameter
+        });
+
+        // Create a vessel relief valve calculation
+        const dischargeParameters = new DischargeParameters();
+        const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+            vessel,
+            reliefValve,
+            dischargeParameters
+        );
+
+        // Run the vessel relief valve calculation
+        const vesselReliefValveResultCode = await vesselReliefValveCalculation.run();
+
+        // Check vessel relief valve calculation result
+        expect(vesselReliefValveResultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression tests for discharge results
+        const expectedReleaseMass = 466.32195097490285;
+        const actualReleaseMass = vesselReliefValveCalculation.dischargeResult?.releaseMass ?? 0;
+        expect(Math.abs((actualReleaseMass - expectedReleaseMass) / expectedReleaseMass)).toBeLessThan(1e-3);
+
+        // Regression tests for discharge records
+        const dischargeRecords = vesselReliefValveCalculation.dischargeRecords!;
+        expect(dischargeRecords).toBeDefined();
+        expect(dischargeRecords.length).toBe(2);
+
+        expect(Math.abs((dischargeRecords[1].time! - 1075.2115493324122) / 1075.2115493324122)).toBeLessThan(1e-3); 
+        expect(Math.abs((dischargeRecords[0].massFlow! - 0.43370251302121643) / 0.43370251302121643)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].orificeState.pressure! - 217541.03350332877) / 217541.03350332877)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 276.4442859277149) / 276.4442859277149)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-relief-valve-calculation/vrv-hydrogen.test.ts

@@ -0,0 +1,96 @@
+import { VesselReliefValveCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Material, MaterialComponent, ReliefValve, State, Vessel } 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('Vessel Relief Valve Calculation - Hydrogen', () => {
+    test('Vessel relief valve calculation for Hydrogen', async () => {
+        // Set the case properties
+        const materialName = 'HYDROGEN';
+        const stateTemperature = 270.0;
+        const statePressure = 8e6;
+        const liquidFraction = 1.0;
+        const vesselShape = VesselShape.VESSEL_SPHERE;
+        const vesselDiameter = 5.0;
+        const reliefValvePipeDiameter = 0.5;
+        const reliefValvePipeLength = 1.0;
+        const reliefValveConstrictionDiameter = 0.25;
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: stateTemperature,
+            pressure: statePressure,
+            liquidFraction: liquidFraction
+        });
+
+        // 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 using the calculated state and material
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            liquidFillFractionByVolume: 0.7,
+            shape: vesselShape,
+            diameter: vesselDiameter,
+            vesselConditions: vesselStateCalculation.vesselConditions
+        });
+
+        // Create a relief valve to use in the vessel relief valve calculation
+        const reliefValve = new ReliefValve({
+            pipeDiameter: reliefValvePipeDiameter,
+            pipeLength: reliefValvePipeLength,
+            pipeHeightFraction: 1.0,
+            reliefValveConstrictionDiameter: reliefValveConstrictionDiameter
+        });
+
+        // Create a vessel relief valve calculation
+        const dischargeParameters = new DischargeParameters();
+        const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+            vessel,
+            reliefValve,
+            dischargeParameters
+        );
+
+        // Run the vessel relief valve calculation
+        const vesselReliefValveResultCode = await vesselReliefValveCalculation.run();
+
+        // Check vessel relief valve calculation result
+        expect(vesselReliefValveResultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression tests for discharge results
+        const expectedReleaseMass = 442.9319348311668;
+        const actualReleaseMass = vesselReliefValveCalculation.dischargeResult?.releaseMass ?? 0;
+        expect(Math.abs((actualReleaseMass - expectedReleaseMass) / expectedReleaseMass)).toBeLessThan(1e-3);
+
+        // Regression tests for discharge records
+        const dischargeRecords = vesselReliefValveCalculation.dischargeRecords!;
+        expect(dischargeRecords).toBeDefined();
+        expect(dischargeRecords.length).toBe(2);
+
+        expect(Math.abs((dischargeRecords[1].time! - 1.6933094303236609) / 1.6933094303236609)).toBeLessThan(1e-3); 
+        expect(Math.abs((dischargeRecords[0].massFlow! - 261.5776696799618) / 261.5776696799618)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].orificeState.pressure! - 1453253.4181444559) / 1453253.4181444559)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 1947.6881413918381) / 1947.6881413918381)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-relief-valve-calculation/vrv-methane.test.ts

@@ -0,0 +1,80 @@
+import { VesselReliefValveCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Material, MaterialComponent, ReliefValve, State, Vessel } 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('Vessel Relief Valve Calculation - Methane', () => {
+    test('Vessel relief valve calculation for Methane', async () => {
+        // Define the initial state of the vessel
+        const state = new State({ temperature: 240.0, pressure: 5e6, liquidFraction: 1.0 });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "METHANE",
+            components: [new MaterialComponent({ name: "METHANE", 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 using the calculated state and material
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_SPHERE,
+            diameter: 3,
+            vesselConditions: vesselStateCalculation.vesselConditions
+        });
+
+        // Create a relief valve
+        const reliefValve = new ReliefValve({
+            pipeDiameter: 0.1,
+            pipeLength: 5.0,
+            pipeHeightFraction: 1.0,
+            reliefValveConstrictionDiameter: 0.01
+        });
+
+        // Create a vessel relief valve calculation
+        const dischargeParameters = new DischargeParameters();
+        const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+            vessel,
+            reliefValve,
+            dischargeParameters
+        );
+
+        // Run the vessel relief valve calculation
+        const vesselReliefValveResultCode = await vesselReliefValveCalculation.run();
+
+        // Check vessel relief valve calculation result
+        expect(vesselReliefValveResultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression tests for discharge results
+        const expectedReleaseMass = 701.8787816018365;
+        const actualReleaseMass = vesselReliefValveCalculation.dischargeResult?.releaseMass ?? 0;
+        expect(Math.abs((actualReleaseMass - expectedReleaseMass) / expectedReleaseMass)).toBeLessThan(1e-3);
+
+        // Regression tests for discharge records
+        const dischargeRecords = vesselReliefValveCalculation.dischargeRecords!;
+        expect(dischargeRecords).toBeDefined();
+        expect(dischargeRecords.length).toBe(2);
+
+        expect(Math.abs((dischargeRecords[1].time! - 798.3770006929267) / 798.3770006929267)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 0.8791320153169022) / 0.8791320153169022)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].orificeState.pressure! - 101325.0) / 101325.0)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 112.52375086203219) / 112.52375086203219)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-relief-valve-calculation/vrv-methaneH2s.test.ts

@@ -0,0 +1,86 @@
+import { VesselReliefValveCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Material, MaterialComponent, ReliefValve, State, Vessel } 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('Vessel Relief Valve Calculation - MET+H2S', () => {
+    test('Vessel relief valve calculation for MET+H2S', async () => {
+        // Define the initial state of the vessel
+        const state = new State({ temperature: 280.0, pressure: 2e6, liquidFraction: 1.0 });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "MET+H2S",
+            components: [
+                new MaterialComponent({ name: "METHANE", moleFraction: 0.9 }),
+                new MaterialComponent({ name: "HYDROGEN SULFIDE", moleFraction: 0.1 })
+            ],
+            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 using the calculated state and material
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_CUBOID,
+            height: 2,
+            width: 1,
+            length: 3,
+            vesselConditions: vesselStateCalculation.vesselConditions
+        });
+
+        // Create a relief valve
+        const reliefValve = new ReliefValve({
+            pipeDiameter: 0.1,
+            pipeLength: 1.0,
+            pipeHeightFraction: 1.0,
+            reliefValveConstrictionDiameter: 0.05
+        });
+
+        // Create a vessel relief valve calculation
+        const dischargeParameters = new DischargeParameters();
+        const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+            vessel,
+            reliefValve,
+            dischargeParameters
+        );
+
+        // Run the vessel relief valve calculation
+        const vesselReliefValveResultCode = await vesselReliefValveCalculation.run();
+
+        // Check vessel relief valve calculation result
+        expect(vesselReliefValveResultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression tests for discharge results
+        const expectedReleaseMass = 97.16333722218255;
+        const actualReleaseMass = vesselReliefValveCalculation.dischargeResult?.releaseMass ?? 0;
+        expect(Math.abs((actualReleaseMass - expectedReleaseMass) / expectedReleaseMass)).toBeLessThan(1e-3);
+
+        // Regression tests for discharge records
+        const dischargeRecords = vesselReliefValveCalculation.dischargeRecords!;
+        expect(dischargeRecords).toBeDefined();
+        expect(dischargeRecords.length).toBe(2);
+
+        expect(Math.abs((dischargeRecords[1].time! - 12.434893609230256) / 12.434893609230256)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 7.81376506109063) / 7.81376506109063)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].orificeState.pressure! - 391491.52234610944) / 391491.52234610944)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 582.3607141206039) / 582.3607141206039)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-relief-valve-calculation/vrv-nitrogen.test.ts

@@ -0,0 +1,80 @@
+import { VesselReliefValveCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DischargeParameters, Material, MaterialComponent, ReliefValve, State, Vessel } 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('Vessel Relief Valve Calculation - Nitrogen', () => {
+    test('Vessel relief valve calculation for Nitrogen', async () => {
+        // Define the initial state of the vessel
+        const state = new State({ temperature: 300.0, pressure: 4e6, liquidFraction: 1.0 });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "NITROGEN",
+            components: [new MaterialComponent({ name: "NITROGEN", 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 using the calculated state and material
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.HORIZONTAL_CYLINDER,
+            diameter: 1.5,
+            height: 3,
+            vesselConditions: vesselStateCalculation.vesselConditions
+        });
+
+        // Create a relief valve
+        const reliefValve = new ReliefValve({
+            pipeDiameter: 0.5,
+            pipeLength: 10.0,
+            pipeHeightFraction: 1.0,
+            reliefValveConstrictionDiameter: 0.5
+        });
+
+        // Create a vessel relief valve calculation
+        const dischargeParameters = new DischargeParameters();
+        const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+            vessel,
+            reliefValve,
+            dischargeParameters
+        );
+
+        // Run the vessel relief valve calculation
+        const vesselReliefValveResultCode = await vesselReliefValveCalculation.run();
+
+        // Check vessel relief valve calculation result
+        expect(vesselReliefValveResultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression tests for discharge results
+        const expectedReleaseMass = 314.94879020959837;
+        const actualReleaseMass = vesselReliefValveCalculation.dischargeResult?.releaseMass ?? 0;
+        expect(Math.abs((actualReleaseMass - expectedReleaseMass) / expectedReleaseMass)).toBeLessThan(1e-3);
+
+        // Regression tests for discharge records
+        const dischargeRecords = vesselReliefValveCalculation.dischargeRecords!;
+        expect(dischargeRecords).toBeDefined();
+        expect(dischargeRecords.length).toBe(2);
+
+        expect(Math.abs((dischargeRecords[1].time! - 0.20034090677203503) / 0.20034090677203503)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].massFlow! - 1572.064314194075) / 1572.064314194075)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].orificeState.pressure! - 2165508.2851427207) / 2165508.2851427207)).toBeLessThan(1e-3);
+        expect(Math.abs((dischargeRecords[0].finalVelocity! - 554.7205461435867) / 554.7205461435867)).toBeLessThan(1e-3);
+    });
+});

package/tests/vessel-state-calculation/vs-ammonia.test.ts

@@ -0,0 +1,56 @@
+import { VesselStateCalculation } from "../../src/calculations/discharge";
+import { Material, MaterialComponent, State } 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('Vessel State Calculation - Test for Ammonia', () => {
+    test('Ammonia vessel state calculation', async () => {
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 270.0,
+            pressure: 8.0e6,
+            liquidFraction: 0.8
+        });
+
+        // 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);
+
+        // Run the vessel state calculation
+        console.log('Running vessel_state_calculation...');
+        const resultCode = await vesselStateCalculation.run();
+
+        // Print any messages
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log('Messages:');
+            vesselStateCalculation.messages.forEach((message) => {
+                console.log(message);
+            });
+        }
+
+        // Check if the calculation was successful
+        if (resultCode === ResultCode.SUCCESS) {
+            // Regression test for vessel conditions
+            expect(vesselStateCalculation.vesselConditions).toBe(4);
+            console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+        } else {
+            // Fail the test if the result code is not successful
+            throw new Error(`FAILED vessel_state_calculation with result code ${resultCode}`);
+        }
+    });
+});

package/tests/vessel-state-calculation/vs-butane.test.ts

@@ -0,0 +1,57 @@
+import { VesselStateCalculation } from "../../src/calculations/discharge";
+import { Material, MaterialComponent, State } 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('Vessel State Calculation - Test for Butane', () => {
+    test('Butane vessel state calculation', async () => {
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 300.0,
+            pressure: 8.0e6,
+            liquidFraction: 0.8
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "N-BUTANE",
+            components: [
+                new MaterialComponent({ name: "N-BUTANE", 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 resultCode = await vesselStateCalculation.run();
+
+        // Print any messages
+        if (vesselStateCalculation.messages.length > 0) {
+            console.log('Messages:');
+            vesselStateCalculation.messages.forEach((message) => {
+                console.log(message);
+            });
+        }
+
+        // Check if the calculation was successful
+        if (resultCode === ResultCode.SUCCESS) {
+            // Regression test for vessel conditions
+            expect(vesselStateCalculation.vesselConditions).toBe(4);
+            console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+        } else {
+            // Fail the test if the result code is not successful
+            throw new Error(`FAILED vessel_state_calculation with result code ${resultCode}`);
+        }
+    });
+});