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

package/tests/late-explosion-calculation/testCase77.test.ts

@@ -0,0 +1,175 @@
+import { Material, MaterialComponent, State, Vessel, LineRupture, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { LateExplosionToOPLevelsCalculation, LateExplosionCalculation } from "../../src/calculations/lateExplosion";
+import { ResultCode, AtmosphericStabilityClass, SpecialConcentration, 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("Integrated Explosion Scenario - Test Case 77", () => {
+    test("should run the full explosion scenario and perform regression check", async () => {
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 260.0,
+            pressure: 5e5,
+            liquidFraction: 1.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "ETHANE_METHANE_HY",
+            components: [
+                new MaterialComponent({ name: "ETHANE", moleFraction: 0.15 }),
+                new MaterialComponent({ name: "METHANE", moleFraction: 0.8 }),
+                new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.05 })
+            ],
+            componentCount: 3
+        });
+
+        // Create and run vessel state calculation
+        const vesselStateCalc = new VesselStateCalculation(material, state);
+        
+        console.log("Running vesselStateCalculation...");
+        let resultCode = await vesselStateCalc.run();
+
+        if (vesselStateCalc.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+        // Create vessel (sphere with 3m diameter)
+        const vessel = new Vessel({
+            state,
+            material,
+            vesselConditions: vesselStateCalc.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_SPHERE,
+            diameter: 3
+        });
+
+        // Create line rupture
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.5,
+            pipeLength: 1.0,
+            pipeHeightFraction: 0.5
+        });
+
+        // Create and run vessel line rupture calculation
+        const lineRuptureCalc = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        
+        console.log("Running vesselLineRuptureCalculation...");
+        resultCode = await lineRuptureCalc.run();
+
+        if (lineRuptureCalc.messages.length > 0) {
+            console.log("Messages:");
+            lineRuptureCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vesselLineRuptureCalculation (${lineRuptureCalc.calculationElapsedTime}ms)`);
+        console.log(`vesselLineRuptureCalculation.dischargeResult.releaseMass: ${lineRuptureCalc.dischargeResult!.releaseMass} [kg]`);
+
+        const exitMaterial = lineRuptureCalc.exitMaterial!;
+
+        // Define weather
+        const weather = new Weather({
+            windSpeed: 1.5,
+            stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+            windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+        });
+
+        // Define substrate
+        const substrate = new Substrate();
+
+        // Create and run dispersion calculation
+        const dispersionCalc = new DispersionCalculation(
+            exitMaterial,
+            substrate,
+            lineRuptureCalc.dischargeResult!,
+            lineRuptureCalc.dischargeRecords!,
+            lineRuptureCalc.dischargeRecords!.length,
+            weather,
+            new DispersionParameters(),
+            0.0
+        );
+
+        console.log("Running dispersionCalculation...");
+        resultCode = await dispersionCalc.run();
+
+        if (dispersionCalc.messages.length > 0) {
+            console.log("Messages:");
+            dispersionCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: dispersionCalculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+        // Define explosion configurations
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: 0.0,
+            specialConcentration: SpecialConcentration.MIN
+        });
+
+        const explosionParams = new ExplosionParameters({ 
+            explosionUniformStrength: 8.0 
+        });
+
+        const explosionOutputConfigs = new ExplosionOutputConfig({ overpressureLevel: 20680, meConfinedMethod: 1 });
+
+        const explosionConfinedVolumes = [
+            new ExplosionConfinedVolume({ confinedVolume: 100, confinedStrength: 10 }),
+            new ExplosionConfinedVolume({ confinedVolume: 25, confinedStrength: 7 })
+        ];
+
+        // Create and run explosion calculation
+        const explosionCalc = new LateExplosionCalculation(
+            exitMaterial,
+            dispersionCalc.scalarUdmOutputs!,
+            weather,
+            dispersionCalc.dispersionRecords!,
+            dispersionCalc.dispersionRecords!.length,
+            substrate,
+            dispersionOutputConfig,
+            explosionOutputConfigs,
+            explosionParams,
+            explosionConfinedVolumes,
+            explosionConfinedVolumes.length,
+            new DispersionParameters()
+        );
+
+        console.log("Running lateExplosionCalculation...");
+        resultCode = await explosionCalc.run();
+
+        if (explosionCalc.messages.length > 0) {
+            console.log("Messages:");
+            explosionCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression checks
+        const result = explosionCalc.explosionUnifConfOverpressureResult!;
+        const expectedMass = 31.04536142489174;
+        const expectedTime = 1.1859455812737545;
+        const expectedDistance = 74.63993525895671;
+
+        const massError = Math.abs((result.explodedMass! - expectedMass) / expectedMass);
+        const timeError = Math.abs((result.ignitionTime! - expectedTime) / expectedTime);
+        const distanceError = Math.abs((result.maximumDistance! - expectedDistance) / expectedDistance);
+
+        expect(massError).toBeLessThan(1e-3);
+        expect(timeError).toBeLessThan(1e-3);
+        expect(distanceError).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: lateExplosionCalculation (${explosionCalc.calculationElapsedTime}ms)`);
+    });
+});

