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

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

@@ -0,0 +1,157 @@
+import { Material, MaterialComponent, State, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import {  DispersionCalculation } from "../../src/calculations/dispersion";
+import {  LateExplosionToOPLevelsCalculation } from "../../src/calculations/lateExplosion";
+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("Integrated Explosion Scenario - Test Case 46", () => {
+    test("should run the full explosion scenario and perform regression check", async () => {
+      // Define material
+      const material = new Material(
+        {
+            name: "N-HEXANE", 
+            components: [
+                            new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 }),
+                        ]
+    });
+  
+      const state = new State({
+        temperature: 280.0,
+        pressure: 2.0e5,
+        liquidFraction: 0.8,
+      });
+  
+      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)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        vesselConditions: vesselStateCalc.vesselConditions,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParams);
+  
+      console.log("Running vesselCatastrophicRuptureCalculation...");
+      resultCode = await ruptureCalc.run();
+  
+      if (ruptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vesselCatastrophicRuptureCalculation (${ruptureCalc.calculationElapsedTime}ms)`);
+  
+      const exitMaterial = ruptureCalc.exitMaterial!;
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+      });
+  
+      const substrate = new Substrate();
+  
+      const dispersionCalc = new DispersionCalculation(
+        exitMaterial,
+        substrate,
+        ruptureCalc.dischargeResult!,
+        ruptureCalc.dischargeRecords!,
+        1,
+        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)`);
+  
+      const explosionParams = new ExplosionParameters({ explosionUniformStrength: 7.0 });
+  
+      const explosionOutputConfigs = [
+        new ExplosionOutputConfig({ overpressureLevel: 1034 }),
+        new ExplosionOutputConfig({ overpressureLevel: 2068 }),
+      ];
+  
+      const explosionConfinedVolumes = [
+        new ExplosionConfinedVolume(),
+        new ExplosionConfinedVolume(),
+      ];
+  
+      const explosionOutputConfig = new DispersionOutputConfig({
+        concentration: 0.0,
+        specialConcentration: SpecialConcentration.MIN,
+      });
+  
+      const explosionCalc = new LateExplosionToOPLevelsCalculation(
+        exitMaterial,
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        explosionOutputConfig,
+        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);
+  
+      const result = explosionCalc.explosionUnifConfOverpressureResults![0];
+      const expectedMass = 11.67432824752745;
+      const expectedTime = 1.743456345845083;
+      const expectedDistance = 193.98838586988907;
+  
+      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/testCase47.test.ts

@@ -0,0 +1,149 @@
+import { Material, MaterialComponent, State, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, DispersionOutputConfig, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { LateExplosionToOPLevelsCalculation } from "../../src/calculations/lateExplosion";
+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("Integrated Explosion Scenario - Test Case 47", () => {
+  test("should run the full explosion scenario and perform regression check", async () => {
+    // Define material
+    const material = new Material({
+      name: "AMMONIA",
+      components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+    });
+
+    const state = new State({
+      temperature: 265.0,
+      pressure: 5.0e5,
+      liquidFraction: 0.8,
+    });
+
+    // Create 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)`);
+
+    const vessel = new Vessel({
+      state,
+      material,
+      liquidFillFractionByVolume: 0.8,
+      vesselConditions: vesselStateCalc.vesselConditions,
+    });
+
+    const dischargeParams = new DischargeParameters();
+
+    const ruptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParams);
+    console.log("Running vesselCatastrophicRuptureCalculation...");
+    resultCode = await ruptureCalc.run();
+
+    if (ruptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      ruptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vesselCatastrophicRuptureCalculation (${ruptureCalc.calculationElapsedTime}ms)`);
+
+    const exitMaterial = ruptureCalc.exitMaterial!;
+    const weather = new Weather({
+      windSpeed: 10.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const substrate = new Substrate();
+
+    // Create a dispersion calculation
+    const dispersionCalc = new DispersionCalculation(
+      exitMaterial,
+      substrate,
+      ruptureCalc.dischargeResult!,
+      ruptureCalc.dischargeRecords!,
+      ruptureCalc.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 the explosion parameters and configurations
+    const explosionParams = new ExplosionParameters({ explosionUniformStrength: 7.0 });
+    const explosionOutputConfigs = [
+      new ExplosionOutputConfig({ overpressureLevel: 1034 }),
+      new ExplosionOutputConfig({ overpressureLevel: 2068 }),
+    ];
+    const explosionConfinedVolumes = [new ExplosionConfinedVolume(), new ExplosionConfinedVolume()];
+    const dispersionOutputConfig = new DispersionOutputConfig({
+      concentration: 0.0,
+      specialConcentration: SpecialConcentration.MIN,
+    });
+
+    // Create 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);
+
+    const result = explosionCalc.explosionUnifConfOverpressureResults![0];
+    const expectedMass = 1005.575405356289;
+    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: lateExplosionToOPLevelsCalculation (${explosionCalc.calculationElapsedTime}ms)`);
+  });
+});

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

@@ -0,0 +1,176 @@
+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 48", () => {
+    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: 1034 }),
+        new ExplosionOutputConfig({ overpressureLevel: 2068 }),
+        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 = 1024.8207387858251;
+  
+      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/testCase49.test.ts

@@ -0,0 +1,178 @@
+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 } 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 49", () => {
+    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 })
+        ];
+
+        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 = 31.04536142489174;
+        const expectedTime = 1.1859455812737545;
+        const expectedDistance = 70.52548140876165;
+
+        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)`);
+    });
+});