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

package/tests/linked-runners/vessel-leak-linked-run/test-vl-160.test.ts

@@ -0,0 +1,165 @@
+import { VesselLeakLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLeakScenarioCalculation } from "../../../src/calculations/utilities";
+import {
+  Material,
+  MaterialComponent,
+  Weather,
+  Substrate,
+  DischargeParameters,
+  FlammableParameters,
+  DispersionParameters,
+  ExplosionParameters,
+  ExplosionOutputConfig,
+  ExplosionConfinedVolume,
+  FlammableOutputConfig,
+  DispersionOutputConfig
+} from "../../../src/entities";
+import {
+  ResultCode,
+  AtmosphericStabilityClass,
+  SpecialConcentration,
+  WindProfileFlag,
+  MixtureModelling
+} 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("VesselLeakLinkedRunCalculation - VLR_160", () => {
+  it("should run the calculation and validate regression outputs", async () => {
+    const material = new Material({
+      name: "CHLORINE",
+      components: [new MaterialComponent({ name: "CHLORINE", moleFraction: 1.0 })],
+      componentCount: 1
+    });
+
+    const loadMassInventory = new LoadMassInventoryVesselForLeakScenarioCalculation(
+      material,
+      1e4,
+      6e5,
+      250,
+      0.08,
+      1.0,
+      0.0
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_leak_scenario_calculation...");
+    const loadResultCode = await loadMassInventory.run();
+
+    if (loadMassInventory.messages.length > 0) {
+      console.log("Messages:");
+      loadMassInventory.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(loadResultCode).toBe(ResultCode.SUCCESS);
+
+    if (loadResultCode === ResultCode.SUCCESS) {
+      console.log(`SUCCESS: load_mass_inventory_vessel_for_leak_scenario_calculation (${loadMassInventory.calculationElapsedTime}ms)`);
+    }
+
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const substrate = new Substrate();
+
+    const dispersionParameters = [
+      new DispersionParameters({ averagingTime: 600.0 }),
+      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 vessel = loadMassInventory.vessel!;
+    vessel.state!.mixtureModelling = MixtureModelling.MC_MULTIPLE_AEROSOL;
+
+    const linkedCalc = new VesselLeakLinkedRunCalculation(
+      vessel,
+      loadMassInventory.leak!,
+      new DischargeParameters(),
+      substrate,
+      weather,
+      dispersionParameters,
+      dispersionParameters.length,
+      0.0,
+      flammableParameters,
+      explosionParameters,
+      dispersionOutputConfigsFlammable,
+      dispersionOutputConfigsFlammable.length,
+      dispersionOutputConfigsToxic,
+      dispersionOutputConfigsToxic.length,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length,
+      explosionOutputConfigs,
+      explosionOutputConfigs.length,
+      explosionConfinedVolumes,
+      explosionConfinedVolumes.length
+    );
+
+    console.log("Running vessel_leak_linked_run_calculation...");
+    const resultCode = await linkedCalc.run();
+
+    if (linkedCalc.messages.length > 0) {
+      console.log("Messages:");
+      linkedCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    if (resultCode === ResultCode.SUCCESS) {
+      expect(Math.abs(linkedCalc.dischargeRecord!.massFlow! - 121.95136629549849) / 121.95136629549849).toBeLessThan(1e-3);
+      expect(linkedCalc.jetFireFlameResult!.flameLength!).toBe(0.0);
+      expect(linkedCalc.poolFireFlameResult!.flameDiameter!).toBe(0.0);
+      expect(linkedCalc.flamConcContourPoints!.length).toBe(0);
+      expect(linkedCalc.toxicConcContourPoints!.length).toBe(665);
+      expect(linkedCalc.areaFootprintFlamConc![0]).toBe(0.0);
+      expect(Math.abs(linkedCalc.areaFootprintToxicConc![0] - 688622.679542524) / 688622.679542524).toBeLessThan(1e-3);
+      expect(linkedCalc.areaContourJet![0]).toBe(0.0);
+      expect(linkedCalc.areaContourPool![0]).toBe(0.0);
+      expect(linkedCalc.explosionOverpressureResults![0].explodedMass!).toBe(0.0);
+      expect(linkedCalc.explosionOverpressureResults![0].maximumDistance!).toBe(0.0);
+
+      console.log(`Mass flow = ${linkedCalc.dischargeRecord!.massFlow}`);
+      console.log(`Flame length = ${linkedCalc.jetFireFlameResult!.flameLength}`);
+      console.log(`Flame diameter = ${linkedCalc.poolFireFlameResult!.flameDiameter}`);
+      console.log(`Length of the dispersion flammable contour array = ${linkedCalc.flamConcContourPoints!.length}`);
+      console.log(`Length of the dispersion toxic contour array = ${linkedCalc.toxicConcContourPoints!.length}`);
+      console.log(`Area of the flammable cloud = ${linkedCalc.areaFootprintFlamConc![0]}`);
+      console.log(`Area of the toxic cloud = ${linkedCalc.areaFootprintToxicConc![0]}`);
+      console.log(`Area of the jet fire = ${linkedCalc.areaContourJet![0]}`);
+      console.log(`Area of the pool = ${linkedCalc.areaContourPool![0]}`);
+      console.log(`Flammable mass = ${linkedCalc.explosionOverpressureResults![0].explodedMass}`);
+      console.log(`Explosion maximum distance = ${linkedCalc.explosionOverpressureResults![0].maximumDistance}`);
+
+      console.log(`SUCCESS: vessel_leak_linked_run_calculation (${linkedCalc.calculationElapsedTime}ms)`);
+    }
+  });
+});

package/tests/linked-runners/vessel-line-rupture-linked-run/test-vlr-161.test.ts

@@ -0,0 +1,161 @@
+import { VesselLineRuptureLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLineRuptureScenarioCalculation } from "../../../src/calculations/utilities";
+import {
+  Material,
+  MaterialComponent,
+  Weather,
+  Substrate,
+  DischargeParameters,
+  FlammableParameters,
+  DispersionParameters,
+  ExplosionParameters,
+  ExplosionOutputConfig,
+  ExplosionConfinedVolume,
+  FlammableOutputConfig,
+  DispersionOutputConfig,
+} 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("VesselLineRuptureLinkedRunCalculation - VLR_161", () => {
+  it("should run the calculation and validate regression outputs", async () => {
+    // Define the material
+    const material = new Material({
+      name: "AMMONIA",
+      components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    // Create the line rupture scenario calculation
+    const loadCalc = new LoadMassInventoryVesselForLineRuptureScenarioCalculation(
+      material,
+      1e3,
+      11e5,
+      250,
+      0.5,
+      10.0, 
+      1.0,
+      0.35
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_line_rupture_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);
+    console.log(`SUCCESS: load_mass_inventory_vessel_for_line_rupture_scenario_calculation (${loadCalc.calculationElapsedTime}ms)`);
+
+    // Define weather and substrate
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_B,
+      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 ruptureCalc = new VesselLineRuptureLinkedRunCalculation(
+      loadCalc.vessel!,
+      loadCalc.lineRupture!,
+      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_line_rupture_linked_run_calculation...");
+    const resultCode = await ruptureCalc.run();
+
+    if (ruptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      ruptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    if (resultCode === ResultCode.SUCCESS) {
+      expect(Math.abs(ruptureCalc.dischargeRecord!.massFlow! - 4854.025293797943) / 4854.025293797943).toBeLessThan(1e-3);
+      expect(Math.abs(ruptureCalc.jetFireFlameResult!.flameLength! - 662.3022367949528) / 662.3022367949528).toBeLessThan(1e-3);
+      expect(Math.abs(ruptureCalc.poolFireFlameResult!.flameDiameter! - 12.537047386169434) / 12.537047386169434).toBeLessThan(1e-3);
+      expect(ruptureCalc.flamConcContourPoints!.length).toBe(0);
+      expect(ruptureCalc.toxicConcContourPoints!.length).toBe(708);
+      expect(ruptureCalc.areaFootprintFlamConc![0]).toBe(0.0);
+      expect(Math.abs(ruptureCalc.areaFootprintToxicConc![0] - 818151.5234553284) / 818151.5234553284).toBeLessThan(1e-3);
+      expect(Math.abs(ruptureCalc.areaContourJet![0] - 873022.314841369) / 873022.314841369).toBeLessThan(1e-3);
+      expect(Math.abs(ruptureCalc.areaContourPool![0] - 604.0546926186413) / 604.0546926186413).toBeLessThan(1e-3);
+      expect(Math.abs(ruptureCalc.explosionOverpressureResults![0].explodedMass! - 468.4280045824483) / 468.4280045824483).toBeLessThan(1e-3);
+      expect(Math.abs(ruptureCalc.explosionOverpressureResults![0].maximumDistance! - 340.816800123033) / 340.816800123033).toBeLessThan(1e-3);
+
+      console.log(`Mass flow = ${ruptureCalc.dischargeRecord!.massFlow}`);
+      console.log(`Flame length = ${ruptureCalc.jetFireFlameResult!.flameLength}`);
+      console.log(`Flame diameter = ${ruptureCalc.poolFireFlameResult!.flameDiameter}`);
+      console.log(`Flam contour length = ${ruptureCalc.flamConcContourPoints!.length}`);
+      console.log(`Toxic contour length = ${ruptureCalc.toxicConcContourPoints!.length}`);
+      console.log(`Flam area = ${ruptureCalc.areaFootprintFlamConc![0]}`);
+      console.log(`Toxic area = ${ruptureCalc.areaFootprintToxicConc![0]}`);
+      console.log(`Jet area = ${ruptureCalc.areaContourJet![0]}`);
+      console.log(`Pool area = ${ruptureCalc.areaContourPool![0]}`);
+      console.log(`Exploded mass = ${ruptureCalc.explosionOverpressureResults![0].explodedMass}`);
+      console.log(`Explosion max distance = ${ruptureCalc.explosionOverpressureResults![0].maximumDistance}`);
+      console.log(`SUCCESS: vessel_line_rupture_linked_run_calculation (${ruptureCalc.calculationElapsedTime}ms)`);
+    }
+  });
+});

package/tests/linked-runners/vessel-line-rupture-linked-run/test-vlr-162.test.ts

@@ -0,0 +1,167 @@
+import { VesselLineRuptureLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLineRuptureScenarioCalculation } from "../../../src/calculations/utilities";
+import {
+    Material,
+    MaterialComponent,
+    Weather,
+    Substrate,
+    DischargeParameters,
+    FlammableParameters,
+    ExplosionParameters,
+    ExplosionConfinedVolume,
+    DispersionParameters,
+    DispersionOutputConfig,
+    FlammableOutputConfig,
+    ExplosionOutputConfig,
+  } from "../../../src/entities";
+  import {
+    AtmosphericStabilityClass,
+    WindProfileFlag,
+    SpecialConcentration,
+    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("VesselLineRuptureLinkedRunCalculation - VLR_162", () => {
+    it("should run and validate regression outputs for methane/ethane mix", 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 loadCalc = new LoadMassInventoryVesselForLineRuptureScenarioCalculation(
+        material,
+        1e5,       // mass
+        11e5,       // pressure
+        250,        // temperature
+        0.5,        // pipe diameter
+        10.0,       // pipe length
+        100.0,      // release elevation
+        0.0         // release angle
+      );
+  
+      console.log("Running load_mass_inventory_vessel_for_line_rupture_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);
+      expect(Math.abs(loadCalc.vessel!.diameter! - 27.049130317992706) / 27.049130317992706).toBeLessThan(1e-3);
+      expect(Math.abs(loadCalc.vessel!.location!.z! - 86.47543484100365) / 86.47543484100365).toBeLessThan(1e-3);
+      expect(Math.abs(loadCalc.lineRupture!.pipeDiameter! - 0.5) / 0.5).toBeLessThan(1e-3);
+      expect(Math.abs(loadCalc.lineRupture!.pipeHeightFraction! - 0.5) / 0.5).toBeLessThan(1e-3);
+      console.log(`SUCCESS: load_mass_inventory_vessel_for_line_rupture_scenario_calculation (${loadCalc.calculationElapsedTime}ms)`);
+  
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+      });
+  
+      const substrate = new Substrate();
+  
+      const dispersionParams = [
+        new DispersionParameters({ averagingTime: 18.75, lflFractionToStop: 0.2 }),
+        new DispersionParameters({ averagingTime: 18.75 }),
+      ];
+  
+      const dispersionOutputConfigsFlammable = [
+        new DispersionOutputConfig({
+          specialConcentration: SpecialConcentration.LFL_FRACTION,
+          elevation: 100.0,
+          lflFractionValue: 0.2,
+        }),
+      ];
+  
+      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 ruptureCalc = new VesselLineRuptureLinkedRunCalculation(
+        loadCalc.vessel!,
+        loadCalc.lineRupture!,
+        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_line_rupture_linked_run_calculation...");
+      const resultCode = await ruptureCalc.run();
+  
+      if (ruptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      if (resultCode === ResultCode.SUCCESS) {
+        expect(Math.abs(ruptureCalc.dischargeRecord!.massFlow! - 369.13836776138595) / 369.13836776138595).toBeLessThan(1e-3);
+        expect(Math.abs(ruptureCalc.jetFireFlameResult!.flameLength! - 132.810385487078) / 132.810385487078).toBeLessThan(1e-3);
+        expect(ruptureCalc.poolFireFlameResult!.flameDiameter!).toBe(0.0);
+        expect(ruptureCalc.flamConcContourPoints!.length).toBe(597);
+        expect(ruptureCalc.toxicConcContourPoints!.length).toBe(873);
+        expect(Math.abs(ruptureCalc.areaFootprintFlamConc![0] - 16798.58475657922) / 16798.58475657922).toBeLessThan(1e-3);
+        expect(Math.abs(ruptureCalc.areaFootprintToxicConc![0] - 21559290.626672193) / 21559290.626672193).toBeLessThan(1e-3);
+        expect(Math.abs(ruptureCalc.areaContourJet![0] - 57212.96926113445) / 57212.96926113445).toBeLessThan(1e-3);
+        expect(ruptureCalc.areaContourPool![0]).toBe(0.0);
+        expect(Math.abs(ruptureCalc.explosionOverpressureResults![0].explodedMass! - 411.4357378379431) / 411.4357378379431).toBeLessThan(1e-3);
+        expect(Math.abs(ruptureCalc.explosionOverpressureResults![0].maximumDistance! - 593.064103906056) / 593.064103906056).toBeLessThan(1e-3);
+  
+        console.log(`Mass flow = ${ruptureCalc.dischargeRecord!.massFlow}`);
+        console.log(`Flame length = ${ruptureCalc.jetFireFlameResult!.flameLength}`);
+        console.log(`Flame diameter = ${ruptureCalc.poolFireFlameResult!.flameDiameter}`);
+        console.log(`Flam contour length = ${ruptureCalc.flamConcContourPoints!.length}`);
+        console.log(`Toxic contour length = ${ruptureCalc.toxicConcContourPoints!.length}`);
+        console.log(`Flam area = ${ruptureCalc.areaFootprintFlamConc![0]}`);
+        console.log(`Toxic area = ${ruptureCalc.areaFootprintToxicConc![0]}`);
+        console.log(`Jet area = ${ruptureCalc.areaContourJet![0]}`);
+        console.log(`Pool area = ${ruptureCalc.areaContourPool![0]}`);
+        console.log(`Exploded mass = ${ruptureCalc.explosionOverpressureResults![0].explodedMass}`);
+        console.log(`Explosion max distance = ${ruptureCalc.explosionOverpressureResults![0].maximumDistance}`);
+        console.log(`SUCCESS: vessel_line_rupture_linked_run_calculation (${ruptureCalc.calculationElapsedTime}ms)`);
+      }
+    });
+  });
+  

package/tests/linked-runners/vessel-line-rupture-linked-run/test-vlr-163.test.ts

@@ -0,0 +1,177 @@
+import { VesselLineRuptureLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLineRuptureScenarioCalculation } from "../../../src/calculations/utilities";
+  import {
+    Material,
+    MaterialComponent,
+    Substrate,
+    Bund,
+    Weather,
+    DispersionParameters,
+    DispersionOutputConfig,
+    FlammableParameters,
+    FlammableOutputConfig,
+    ExplosionParameters,
+    ExplosionOutputConfig,
+    ExplosionConfinedVolume,
+    DischargeParameters,
+  } from "../../../src/entities";
+  import {
+    ResultCode,
+    AtmosphericStabilityClass,
+    WindProfileFlag,
+    SpecialConcentration,
+  } 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("VesselLineRuptureLinkedRunCalculation - VLR_163", () => {
+    it("should match expected outputs for N-HEXANE scenario", async () => {
+      const material = new Material({
+        name: "N-HEXANE",
+        components: [new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const loadCalc = new LoadMassInventoryVesselForLineRuptureScenarioCalculation(
+        material,
+        9876,
+        7e5,
+        250,
+        0.1,
+        7.5,
+        0.0,
+        0.0
+      );
+  
+      console.log("Running load_mass_inventory_vessel_for_line_rupture_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! - 3.0323298714998153) / 3.0323298714998153).toBeLessThan(1e-3);
+        expect(Math.abs(loadCalc.vessel!.location!.z! + 2.7170445294165657) / 2.7170445294165657).toBeLessThan(1e-3);
+        expect(Math.abs(loadCalc.lineRupture!.pipeDiameter! - 0.1) / 0.1).toBeLessThan(1e-3);
+        expect(Math.abs(loadCalc.lineRupture!.pipeHeightFraction! - 0.8960253813259087) / 0.8960253813259087).toBeLessThan(1e-3);
+        console.log(`SUCCESS: load_mass_inventory_vessel_for_line_rupture_scenario_calculation (${loadCalc.calculationElapsedTime}ms)`);
+      }
+  
+      const weather = new Weather({
+        windSpeed: 2.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_CD,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+      });
+  
+      const substrate = new Substrate({
+        bund: new Bund({
+          specifyBund: true,
+          bundHeight: 2.0,
+          bundDiameter: 20.0,
+        }),
+      });
+  
+      const dispersionParams = [
+        new DispersionParameters({
+          averagingTime: 18.75,
+          lflFractionToStop: 0.15,
+        }),
+        new DispersionParameters({
+          averagingTime: 18.75,
+        }),
+      ];
+  
+      const dispersionOutputConfigsFlammable = [
+        new DispersionOutputConfig({
+          specialConcentration: SpecialConcentration.LFL_FRACTION,
+          lflFractionValue: 0.15,
+          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 ruptureCalc = new VesselLineRuptureLinkedRunCalculation(
+        loadCalc.vessel!,
+        loadCalc.lineRupture!,
+        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_line_rupture_linked_run_calculation...");
+      const resultCode = await ruptureCalc.run();
+  
+      if (ruptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      if (resultCode === ResultCode.SUCCESS) {
+        expect(Math.abs(ruptureCalc.dischargeRecord!.massFlow! - 131.73664600034286) / 131.73664600034286).toBeLessThan(1e-3);
+        expect(ruptureCalc.jetFireFlameResult!.flameLength!).toBe(0.0);
+        expect(Math.abs(ruptureCalc.poolFireFlameResult!.flameDiameter! - 20.00299644470215) / 20.00299644470215).toBeLessThan(1e-3);
+        expect(ruptureCalc.flamConcContourPoints!.length).toBe(563);
+        expect(ruptureCalc.toxicConcContourPoints!.length).toBe(623);
+        expect(Math.abs(ruptureCalc.areaFootprintFlamConc![0] - 585.0061568126835) / 585.0061568126835).toBeLessThan(1e-3);
+        expect(Math.abs(ruptureCalc.areaFootprintToxicConc![0] - 12934.3464614692) / 12934.3464614692).toBeLessThan(1e-3);
+        expect(ruptureCalc.areaContourJet![0]).toBe(0.0);
+        expect(Math.abs(ruptureCalc.areaContourPool![0] - 4498.14606654948) / 4498.14606654948).toBeLessThan(1e-3);
+        expect(ruptureCalc.explosionOverpressureResults![0].explodedMass!).toBe(0.0);
+        expect(ruptureCalc.explosionOverpressureResults![0].maximumDistance!).toBe(0.0);
+  
+        console.log(`Mass flow = ${ruptureCalc.dischargeRecord!.massFlow}`);
+        console.log(`Flame length = ${ruptureCalc.jetFireFlameResult!.flameLength}`);
+        console.log(`Flame diameter = ${ruptureCalc.poolFireFlameResult!.flameDiameter}`);
+        console.log(`Flam contour length = ${ruptureCalc.flamConcContourPoints!.length}`);
+        console.log(`Toxic contour length = ${ruptureCalc.toxicConcContourPoints!.length}`);
+        console.log(`Flam area = ${ruptureCalc.areaFootprintFlamConc![0]}`);
+        console.log(`Toxic area = ${ruptureCalc.areaFootprintToxicConc![0]}`);
+        console.log(`Jet area = ${ruptureCalc.areaContourJet![0]}`);
+        console.log(`Pool area = ${ruptureCalc.areaContourPool![0]}`);
+        console.log(`Exploded mass = ${ruptureCalc.explosionOverpressureResults![0].explodedMass}`);
+        console.log(`Explosion max distance = ${ruptureCalc.explosionOverpressureResults![0].maximumDistance}`);
+        console.log(`SUCCESS: vessel_line_rupture_linked_run_calculation (${ruptureCalc.calculationElapsedTime}ms)`);
+      }
+    });
+  });
+