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

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

@@ -0,0 +1,176 @@
+import { Material, MaterialComponent, State, Vessel, Weather, LineRupture, 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 } 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 50", () => {
+    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: 3e5,
+        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 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: 10.0 
+      });
+
+      const explosionOutputConfigs = [
+        new ExplosionOutputConfig({ overpressureLevel: 1034 }),
+        new ExplosionOutputConfig({ overpressureLevel: 2068 }),
+        new ExplosionOutputConfig({ overpressureLevel: 8272 })
+      ];
+
+      const explosionConfinedVolumes = [
+        new ExplosionConfinedVolume(),
+        new ExplosionConfinedVolume()
+      ];
+
+      // Create and run explosion calculation
+      const explosionCalc = new LateExplosionToOPLevelsCalculation(
+        exitMaterial,
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        explosionOutputConfigs,
+        explosionOutputConfigs.length,
+        explosionParams,
+        explosionConfinedVolumes,
+        explosionConfinedVolumes.length,
+        new DispersionParameters()
+      );
+
+      console.log("Running lateExplosionToOPLevelsCalculation...");
+      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.explosionUnifConfOverpressureResults![0];
+      const expectedMass = 1081.1427088939722;
+      const expectedTime = 96.0561524166236;
+      const expectedDistance = 1042.2068518145015;
+
+      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: lateExplosionToOPLevelsCalculation (${explosionCalc.calculationElapsedTime}ms)`);
+    });
+});

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

@@ -0,0 +1,166 @@
+import { Material, MaterialComponent, State, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselLineRuptureCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { 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 74", () => {
+    test("should run the full explosion scenario and perform regression check", async () => {
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "N-HEXANE",
+            components: [new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 })]
+        });
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 280.0,
+            pressure: 2.0e5,
+            liquidFraction: 0.8
+        });
+
+        // Create and run vessel state calculation
+        const vesselStateCalc = new VesselStateCalculation(material, state);
+        
+        console.log("Running vesselStateCalculation...");
+        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: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+        // Create vessel
+        const vessel = new Vessel({
+            state,
+            material,
+            vesselConditions: vesselStateCalc.vesselConditions,
+            liquidFillFractionByVolume: 0.8
+        });
+
+        // Create and run vessel catastrophic rupture calculation
+        const vesselCatastrophicCalc = new VesselCatastrophicRuptureCalculation(
+            vessel, 
+            new DischargeParameters()
+        );
+        
+        console.log("Running vesselCatastrophicRuptureCalculation...");
+        const catastrophicResult = await vesselCatastrophicCalc.run();
+
+        if (vesselCatastrophicCalc.messages.length > 0) {
+            console.log("Messages:");
+            vesselCatastrophicCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(catastrophicResult).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vesselCatastrophicRuptureCalculation (${vesselCatastrophicCalc.calculationElapsedTime}ms)`);
+
+        const exitMaterial = vesselCatastrophicCalc.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,
+            vesselCatastrophicCalc.dischargeResult!,
+            vesselCatastrophicCalc.dischargeRecords!,
+            1,
+            weather,
+            new DispersionParameters(),
+            0.0
+        );
+
+        console.log("Running dispersionCalculation...");
+        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: dispersionCalculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+        // Define explosion configurations
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: 0.0,
+            specialConcentration: SpecialConcentration.MIN
+        });
+
+        const explosionParams = new ExplosionParameters({ 
+            explosionUniformStrength: 7.0 
+        });
+
+        const explosionOutputConfig = new ExplosionOutputConfig({ 
+            overpressureLevel: 2068 
+        });
+
+        const explosionConfinedVolumes = [
+            new ExplosionConfinedVolume(),
+            new ExplosionConfinedVolume()
+        ];
+
+        // 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...");
+        const explosionResult = await explosionCalc.run();
+
+        if (explosionCalc.messages.length > 0) {
+            console.log("Messages:");
+            explosionCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(explosionResult).toBe(ResultCode.SUCCESS);
+
+        // Regression checks
+        const result = explosionCalc.explosionUnifConfOverpressureResult!;
+        const expectedMass = 9.863701824923115;
+        const expectedTime = 5.794506457215323;
+        const expectedDistance = 112.78500368023822;
+
+        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/testCase75.test.ts

@@ -0,0 +1,163 @@
+import { Material, MaterialComponent, State, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselLineRuptureCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { 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 75", () => {
+    test("should run the full explosion scenario and perform regression check", async () => {
+        // Define the material
+        const material = new Material({
+            name: "AMMONIA",
+            components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })]
+        });
+
+        // Define the initial state
+        const state = new State({
+            temperature: 265.0,
+            pressure: 5.0e5,
+            liquidFraction: 0.8
+        });
+
+        // Create and run vessel state calculation
+        const vesselStateCalc = new VesselStateCalculation(material, state);
+        
+        console.log("Running vesselStateCalculation...");
+        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: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+        // Create vessel
+        const vessel = new Vessel({
+            state,
+            material,
+            vesselConditions: vesselStateCalc.vesselConditions,
+            liquidFillFractionByVolume: 0.8
+        });
+
+        // Create and run vessel catastrophic rupture calculation
+        const dischargeParams = new DischargeParameters();
+        const vesselRuptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParams);
+        
+        console.log("Running vesselCatastrophicRuptureCalculation...");
+        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: vesselCatastrophicRuptureCalculation (${vesselRuptureCalc.calculationElapsedTime}ms)`);
+
+        const exitMaterial = vesselRuptureCalc.exitMaterial!;
+
+        // Define weather
+        const weather = new Weather({
+            windSpeed: 10.0,
+            stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+            windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+        });
+
+        // Define substrate
+        const substrate = new Substrate();
+
+        // Create and run dispersion calculation
+        const dispersionCalc = new DispersionCalculation(
+            exitMaterial,
+            substrate,
+            vesselRuptureCalc.dischargeResult!,
+            vesselRuptureCalc.dischargeRecords!,
+            vesselRuptureCalc.dischargeRecords!.length,
+            weather,
+            new DispersionParameters(),
+            0.0
+        );
+
+        console.log("Running dispersionCalculation...");
+        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: dispersionCalculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+        // Define explosion configurations
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: 0.0,
+            specialConcentration: SpecialConcentration.MIN
+        });
+
+        const explosionParams = new ExplosionParameters({
+            explosionUniformStrength: 7.0
+        });
+
+        const explosionOutputConfig = new ExplosionOutputConfig({
+            overpressureLevel: 1034
+        });
+
+        const explosionConfinedVolumes = [
+            new ExplosionConfinedVolume(),
+            new ExplosionConfinedVolume()
+        ];
+
+        // 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...");
+        const explosionResult = await explosionCalc.run();
+
+        if (explosionCalc.messages.length > 0) {
+            console.log("Messages:");
+            explosionCalc.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(explosionResult).toBe(ResultCode.SUCCESS);
+
+        // Regression checks
+        const result = explosionCalc.explosionUnifConfOverpressureResult!;
+        const expectedMass = 1005.5754053562894;
+        const expectedTime = 0.5886114409418679;
+        const expectedDistance = 626.5034456922325;
+
+        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/testCase76.test.ts

@@ -0,0 +1,174 @@
+import { Material, MaterialComponent, State, ReliefValve, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselReliefValveCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { LateExplosionToOPLevelsCalculation } 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 76", () => {
+    test("should run the full explosion scenario and perform regression check", async () => {
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: 270.0,
+            pressure: 8e6,
+            liquidFraction: 1.0
+        });
+
+        // Define the material contained by the vessel
+        const material = new Material({
+            name: "HYDROGEN",
+            components: [new MaterialComponent({ name: "HYDROGEN", 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 (sphere with 5m diameter)
+        const vessel = new Vessel({
+            state,
+            material,
+            vesselConditions: vesselStateCalc.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_SPHERE,
+            diameter: 5
+        });
+
+        // Create relief valve
+        const reliefValve = new ReliefValve({
+            pipeDiameter: 0.5,
+            pipeLength: 1.0,
+            pipeHeightFraction: 1,
+            reliefValveConstrictionDiameter: 0.25
+        });
+
+        // Create and run vessel relief valve calculation
+        const reliefValveCalc = new VesselReliefValveCalculation(vessel, reliefValve, new DischargeParameters());
+        
+        console.log("Running vesselReliefValveCalculation...");
+        resultCode = await reliefValveCalc.run();
+
+        if (reliefValveCalc.messages.length > 0) {
+            console.log("Messages:");
+            reliefValveCalc.messages.forEach((msg) => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vesselReliefValveCalculation (${reliefValveCalc.calculationElapsedTime}ms)`);
+        console.log(`vesselReliefValveCalculation.dischargeResult.releaseMass: ${reliefValveCalc.dischargeResult!.releaseMass} [kg]`);
+
+        const exitMaterial = reliefValveCalc.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,
+            reliefValveCalc.dischargeResult!,
+            reliefValveCalc.dischargeRecords!,
+            reliefValveCalc.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 explosionOutputConfigs = [
+            new ExplosionOutputConfig({ overpressureLevel: 4136 })
+        ];
+
+        const explosionConfinedVolumes = [
+            new ExplosionConfinedVolume(),
+            new ExplosionConfinedVolume()
+        ];
+
+        // Create and run explosion calculation
+        const explosionCalc = new LateExplosionToOPLevelsCalculation(
+            exitMaterial,
+            dispersionCalc.scalarUdmOutputs!,
+            weather,
+            dispersionCalc.dispersionRecords!,
+            dispersionCalc.dispersionRecords!.length,
+            substrate,
+            dispersionOutputConfig,
+            explosionOutputConfigs,
+            explosionOutputConfigs.length,
+            explosionParams,
+            explosionConfinedVolumes,
+            explosionConfinedVolumes.length,
+            new DispersionParameters()
+        );
+
+        console.log("Running lateExplosionToOPLevelsCalculation...");
+        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.explosionUnifConfOverpressureResults![0];
+        const expectedMass = 364.4122308301167;
+        const expectedTime = 4.444690161422924;
+        const expectedDistance = 449.089635837361;
+
+        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: lateExplosionToOPLevelsCalculation (${explosionCalc.calculationElapsedTime}ms)`);
+    });
+});