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

package/tests/distances-to-conc-levels-calculation/testCase122.test.ts

@@ -0,0 +1,145 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesToConcLevelsCalculation } from "../../src/calculations/dispersionView";
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, VesselShape, WindProfileFlag } 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 122 - Distances to Concentration Levels Scenario", () => {
+  test("should run vessel, rupture, dispersion, and distances calculations with regression checks", async () => {
+    // Define material and state
+    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,
+    });
+
+    // 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,
+    });
+
+    // 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)`);
+
+    // Set up entities for dispersion calculation
+    const bund = new Bund({
+      specifyBund: true,
+      bundHeight: 1.0,
+      bundDiameter: 8.0,
+    });
+
+    const substrate = new Substrate({
+      bund,
+      surfaceType: SurfaceType.WATER,
+      surfaceRoughness: 0.05,
+    });
+
+    const weather = new Weather({
+      windSpeed: 2.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const dispersionParams = new DispersionParameters();
+
+    // Dispersion calculation
+    const dispersionCalc = new DispersionCalculation(
+      vesselRuptureCalc.exitMaterial!,
+      substrate,
+      vesselRuptureCalc.dischargeResult!,
+      vesselRuptureCalc.dischargeRecords!,
+      vesselRuptureCalc.dischargeRecords!.length,
+      weather,
+      dispersionParams,
+      0.0 // endPointConcentration
+    );
+
+    console.log("Running dispersion_calculation...");
+    const dispersionResult = await dispersionCalc.run();
+
+    if (dispersionCalc.messages.length > 0) {
+      console.log("Messages:");
+      dispersionCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(dispersionResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+    // Distances to concentration levels calculation
+    const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: 0.0 })];
+
+    const distancesCalc = new DistancesToConcLevelsCalculation(
+      dispersionCalc.scalarUdmOutputs!,
+      weather,
+      dispersionCalc.dispersionRecords!,
+      dispersionCalc.dispersionRecords!.length,
+      substrate,
+      dispersionOutputConfigs,
+      dispersionOutputConfigs.length,
+      vesselRuptureCalc.exitMaterial!,
+      dispersionParams
+    );
+
+    console.log("Running distances_to_conc_levels_calculation...");
+    const distancesResult = await distancesCalc.run();
+
+    if (distancesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression check
+    const distanceError = Math.abs(
+      (distancesCalc.distances![0] - 13.21859690146534) / 13.21859690146534
+    );
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_to_conc_levels_calculation (${distancesCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/distances-to-conc-levels-calculation/testCase123.test.ts

@@ -0,0 +1,150 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesToConcLevelsCalculation } from "../../src/calculations/dispersionView";
+import {  DischargeParameters, DispersionOutputConfig, DispersionParameters, Leak, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, TimeVaryingOption, VesselShape, WindProfileFlag } 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 123 - Distances to Concentration Levels Scenario", () => {
+  test("should run vessel, leak, dispersion, and distances calculations with regression checks", async () => {
+    // Define material and state
+    const material = new Material({
+      name: "CARBON DIOXIDE (TOXIC)",
+      components: [
+        new MaterialComponent({ name: "CARBON DIOXIDE (TOXIC)", moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: 280.0,
+      pressure: 8.0e6,
+      liquidFraction: 0.0,
+    });
+
+    // 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: vesselStateCalc.outputState!,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      diameter: 5.0,
+      shape: VesselShape.VESSEL_SPHERE,
+      liquidFillFractionByVolume: 0.8,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: 0.008,
+      holeHeightFraction: 0.5,
+      timeVaryingOption: TimeVaryingOption.INITIAL_RATE,
+    });
+
+    // Vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+
+    console.log("Running vessel_leak_calculation...");
+    const leakResult = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(leakResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Set up entities for dispersion calculation
+    const substrate = new Substrate({
+      surfaceType: SurfaceType.WATER,
+      surfaceRoughness: 0.01,
+    });
+
+    const weather = new Weather({
+      windSpeed: 4.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_C,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const dispersionParams = new DispersionParameters();
+
+    // Dispersion calculation
+    const dispersionCalc = new DispersionCalculation(
+      vesselLeakCalc.exitMaterial!,
+      substrate,
+      vesselLeakCalc.dischargeResult!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      weather,
+      dispersionParams,
+      0.0 // endPointConcentration
+    );
+
+    console.log("Running dispersion_calculation...");
+    const dispersionResult = await dispersionCalc.run();
+
+    if (dispersionCalc.messages.length > 0) {
+      console.log("Messages:");
+      dispersionCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(dispersionResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+    // Distances to concentration levels calculation
+    const dispersionOutputConfigs = [
+      new DispersionOutputConfig({ concentration: 0.0, elevation: 2.4 }),
+    ];
+
+    const distancesCalc = new DistancesToConcLevelsCalculation(
+      dispersionCalc.scalarUdmOutputs!,
+      weather,
+      dispersionCalc.dispersionRecords!,
+      dispersionCalc.dispersionRecords!.length,
+      substrate,
+      dispersionOutputConfigs,
+      dispersionOutputConfigs.length,
+      vesselLeakCalc.exitMaterial!,
+      dispersionParams
+    );
+
+    console.log("Running distances_to_conc_levels_calculation...");
+    const distancesResult = await distancesCalc.run();
+
+    if (distancesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression check
+    const distanceError = Math.abs(
+      (distancesCalc.distances![0] - 10.023176380641605) / 10.023176380641605
+    );
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_to_conc_levels_calculation (${distancesCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/distances-to-conc-levels-calculation/testCase124.test.ts

@@ -0,0 +1,154 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesToConcLevelsCalculation } from "../../src/calculations/dispersionView";
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, LineRupture, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, VesselShape, WindProfileFlag } 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 124 - Distances to Concentration Levels Scenario", () => {
+  test("should run vessel, line rupture, dispersion, and distances calculations with regression checks", async () => {
+    // Define material and state
+    const state = new State({
+      temperature: 290.0,
+      pressure: 7.0e6,
+      liquidFraction: 1.0,
+    });
+
+    const material = new Material({
+      name: "AMMONIA",
+      components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    // 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,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      liquidFillFractionByVolume: 0.7,
+      shape: VesselShape.VESSEL_CUBOID,
+      height: 2.0,
+      width: 1.0,
+      length: 3.0,
+    });
+
+    // Define line rupture
+    const lineRupture = new LineRupture({
+      pipeDiameter: 0.1,
+      pipeLength: 1.0,
+      pipeHeightFraction: 0.1,
+    });
+
+    // Vessel line rupture calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselLineRuptureCalc = new VesselLineRuptureCalculation(vessel, lineRupture, dischargeParams);
+
+    console.log("Running vessel_line_rupture_calculation...");
+    const ruptureResult = await vesselLineRuptureCalc.run();
+
+    if (vesselLineRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLineRuptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(ruptureResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalc.calculationElapsedTime}ms)`);
+
+    // Set up entities for dispersion calculation
+    const bund = new Bund({
+      specifyBund: true,
+      bundHeight: 0.5,
+      bundDiameter: 5.0,
+    });
+
+    const substrate = new Substrate({
+      bund,
+      surfaceType: SurfaceType.LAND,
+      surfaceRoughness: 0.183,
+    });
+
+    const weather = new Weather({
+      windSpeed: 1.5,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+    });
+
+    const dispersionParams = new DispersionParameters();
+
+    // Dispersion calculation
+    const dispersionCalc = new DispersionCalculation(
+      vesselLineRuptureCalc.exitMaterial!,
+      substrate,
+      vesselLineRuptureCalc.dischargeResult!,
+      vesselLineRuptureCalc.dischargeRecords!,
+      vesselLineRuptureCalc.dischargeRecords!.length,
+      weather,
+      dispersionParams,
+      0.0 // endPointConcentration
+    );
+
+    console.log("Running dispersion_calculation...");
+    const dispersionResult = await dispersionCalc.run();
+
+    if (dispersionCalc.messages.length > 0) {
+      console.log("Messages:");
+      dispersionCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(dispersionResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+    // Distances to concentration levels calculation
+    const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: 0.0, elevation: 35.0 })];
+
+    const distancesCalc = new DistancesToConcLevelsCalculation(
+      dispersionCalc.scalarUdmOutputs!,
+      weather,
+      dispersionCalc.dispersionRecords!,
+      dispersionCalc.dispersionRecords!.length,
+      substrate,
+      dispersionOutputConfigs,
+      dispersionOutputConfigs.length,
+      vesselLineRuptureCalc.exitMaterial!,
+      dispersionParams
+    );
+
+    console.log("Running distances_to_conc_levels_calculation...");
+    const distancesResult = await distancesCalc.run();
+
+    if (distancesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression check
+    const distanceError = Math.abs(
+      (distancesCalc.distances![0] - 327.4691422670722) / 327.4691422670722);
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_to_conc_levels_calculation (${distancesCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/distances-to-conc-levels-calculation/testCase125.test.ts

@@ -0,0 +1,157 @@
+import { VesselStateCalculation, VesselReliefValveCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation} from "../../src/calculations/dispersion";
+import { DistancesToConcLevelsCalculation, } from "../../src/calculations/dispersionView";
+import { Material, MaterialComponent, State, Vessel, ReliefValve, DischargeParameters, Bund, Substrate, Weather, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselShape, ResultCode, SurfaceType, AtmosphericStabilityClass, WindProfileFlag } 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 125 - Distances to Concentration Levels Scenario", () => {
+    test("should run vessel state, relief valve, dispersion, and distances calculations with regression checks", async () => {
+      // Define material and state
+      const material = new Material({
+        name: "CHLORINE",
+        components: [
+          new MaterialComponent({ name: "CHLORINE", moleFraction: 1.0 }),
+        ],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: 320.0,
+        pressure: 1.0e6,
+        liquidFraction: 1.0,
+      });
+  
+      // 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.7,
+        shape: VesselShape.HORIZONTAL_CYLINDER,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        diameter: 2.0,
+        length: 5.0,
+      });
+  
+      // Define relief valve
+      const reliefValve = new ReliefValve({
+        pipeDiameter: 0.02,
+        pipeLength: 10.0,
+        pipeHeightFraction: 1,
+        reliefValveConstrictionDiameter: 0.02,
+      });
+  
+      // Vessel relief valve calculation
+      const dischargeParams = new DischargeParameters();
+      const vesselReliefValveCalc = new VesselReliefValveCalculation(vessel, reliefValve, dischargeParams);
+  
+      console.log("Running vessel_relief_valve_calculation...");
+      const reliefValveResult = await vesselReliefValveCalc.run();
+  
+      if (vesselReliefValveCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselReliefValveCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(reliefValveResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_relief_valve_calculation (${vesselReliefValveCalc.calculationElapsedTime}ms)`);
+      console.log(`vessel_relief_valve_calculation.dischargeResult.releaseMass: ${vesselReliefValveCalc.dischargeResult?.releaseMass} [kg]`);
+  
+      // Set up entities for dispersion calculation
+      const bund = new Bund({
+        specifyBund: true,
+        bundHeight: 0.5,
+        bundDiameter: 5.0,
+      });
+  
+      const substrate = new Substrate({
+        bund,
+        surfaceType: SurfaceType.LAND,
+        surfaceRoughness: 0.183,
+      });
+  
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+      });
+  
+      const dispersionParams = new DispersionParameters();
+  
+      // Dispersion calculation
+      const dispersionCalc = new DispersionCalculation(
+        vesselReliefValveCalc.exitMaterial!,
+        substrate,
+        vesselReliefValveCalc.dischargeResult!,
+        vesselReliefValveCalc.dischargeRecords!,
+        vesselReliefValveCalc.dischargeRecords!.length,
+        weather,
+        dispersionParams,
+        0.0 // endPointConcentration
+      );
+  
+      console.log("Running dispersion_calculation...");
+      const dispersionResult = await dispersionCalc.run();
+  
+      if (dispersionCalc.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(dispersionResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+  
+      // Distances to concentration levels calculation
+      const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: 0.0, elevation: 0.0 })];
+  
+      const distancesCalc = new DistancesToConcLevelsCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfigs,
+        dispersionOutputConfigs.length,
+        vesselReliefValveCalc.exitMaterial!,
+        dispersionParams
+      );
+  
+      console.log("Running distances_to_conc_levels_calculation...");
+      const distancesResult = await distancesCalc.run();
+  
+      if (distancesCalc.messages.length > 0) {
+        console.log("Messages:");
+        distancesCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(distancesResult).toBe(ResultCode.SUCCESS);
+      console.log(`distances = ${distancesCalc.distances![0]}`);
+      console.log(`SUCCESS: distances_to_conc_levels_calculation (${distancesCalc.calculationElapsedTime}ms)`);
+  
+      // Note: The Python test does not include a regression check for distances, so none is added here.
+      // If a specific expected distance value is known, you can add a check like:
+      // const distanceError = Math.abs((distancesCalc.distances![0] - EXPECTED_VALUE) / EXPECTED_VALUE);
+      // expect(distanceError).toBeLessThan(1e-3);
+    });
+  });

package/tests/entities/testVessel.test.ts

@@ -0,0 +1,49 @@
+import { LocalPosition, Material, MaterialComponent, State, Vessel } from "../../src/entities";
+import { VesselConditions, 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 Vessel Entity", () => {
+  test("should correctly instantiate a Vessel entity with specified attributes", () => {
+    // Define material
+    const material = new Material({
+      name: "AMMONIA",
+      components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    // Define state
+    const state = new State({
+      temperature: 265.0,
+      pressure: 5.0e5,  // Converted from string '5.0E5' to number notation
+      liquidFraction: 0.0,
+    });
+
+    // Define position
+    const position = new LocalPosition({
+      x: 10.0,
+      y: 20.0,
+      z: 30.0,
+    });
+
+    // Create vessel
+    const vessel = new Vessel({
+      state,
+      material,
+      location: position,
+      liquidFillFractionByVolume: 0.5
+    });
+
+    // Assertions
+    expect(vessel.material.name).toBe("AMMONIA");
+    expect(vessel.state.temperature).toBe(265.0);
+    expect(vessel.state.pressure).toBe(5.0e5);
+    expect(vessel.state.liquidFraction).toBe(0.0);
+  });
+});