package/tests/late-explosion-calculation/testCase78.test.ts

@@ -0,0 +1,175 @@
+import { Material, MaterialComponent, State, Vessel, LineRupture, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { LateExplosionCalculation } from "../../src/calculations/lateExplosion";
+import { ResultCode, AtmosphericStabilityClass, SpecialConcentration, VesselShape, MEConfinedMethod, 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("Integrated Explosion Scenario - Test Case 78", () => {
+    test("should run the full explosion scenario and perform regression check", 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 })]
+        });
+
+        // Create and run vessel state calculation
+        const vesselStateCalc = new VesselStateCalculation(material, state);
+        
+        console.log("Running vesselStateCalculation...");
+        let resultCode = await vesselStateCalc.run();
+
+        if (vesselStateCalc.messages.length > 0) {
+            console.log("Messages:");
+            vesselStateCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+        // Create vessel (horizontal cylinder with 2m diameter and 5m length)
+        const vessel = new Vessel({
+            state,
+            material,
+            vesselConditions: vesselStateCalc.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.HORIZONTAL_CYLINDER,
+            diameter: 2,
+            length: 5
+        });
+
+        // Create line rupture
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.1,
+            pipeLength: 5.0,
+            pipeHeightFraction: 0.3
+        });
+
+        // Create and run vessel line rupture calculation
+        const vesselLineRuptureCalc = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        
+        console.log("Running vesselLineRuptureCalculation...");
+        resultCode = await vesselLineRuptureCalc.run();
+
+        if (vesselLineRuptureCalc.messages.length > 0) {
+            console.log("Messages:");
+            vesselLineRuptureCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vesselLineRuptureCalculation (${vesselLineRuptureCalc.calculationElapsedTime}ms)`);
+        console.log(`vesselLineRuptureCalculation.dischargeResult.releaseMass: ${vesselLineRuptureCalc.dischargeResult!.releaseMass} [kg]`);
+
+        const exitMaterial = vesselLineRuptureCalc.exitMaterial!;
+
+        // Define weather
+        const weather = new Weather({
+            windSpeed: 1.5,
+            stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+            windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+        });
+
+        // Define substrate
+        const substrate = new Substrate();
+
+        // Create and run dispersion calculation
+        const dispersionCalc = new DispersionCalculation(
+            exitMaterial,
+            substrate,
+            vesselLineRuptureCalc.dischargeResult!,
+            vesselLineRuptureCalc.dischargeRecords!,
+            vesselLineRuptureCalc.dischargeRecords!.length,
+            weather,
+            new DispersionParameters(),
+            0.0
+        );
+
+        console.log("Running dispersionCalculation...");
+        resultCode = await dispersionCalc.run();
+
+        if (dispersionCalc.messages.length > 0) {
+            console.log("Messages:");
+            dispersionCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: dispersionCalculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+        // Define explosion configurations
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: 0.0,
+            specialConcentration: SpecialConcentration.MIN
+        });
+
+        const explosionParams = new ExplosionParameters({ 
+            explosionUniformStrength: 10.0 
+        });
+
+        const explosionOutputConfig = new ExplosionOutputConfig({
+            overpressureLevel: 8272,
+            meConfinedMethod: MEConfinedMethod.USER_DEFINED
+        });
+
+        const explosionConfinedVolumes = [
+            new ExplosionConfinedVolume({ confinedVolume: 167, confinedStrength: 9 }),
+            new ExplosionConfinedVolume({ confinedVolume: 33, confinedStrength: 10 }),
+            new ExplosionConfinedVolume({ confinedVolume: 300, confinedStrength: 6 })
+        ];
+
+        // Create and run explosion calculation
+        const explosionCalc = new LateExplosionCalculation(
+            exitMaterial,
+            dispersionCalc.scalarUdmOutputs!,
+            weather,
+            dispersionCalc.dispersionRecords!,
+            dispersionCalc.dispersionRecords!.length,
+            substrate,
+            dispersionOutputConfig,
+            explosionOutputConfig,
+            explosionParams,
+            explosionConfinedVolumes,
+            explosionConfinedVolumes.length,
+            new DispersionParameters()
+        );
+
+        console.log("Running lateExplosionCalculation...");
+        resultCode = await explosionCalc.run();
+
+        if (explosionCalc.messages.length > 0) {
+            console.log("Messages:");
+            explosionCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        // Regression checks
+        const result = explosionCalc.explosionUnifConfOverpressureResult!;
+        const expectedMass = 1081.1427088939722;
+        const expectedTime = 96.0561524166236;
+        const expectedDistance = 272.08706213990797;
+
+        const massError = Math.abs((result.explodedMass! - expectedMass) / expectedMass);
+        const timeError = Math.abs((result.ignitionTime! - expectedTime) / expectedTime);
+        const distanceError = Math.abs((result.maximumDistance! - expectedDistance) / expectedDistance);
+
+        expect(massError).toBeLessThan(1e-3);
+        expect(timeError).toBeLessThan(1e-3);
+        expect(distanceError).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: lateExplosionCalculation (${explosionCalc.calculationElapsedTime}ms)`);
+    });
+});

