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

package/tests/linked-runners/vessel-relief-valve-linked-run/test-vrv-168.test.ts

@@ -0,0 +1,168 @@
+import {
+    VesselReliefValveLinkedRunCalculation,
+  } from "../../../src/calculations/linkedRunners";
+  import {
+    LoadMassInventoryVesselForReliefValveScenarioCalculation,
+  } from "../../../src/calculations/utilities";
+  import {
+    Material,
+    MaterialComponent,
+    Weather,
+    Substrate,
+    DispersionParameters,
+    FlammableParameters,
+    ExplosionParameters,
+    ExplosionOutputConfig,
+    ExplosionConfinedVolume,
+    FlammableOutputConfig,
+    DispersionOutputConfig,
+    DischargeParameters,
+  } from "../../../src/entities";
+  import {
+    ResultCode,
+    AtmosphericStabilityClass,
+    SpecialConcentration,
+    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("VesselReliefValveLinkedRunCalculation - VLR_168", () => {
+    it("should run the hydrogen scenario and validate regression outputs", async () => {
+      const material = new Material({
+        name: "HYDROGEN",
+        components: [new MaterialComponent({ name: "HYDROGEN", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const loadCalc = new LoadMassInventoryVesselForReliefValveScenarioCalculation(
+        material,
+        9876,
+        7e5,
+        250,
+        0.05,
+        0.1,
+        33.0,
+        1.0,
+        1.1
+      );
+  
+      console.log("Running load_mass_inventory_vessel_for_relief_valve_scenario_calculation...");
+      const loadResultCode = await loadCalc.run();
+  
+      if (loadCalc.messages.length > 0) {
+        console.log("Messages:");
+        loadCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(loadResultCode).toBe(ResultCode.SUCCESS);
+  
+      if (loadResultCode === ResultCode.SUCCESS) {
+        expect(Math.abs(loadCalc.vessel!.diameter! - 30.344485738881644) / 30.344485738881644).toBeLessThan(1e-3);
+        expect(Math.abs(loadCalc.vessel!.location!.z! + 14.172242869440822) / 14.172242869440822).toBeLessThan(1e-3);
+        expect(Math.abs(loadCalc.reliefValve!.pipeDiameter! - 0.1) / 0.1).toBeLessThan(1e-3);
+        expect(Math.abs(loadCalc.reliefValve!.pipeHeightFraction! - 0.5) / 0.5).toBeLessThan(1e-3);
+        console.log(`SUCCESS: load_mass_inventory_vessel_for_relief_valve_scenario_calculation (${loadCalc.calculationElapsedTime}ms)`);
+      }
+  
+      const weather = new Weather({
+        windSpeed: 10.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+      });
+  
+      const substrate = new Substrate();
+  
+      const dispersionParams = [
+        new DispersionParameters({ averagingTime: 18.75 }),
+        new DispersionParameters({ averagingTime: 18.75 }),
+      ];
+  
+      const dispersionOutputConfigsFlammable = [
+        new DispersionOutputConfig({
+          specialConcentration: SpecialConcentration.LFL_FRACTION,
+          elevation: 0.0,
+        }),
+      ];
+  
+      const dispersionOutputConfigsToxic = [
+        new DispersionOutputConfig({
+          specialConcentration: SpecialConcentration.NOT_DEFINED,
+          concentration: 5e-5,
+          elevation: 0.0,
+        }),
+      ];
+  
+      const flammableParameters = new FlammableParameters();
+      const flammableOutputConfigs = [new FlammableOutputConfig()];
+      const explosionParameters = new ExplosionParameters();
+      const explosionOutputConfigs = [new ExplosionOutputConfig()];
+      const explosionConfinedVolumes = [new ExplosionConfinedVolume()];
+  
+      const reliefCalc = new VesselReliefValveLinkedRunCalculation(
+        loadCalc.vessel!,
+        loadCalc.reliefValve!,
+        new DischargeParameters(),
+        substrate,
+        weather,
+        dispersionParams,
+        dispersionParams.length,
+        0.0,
+        flammableParameters,
+        explosionParameters,
+        dispersionOutputConfigsFlammable,
+        dispersionOutputConfigsFlammable.length,
+        dispersionOutputConfigsToxic,
+        dispersionOutputConfigsToxic.length,
+        flammableOutputConfigs,
+        flammableOutputConfigs.length,
+        explosionOutputConfigs,
+        explosionOutputConfigs.length,
+        explosionConfinedVolumes,
+        explosionConfinedVolumes.length
+      );
+  
+      console.log("Running vessel_relief_valve_linked_run_calculation...");
+      const resultCode = await reliefCalc.run();
+  
+      if (reliefCalc.messages.length > 0) {
+        console.log("Messages:");
+        reliefCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      if (resultCode === ResultCode.SUCCESS) {
+        expect(Math.abs(reliefCalc.dischargeRecord!.massFlow! - 0.9443675979173782) / 0.9443675979173782).toBeLessThan(1e-3);
+        expect(Math.abs(reliefCalc.jetFireFlameResult!.flameLength! - 11.028079519540297) / 11.028079519540297).toBeLessThan(1e-3);
+        expect(reliefCalc.poolFireFlameResult!.flameDiameter!).toBe(0.0);
+        expect(reliefCalc.flamConcContourPoints!.length).toBe(0);
+        expect(reliefCalc.toxicConcContourPoints!.length).toBe(603);
+        expect(reliefCalc.areaFootprintFlamConc![0]).toBe(0.0);
+        expect(Math.abs(reliefCalc.areaFootprintToxicConc![0] - 33801.6456631375) / 33801.6456631375).toBeLessThan(1e-3);
+        expect(Math.abs(reliefCalc.areaContourJet![0] - 396.48256520388253) / 396.48256520388253).toBeLessThan(1e-3);
+        expect(reliefCalc.areaContourPool![0]).toBe(0.0);
+        expect(Math.abs(reliefCalc.explosionOverpressureResults![0].explodedMass! - 0.20630565247270963) / 0.20630565247270963).toBeLessThan(1e-3);
+        expect(Math.abs(reliefCalc.explosionOverpressureResults![0].maximumDistance! - 45.518593970444364) / 45.518593970444364).toBeLessThan(1e-3);
+  
+        console.log(`Mass flow = ${reliefCalc.dischargeRecord!.massFlow}`);
+        console.log(`Flame length = ${reliefCalc.jetFireFlameResult!.flameLength}`);
+        console.log(`Flame diameter = ${reliefCalc.poolFireFlameResult!.flameDiameter}`);
+        console.log(`Flam contour length = ${reliefCalc.flamConcContourPoints!.length}`);
+        console.log(`Toxic contour length = ${reliefCalc.toxicConcContourPoints!.length}`);
+        console.log(`Flam area = ${reliefCalc.areaFootprintFlamConc![0]}`);
+        console.log(`Toxic area = ${reliefCalc.areaFootprintToxicConc![0]}`);
+        console.log(`Jet area = ${reliefCalc.areaContourJet![0]}`);
+        console.log(`Pool area = ${reliefCalc.areaContourPool![0]}`);
+        console.log(`Exploded mass = ${reliefCalc.explosionOverpressureResults![0].explodedMass}`);
+        console.log(`Explosion max distance = ${reliefCalc.explosionOverpressureResults![0].maximumDistance}`);
+        console.log(`SUCCESS: vessel_relief_valve_linked_run_calculation (${reliefCalc.calculationElapsedTime}ms)`);
+      }
+    });
+  });
+  

package/tests/load-mass-inventory-vessel-for-line-rupture-scenario-calculation/testCase126.test.ts

@@ -0,0 +1,72 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { LoadMassInventoryVesselForLineRuptureScenarioCalculation } from "../../src/calculations/utilities";
+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("Load Mass Inventory Vessel for Line Rupture Scenario - Test Case 126", () => {
+  test("should run the calculation and perform regression check", async () => {
+    const material = new Material({
+      name: "PROPANE",
+      components: [
+        new MaterialComponent({ name: "PROPANE", moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    const mass = 1e3;
+    const pressure = 11e5;
+    const temperature = 250;
+    const pipeLength = 10.0;
+    const pipeDiameter = 0.5;
+    const releaseElevation = 1.0;
+    const releaseAngle = 0.35;
+
+    const calculation = new LoadMassInventoryVesselForLineRuptureScenarioCalculation(
+      material,
+      mass,
+      pressure,
+      temperature,
+      pipeDiameter,
+      pipeLength,
+      releaseElevation,
+      releaseAngle,
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_line_rupture_scenario_calculation...");
+    const resultCode = await calculation.run();
+
+    if (calculation.messages.length > 0) {
+      console.log("Messages:");
+      calculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedDiameter = 1.521293357476972;
+    const expectedElevation = -0.3626191519898414;
+    const expectedPipeDiameter = 0.5;
+    const expectedPipeHeightFraction = 0.8956978253357473;
+
+    const vessel = calculation.vessel!;
+    const lineRupture = calculation.lineRupture!;
+
+    const diameterError = Math.abs((vessel.diameter - expectedDiameter) / expectedDiameter);
+    const elevationError = Math.abs((vessel.location.z - expectedElevation) / expectedElevation);
+    const pipeDiameterError = Math.abs((lineRupture.pipeDiameter! - expectedPipeDiameter) / expectedPipeDiameter);
+    const pipeHeightFractionError = Math.abs((lineRupture.pipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+
+    expect(diameterError).toBeLessThan(1e-3);
+    expect(elevationError).toBeLessThan(1e-3);
+    expect(pipeDiameterError).toBeLessThan(1e-3);
+    expect(pipeHeightFractionError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_line_rupture_scenario_calculation (${calculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/load-mass-inventory-vessel-for-line-rupture-scenario-calculation/testCase127.test.ts

@@ -0,0 +1,73 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { LoadMassInventoryVesselForLineRuptureScenarioCalculation } from "../../src/calculations/utilities";
+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("Load Mass Inventory Vessel for Line Rupture Scenario - Test Case 127", () => {
+  test("should run the calculation and perform regression check", async () => {
+    const material = new Material({
+      name: "METHANE+ETHANE",
+      components: [
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.9 }),
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.1 }),
+      ],
+      componentCount: 2,
+    });
+
+    const mass = 1e5;
+    const pressure = 11e5;
+    const temperature = 250;
+    const pipeDiameter = 0.5;
+    const pipeLength = 10.0;
+    const releaseElevation = 100.0;
+    const releaseAngle = 0.0;
+
+    const calculation = new LoadMassInventoryVesselForLineRuptureScenarioCalculation(
+      material,
+      mass,
+      pressure,
+      temperature,
+      pipeDiameter,
+      pipeLength,
+      releaseElevation,
+      releaseAngle
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_line_rupture_scenario_calculation...");
+    const resultCode = await calculation.run();
+
+    if (calculation.messages.length > 0) {
+      console.log("Messages:");
+      calculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedDiameter = 27.049130317992706;
+    const expectedElevation = 86.47543484100365;
+    const expectedPipeDiameter = 0.5;
+    const expectedPipeHeightFraction = 0.5;
+
+    const vessel = calculation.vessel!;
+    const lineRupture = calculation.lineRupture!;
+
+    const diameterError = Math.abs((vessel.diameter - expectedDiameter) / expectedDiameter);
+    const elevationError = Math.abs((vessel.location.z - expectedElevation) / expectedElevation);
+    const pipeDiameterError = Math.abs((lineRupture.pipeDiameter! - expectedPipeDiameter) / expectedPipeDiameter);
+    const pipeHeightFractionError = Math.abs((lineRupture.pipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+
+    expect(diameterError).toBeLessThan(1e-3);
+    expect(elevationError).toBeLessThan(1e-3);
+    expect(pipeDiameterError).toBeLessThan(1e-3);
+    expect(pipeHeightFractionError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_line_rupture_scenario_calculation (${calculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/load-mass-inventory-vessel-for-line-rupture-scenario-calculation/testCase128.test.ts

@@ -0,0 +1,72 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { LoadMassInventoryVesselForLineRuptureScenarioCalculation } from "../../src/calculations/utilities";
+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("Load Mass Inventory Vessel for Line Rupture Scenario - Test Case 128", () => {
+  test("should run the calculation and perform regression check", async () => {
+    const material = new Material({
+      name: "N-HEXANE",
+      components: [
+        new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    const mass = 9876;
+    const pressure = 7e5;
+    const temperature = 250;
+    const pipeLength = 33.0;
+    const pipeDiameter = 0.1;
+    const releaseElevation = 1.0;
+    const releaseAngle = 1.1;
+
+    const calculation = new LoadMassInventoryVesselForLineRuptureScenarioCalculation(
+      material,
+      mass,
+      pressure,
+      temperature,
+      pipeDiameter,
+      pipeLength,
+      releaseElevation,
+      releaseAngle
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_line_rupture_scenario_calculation...");
+    const resultCode = await calculation.run();
+
+    if (calculation.messages.length > 0) {
+      console.log("Messages:");
+      calculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedDiameter = 3.0323298714998153;
+    const expectedElevation = -1.7170445294165657;
+    const expectedPipeDiameter = 0.1;
+    const expectedPipeHeightFraction = 0.8960253813259087;
+
+    const vessel = calculation.vessel!;
+    const lineRupture = calculation.lineRupture!;
+
+    const diameterError = Math.abs((vessel.diameter - expectedDiameter) / expectedDiameter);
+    const elevationError = Math.abs((vessel.location.z - expectedElevation) / expectedElevation);
+    const pipeDiameterError = Math.abs((lineRupture.pipeDiameter! - expectedPipeDiameter) / expectedPipeDiameter);
+    const pipeHeightFractionError = Math.abs((lineRupture.pipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+
+    expect(diameterError).toBeLessThan(1e-3);
+    expect(elevationError).toBeLessThan(1e-3);
+    expect(pipeDiameterError).toBeLessThan(1e-3);
+    expect(pipeHeightFractionError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_line_rupture_scenario_calculation (${calculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/load-mass-inventory-vessel-for-relief-valve-scenario-calculation/testCase103.test.ts

@@ -0,0 +1,74 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { LoadMassInventoryVesselForReliefValveScenarioCalculation } from "../../src/calculations/utilities";
+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("Load Mass Inventory Vessel for Relief Valve Scenario - Test Case 103", () => {
+  test("should run the calculation and perform regression check", async () => {
+    const material = new Material({
+      name: "PROPANE",
+      components: [
+        new MaterialComponent({ name: "PROPANE", moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    const mass = 1e3;
+    const pressure = 11e5;
+    const temperature = 250;
+    const constrictionSize = 0.15;
+    const pipeDiameter = 0.5;
+    const pipeLength = 10.0;
+    const releaseElevation = 1.0;
+    const releaseAngle = 0.35;
+
+    const calculation = new LoadMassInventoryVesselForReliefValveScenarioCalculation(
+      material,
+      mass,
+      pressure,
+      temperature,
+      constrictionSize,
+      pipeDiameter,
+      pipeLength,
+      releaseElevation,
+      releaseAngle
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_relief_valve_scenario_calculation...");
+    const resultCode = await calculation.run();
+
+    if (calculation.messages.length > 0) {
+      console.log("Messages:");
+      calculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedDiameter = 1.521293357476972;
+    const expectedElevation = -0.3626191519898414;
+    const expectedPipeDiameter = 0.5;
+    const expectedPipeHeightFraction = 0.8956978253357473;
+
+    const vessel = calculation.vessel!;
+    const reliefValve = calculation.reliefValve!;
+
+    const diameterError = Math.abs((vessel.diameter - expectedDiameter) / expectedDiameter);
+    const elevationError = Math.abs((vessel.location.z - expectedElevation) / expectedElevation);
+    const pipeDiameterError = Math.abs((reliefValve.pipeDiameter! - expectedPipeDiameter) / expectedPipeDiameter);
+    const pipeHeightFractionError = Math.abs((reliefValve.pipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+
+    expect(diameterError).toBeLessThan(1e-3);
+    expect(elevationError).toBeLessThan(1e-3);
+    expect(pipeDiameterError).toBeLessThan(1e-3);
+    expect(pipeHeightFractionError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_relief_valve_scenario_calculation (${calculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/load-mass-inventory-vessel-for-relief-valve-scenario-calculation/testCase104.test.ts

@@ -0,0 +1,75 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { LoadMassInventoryVesselForReliefValveScenarioCalculation } from "../../src/calculations/utilities";
+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("Load Mass Inventory Vessel for Relief Valve Scenario - Test Case 104", () => {
+  test("should run the calculation and perform regression check", async () => {
+    const material = new Material({
+      name: "METHANE+ETHANE",
+      components: [
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.9 }),
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.1 }),
+      ],
+      componentCount: 2,
+    });
+    
+    let mass = 1e5
+    let pressure = 11e5
+    let temperature = 250
+    let constrictionSize = 0.5
+    let pipeDiameter = 0.5
+    let pipeLength = 10.0
+    let releaseElevation = 100.0
+    let releaseAngle = 0.0
+
+    const calculation = new LoadMassInventoryVesselForReliefValveScenarioCalculation(
+      material,
+      mass,
+      pressure,
+      temperature,
+      constrictionSize,
+      pipeDiameter,
+      pipeLength,
+      releaseElevation,
+      releaseAngle,
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_relief_valve_scenario_calculation...");
+    const resultCode = await calculation.run();
+
+    if (calculation.messages.length > 0) {
+      console.log("Messages:");
+      calculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedDiameter = 27.049130317992706;
+    const expectedElevation = 86.47543484100365;
+    const expectedPipeDiameter = 0.5;
+    const expectedPipeHeightFraction = 0.5;
+
+    const vessel = calculation.vessel!;
+    const reliefValve = calculation.reliefValve!;
+
+    const diameterError = Math.abs((vessel.diameter - expectedDiameter) / expectedDiameter);
+    const elevationError = Math.abs((vessel.location.z - expectedElevation) / expectedElevation);
+    const pipeDiameterError = Math.abs((reliefValve.pipeDiameter! - expectedPipeDiameter) / expectedPipeDiameter);
+    const pipeHeightFractionError = Math.abs((reliefValve.pipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+
+    expect(diameterError).toBeLessThan(1e-3);
+    expect(elevationError).toBeLessThan(1e-3);
+    expect(pipeDiameterError).toBeLessThan(1e-3);
+    expect(pipeHeightFractionError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_relief_valve_scenario_calculation (${calculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/load-mass-inventory-vessel-for-relief-valve-scenario-calculation/testCase105.test.ts

@@ -0,0 +1,74 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { LoadMassInventoryVesselForReliefValveScenarioCalculation } from "../../src/calculations/utilities";
+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("Load Mass Inventory Vessel for Relief Valve Scenario - Test Case 105", () => {
+  test("should run the calculation and perform regression check", async () => {
+    const material = new Material({
+      name: "N-HEXANE",
+      components: [
+        new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    const mass = 9876;
+    const pressure = 7e5;
+    const temperature = 250;
+    const constrictionSize = 0.05;
+    const pipeDiameter = 0.1;
+    const pipeLength = 33.0;
+    const releaseElevation = 1.0;
+    const releaseAngle = 1.1;
+
+    const calculation = new LoadMassInventoryVesselForReliefValveScenarioCalculation(
+      material,
+      mass,
+      pressure,
+      temperature,
+      constrictionSize,
+      pipeDiameter,
+      pipeLength,
+      releaseElevation,
+      releaseAngle,
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_relief_valve_scenario_calculation...");
+    const resultCode = await calculation.run();
+
+    if (calculation.messages.length > 0) {
+      console.log("Messages:");
+      calculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedDiameter = 3.0323298714998153;
+    const expectedElevation = -1.7170445294165657;
+    const expectedPipeDiameter = 0.1;
+    const expectedPipeHeightFraction = 0.8960253813259087;
+
+    const vessel = calculation.vessel!;
+    const reliefValve = calculation.reliefValve!;
+
+    const diameterError = Math.abs((vessel.diameter - expectedDiameter) / expectedDiameter);
+    const elevationError = Math.abs((vessel.location.z - expectedElevation) / expectedElevation);
+    const pipeDiameterError = Math.abs((reliefValve.pipeDiameter! - expectedPipeDiameter) / expectedPipeDiameter);
+    const pipeHeightFractionError = Math.abs((reliefValve.pipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+
+    expect(diameterError).toBeLessThan(1e-3);
+    expect(elevationError).toBeLessThan(1e-3);
+    expect(pipeDiameterError).toBeLessThan(1e-3);
+    expect(pipeHeightFractionError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_relief_valve_scenario_calculation (${calculation.calculationElapsedTime}ms)`);
+  });
+});