package/tests/lethality-distance-calculation/testCase60.test.ts

@@ -0,0 +1,142 @@
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { LethalityDistanceCalculation } from "../../src/calculations/toxics";
+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("Lethality Distance Calculation - Test Case 60", () => {
+    test("should perform the full chain of calculations and validate results", async () => {
+      const materialName = "CARBON DIOXIDE (TOXIC)";
+      const stateTemperature = 280.0;
+      const statePressure = 8.0e6;
+      const liquidFraction = 0.8;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 5.0;
+      const liquidFillFractionByVolume = 0.8;
+      const surfaceType = SurfaceType.LAND;
+      const surfaceRoughness = 0.2;
+      const windSpeed = 5.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_A_;
+      const endPointConcentration = 0.0;
+      const specifyBund = true;
+      const bundHeight = 1.0;
+      const bundDiameter = 8.0;
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      console.log("Running vessel_state_calculation...");
+      let resultCode = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume,
+        shape: vesselShape,
+        diameter: vesselDiameter,
+        vesselConditions: vesselStateCalculation.vesselConditions!,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const vesselCatastrophicRuptureCalculation = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+  
+      console.log("Running vessel_catastrophic_rupture_calculation...");
+      resultCode = await vesselCatastrophicRuptureCalculation.run();
+  
+      if (vesselCatastrophicRuptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselCatastrophicRuptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselCatastrophicRuptureCalculation.calculationElapsedTime}ms)`);
+  
+      const bund = new Bund({ specifyBund, bundHeight, bundDiameter });
+      const substrate = new Substrate({ bund, surfaceType, surfaceRoughness });
+      const weather = new Weather({ windSpeed: windSpeed, stabilityClass: stabilityClass, windProfileFlag: windProfileFlag });
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        substrate,
+        vesselCatastrophicRuptureCalculation.dischargeResult!,
+        vesselCatastrophicRuptureCalculation.dischargeRecords!,
+        vesselCatastrophicRuptureCalculation.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration,
+      );
+  
+      console.log("Running dispersion_calculation...");
+      resultCode = await dispersionCalculation.run();
+  
+      if (dispersionCalculation.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({ concentration: endPointConcentration });
+  
+      const lethalityDistanceCalculation = new LethalityDistanceCalculation(
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        dispersionParameters,
+      );
+  
+      console.log("Running lethality_distance_calculation...");
+      resultCode = await lethalityDistanceCalculation.run();
+  
+      if (lethalityDistanceCalculation.messages.length > 0) {
+        console.log("Messages:");
+        lethalityDistanceCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+      expect(lethalityDistanceCalculation.toxicRecords!.length).toBe(1830);
+  
+      if (lethalityDistanceCalculation.toxicRecords!.length > 0) {
+        const last = lethalityDistanceCalculation.toxicRecords![lethalityDistanceCalculation.toxicRecords!.length - 1];
+        const expectedLastToxicResult = 0.0004837476263379603;
+        const relativeError = Math.abs((last.toxicResult! - expectedLastToxicResult) / expectedLastToxicResult);
+        expect(relativeError).toBeLessThan(1e-3);
+      }
+  
+      console.log(`SUCCESS: lethality_distance_calculation (${lethalityDistanceCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+  

package/tests/linked-runners/user-defined-source-linked-run/test-uds-153.test.ts

@@ -0,0 +1,121 @@
+import { UserDefinedSourceLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { Material, MaterialComponent, Weather, Substrate, DischargeParameters, FlammableParameters, DispersionParameters, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume, FlammableOutputConfig, DispersionOutputConfig, State, DischargeRecord, DischargeResult } from "../../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, SpecialConcentration, WindProfileFlag, Phase, FluidSpec, DynamicType} 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("UserDefinedSourceLinkedRunCalculation - VLR_153", () => {
+    it("should run the calculation and validate regression outputs", async () => {
+      const material = new Material({name: "AMMONIA", components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })], componentCount: 1});
+  
+      const weather = new Weather({ windSpeed: 5.0, stabilityClass: AtmosphericStabilityClass.STABILITY_B, windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE});
+  
+      const substrate = new Substrate({surfaceRoughness: 0.01});
+  
+      const dispersionParameters = [
+        new DispersionParameters({averagingTime: 18.75}),
+        new DispersionParameters({averagingTime: 600.0})
+      ];
+  
+      const dispersionOutputConfigsFlammable = [
+        new DispersionOutputConfig({ specialConcentration: SpecialConcentration.LFL_FRACTION, elevation: 0.0})
+      ];
+  
+      const dispersionOutputConfigsToxic = [
+        new DispersionOutputConfig({ specialConcentration: SpecialConcentration.NOT_DEFINED, elevation: 0.0, concentration: 5e-5})
+      ];
+  
+      const flammableParameters = new FlammableParameters();
+      const flammableOutputConfigs = [new FlammableOutputConfig()];
+  
+      const explosionParameters = new ExplosionParameters();
+      const explosionOutputConfigs = [new ExplosionOutputConfig()];
+      const explosionConfinedVolumes = [new ExplosionConfinedVolume()];
+  
+      const dischargeRecord = new DischargeRecord({
+        massFlow: 50.0,
+        time: 600.0,
+        finalState: new State({temperature: 200.0, pressure: 101325.0, flashFlag: FluidSpec.TP, liquidFraction: 1.0}),
+        orificeState: new State({temperature: 300.0, pressure: 101325.0, liquidFraction: 1.0}),
+        orificeVelocity: 0.0,
+        storageState: new State({temperature: 300.0, pressure: 101325.0, liquidFraction: 1.0}),
+        finalVelocity: 60.0,
+        dropletDiameter: 0.0009
+    });
+  
+      const dischargeResult = new DischargeResult({
+        releaseMass: 3000.0,
+        height: 0.0,
+        angle: 0.0,
+        holeDiameter: 0.3,
+        releaseType: DynamicType.CONTINUOUS,
+        preDilutionAirRate: 0.0,
+        expansionEnergy: 6000.0
+    });
+  
+      const calculation = new UserDefinedSourceLinkedRunCalculation(
+        material,
+        dischargeResult,
+        [dischargeRecord],
+        1,
+        Phase.LIQUID,
+        new DischargeParameters(),
+        substrate,
+        weather,
+        dispersionParameters,
+        2,
+        0.0,
+        flammableParameters,
+        explosionParameters,
+        dispersionOutputConfigsFlammable,
+        1,
+        dispersionOutputConfigsToxic,
+        1,
+        flammableOutputConfigs,
+        1,
+        explosionOutputConfigs,
+        1,
+        explosionConfinedVolumes,
+        1
+      );
+  
+      console.log("Running user_defined_source_linked_run_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);
+  
+      if (resultCode === ResultCode.SUCCESS) {
+        expect(calculation.jetFireFlameResult!.flameLength).toBe(0.0);
+        expect(
+          Math.abs(calculation.poolFireFlameResult!.flameDiameter! - 87.63609313964844) / 87.63609313964844
+        ).toBeLessThan(1e-3);
+        expect(calculation.flamConcContourPoints!.length).toBe(0);
+        expect(calculation.toxicConcContourPoints!.length).toBe(637);
+        expect(calculation.areaFootprintFlamConc![0]).toBe(0.0);
+        expect(
+          Math.abs(calculation.areaFootprintToxicConc![0] - 940696.3465428002) / 940696.3465428002
+        ).toBeLessThan(1e-3);
+        expect(calculation.areaContourJet![0]).toBe(0.0);
+        expect(
+          Math.abs(calculation.areaContourPool![0] - 25251.117265661516) / 25251.117265661516
+        ).toBeLessThan(1e-3);
+        expect(calculation.explosionOverpressureResults![0].explodedMass).toBe(0.0);
+        expect(calculation.explosionOverpressureResults![0].maximumDistance).toBe(0.0);
+  
+        console.log(`SUCCESS: user_defined_source_linked_run_calculation (${calculation.calculationElapsedTime}ms)`);
+      }
+    });
+  });
+