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

package/tests/distances-and-footprints-to-concentration-levels-calculation/testCase33a.test.ts

@@ -0,0 +1,158 @@
+import { VesselStateCalculation, VesselLeakCalculation } from '../../src/calculations/discharge';
+import { DispersionCalculation } from '../../src/calculations/dispersion';
+import { DistancesAndFootprintsToConcentrationLevelsCalculation } from '../../src/calculations/dispersionView';
+import { DischargeParameters, DispersionOutputConfig, DispersionParameters, Leak, Material, MaterialComponent, State, Substrate, Vessel, Weather } from '../../src/entities';
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, TimeVaryingOption, 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('Test Case 33a - Distances and Footprints to Concentration Levels Scenario', () => {
+  test('should run vessel state, leak, dispersion, and distances/footprints calculations with regression checks', async () => {
+    // Define material and state
+    const material = new Material({
+      name: 'CARBON DIOXIDE (TOXIC)',
+      components: [new MaterialComponent({ name: 'CARBON DIOXIDE (TOXIC)', moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: 280.0,
+      pressure: 8.0e6,
+      liquidFraction: 0.0,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+
+    console.log('Running vessel_state_calculation...');
+    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: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState!,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      diameter: 5.0,
+      shape: VesselShape.VESSEL_SPHERE,
+      liquidFillFractionByVolume: 0.8,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: 0.008,
+      holeHeightFraction: 0.5,
+      timeVaryingOption: TimeVaryingOption.INITIAL_RATE,
+    });
+
+    // Vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+
+    console.log('Running vessel_leak_calculation...');
+    const leakResult = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log('Messages:');
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(leakResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Set up entities for dispersion calculation
+    const substrate = new Substrate({
+      surfaceType: SurfaceType.WATER,
+      surfaceRoughness: 0.01,
+    });
+
+    const weather = new Weather({
+      windSpeed: 4.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_C,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const dispersionParams = new DispersionParameters();
+
+    // Dispersion calculation
+    const dispersionCalc = new DispersionCalculation(
+      vesselLeakCalc.exitMaterial!,
+      substrate,
+      vesselLeakCalc.dischargeResult!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      weather,
+      dispersionParams,
+      0.0 // endPointConcentration
+    );
+
+    console.log('Running dispersion_calculation...');
+    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: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+    // Distances and footprints to concentration levels calculation
+    const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: 0.0, elevation: 2.5 })];
+
+    const distancesFootprintsCalc = new DistancesAndFootprintsToConcentrationLevelsCalculation(
+      dispersionCalc.scalarUdmOutputs!,
+      weather,
+      dispersionCalc.dispersionRecords!,
+      dispersionCalc.dispersionRecords!.length,
+      substrate,
+      dispersionOutputConfigs,
+      dispersionOutputConfigs.length,
+      dispersionParams,
+      vesselLeakCalc.exitMaterial!
+    );
+
+    console.log('Running distances_and_footprints_to_concentration_levels_calculation...');
+    const distancesFootprintsResult = await distancesFootprintsCalc.run();
+
+    if (distancesFootprintsCalc.messages.length > 0) {
+      console.log('Messages:');
+      distancesFootprintsCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesFootprintsResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesFootprintsCalc.contourPoints!.length).toBe(553);
+
+    if (distancesFootprintsCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesFootprintsCalc.contourPoints![distancesFootprintsCalc.contourPoints!.length - 3].x - -0.09459660419095317) /
+        -0.09459660419095317
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const distanceError = Math.abs(
+      (distancesFootprintsCalc.distancesConcentration![0] - 10.10796681882425) / 10.10796681882425
+    );
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(
+      `SUCCESS: distances_and_footprints_to_concentration_levels_calculation (${distancesFootprintsCalc.calculationElapsedTime}ms)`
+    );
+  });
+});

package/tests/distances-and-footprints-to-concentration-levels-calculation/testCase34a.test.ts

@@ -0,0 +1,165 @@
+import { VesselStateCalculation, VesselLeakCalculation, VesselLineRuptureCalculation } from '../../src/calculations/discharge';
+import { DispersionCalculation } from '../../src/calculations/dispersion';
+import { DistancesAndFootprintsToConcentrationLevelsCalculation } from '../../src/calculations/dispersionView';
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Leak, Material, MaterialComponent, State, Substrate, Vessel, Weather, LineRupture } from '../../src/entities';
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, TimeVaryingOption, 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("Test Case 34a - Distances and Footprints to Concentration Levels Scenario", () => {
+    test("should run vessel state, line rupture, dispersion, and distances/footprints calculations with regression checks", async () => {
+      // Define material and state
+      const material = new Material({
+        name: "AMMONIA",
+        components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: 290.0,
+        pressure: 7.0e6,
+        liquidFraction: 1.0,
+      });
+  
+      // Vessel state calculation
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+  
+      console.log("Running vessel_state_calculation...");
+      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: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+  
+      // Define vessel
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.7,
+        shape: VesselShape.VESSEL_CUBOID,
+        height: 2.0,
+        width: 1.0,
+        length: 3.0,
+        vesselConditions: vesselStateCalc.vesselConditions,
+      });
+  
+      // Define line rupture
+      const lineRupture = new LineRupture({
+        pipeDiameter: 0.1,
+        pipeLength: 1.0,
+        pipeHeightFraction: 0.1,
+      });
+  
+      // Vessel line rupture calculation
+      const dischargeParams = new DischargeParameters();
+      const vesselLineRuptureCalc = new VesselLineRuptureCalculation(vessel, lineRupture, dischargeParams);
+  
+      console.log("Running vessel_line_rupture_calculation...");
+      const ruptureResult = await vesselLineRuptureCalc.run();
+  
+      if (vesselLineRuptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselLineRuptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalc.calculationElapsedTime}ms)`);
+  
+      // Set up entities for dispersion calculation
+      const bund = new Bund({
+        specifyBund: true,
+        bundHeight: 0.5,
+        bundDiameter: 5.0,
+      });
+  
+      const substrate = new Substrate({
+        bund,
+        surfaceType: SurfaceType.LAND,
+        surfaceRoughness: 0.183,
+      });
+  
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+      });
+  
+      const dispersionParams = new DispersionParameters();
+  
+      // Dispersion calculation
+      const dispersionCalc = new DispersionCalculation(
+        vesselLineRuptureCalc.exitMaterial!,
+        substrate,
+        vesselLineRuptureCalc.dischargeResult!,
+        vesselLineRuptureCalc.dischargeRecords!,
+        vesselLineRuptureCalc.dischargeRecords!.length,
+        weather,
+        dispersionParams,
+        0.0 // endPointConcentration
+      );
+  
+      console.log("Running dispersion_calculation...");
+      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: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+  
+      // Distances and footprints to concentration levels calculation
+      const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: 0.0 })];
+  
+      const distancesFootprintsCalc = new DistancesAndFootprintsToConcentrationLevelsCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfigs,
+        dispersionOutputConfigs.length,
+        dispersionParams,
+        vesselLineRuptureCalc.exitMaterial!
+      );
+  
+      console.log("Running distances_and_footprints_to_concentration_levels_calculation...");
+      const distancesFootprintsResult = await distancesFootprintsCalc.run();
+  
+      if (distancesFootprintsCalc.messages.length > 0) {
+        console.log("Messages:");
+        distancesFootprintsCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(distancesFootprintsResult).toBe(ResultCode.SUCCESS);
+  
+      // Regression checks
+      expect(distancesFootprintsCalc.contourPoints!.length).toBe(587);
+  
+      if (distancesFootprintsCalc.contourPoints!.length > 0) {
+        const contourPointError = Math.abs(
+          (distancesFootprintsCalc.contourPoints![distancesFootprintsCalc.contourPoints!.length - 3].x - -0.3224436750622628) /
+          -0.3224436750622628
+        );
+        expect(contourPointError).toBeLessThan(1e-3);
+      }
+  
+      const distanceError = Math.abs(
+        (distancesFootprintsCalc.distancesConcentration![0] - 248.37370206331042) / 248.37370206331042
+      );
+      expect(distanceError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: distances_and_footprints_to_concentration_levels_calculation (${distancesFootprintsCalc.calculationElapsedTime}ms)`);
+    });
+  });

package/tests/distances-and-footprints-to-concentration-levels-calculation/testCase35a.test.ts

@@ -0,0 +1,188 @@
+import { VesselReliefValveCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesAndFootprintsToConcentrationLevelsCalculation } from "../../src/calculations/dispersionView";
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Material, MaterialComponent, ReliefValve, State, Substrate, Vessel, Weather } from "../../src/entities";
+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("Test Case 35a - Distances and Footprints to Concentration Levels Scenario", () => {
+  test("should run vessel, relief valve, dispersion, and distances/footprints calculations with regression checks", async () => {
+    // Define constants
+    const stateTemperature = 320.0;
+    const statePressure = 1.0e6;
+    const stateLiquidFraction = 1.0;
+    const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+    const vesselDiameter = 2.0;
+    const vesselLength = 5.0;
+    const liquidFillFractionByVolume = 0.7;
+    const reliefValvePipeDiameter = 0.02;
+    const reliefValvePipeLength = 10.0;
+    const reliefValvePipeHeightFraction = 1;
+    const reliefValveConstrictionDiameter = 0.02;
+    const surfaceType = SurfaceType.LAND;
+    const surfaceRoughness = 0.183;
+    const windSpeed = 1.5;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_D;
+    const endPointConcentration = 0.0;
+    const specifyBund = true;
+    const bundHeight = 0.5;
+    const bundDiameter = 5.0;
+    const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+
+    // Define material and state
+    const material = new Material({
+      name: "CHLORINE",
+      components: [new MaterialComponent({ name: "CHLORINE", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: stateLiquidFraction,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+
+    console.log("Running vessel_state_calculation...");
+    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: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state,
+      material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      liquidFillFractionByVolume,
+      shape: vesselShape,
+      diameter: vesselDiameter,
+      length: vesselLength,
+    });
+
+    // Define relief valve
+    const reliefValve = new ReliefValve({
+      pipeDiameter: reliefValvePipeDiameter,
+      pipeLength: reliefValvePipeLength,
+      pipeHeightFraction: reliefValvePipeHeightFraction,
+      reliefValveConstrictionDiameter: reliefValveConstrictionDiameter,
+    });
+
+    // Vessel relief valve calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselReliefValveCalc = new VesselReliefValveCalculation(vessel, reliefValve, dischargeParams);
+
+    console.log("Running vessel_relief_valve_calculation...");
+    const reliefValveResult = await vesselReliefValveCalc.run();
+
+    if (vesselReliefValveCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselReliefValveCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(reliefValveResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_relief_valve_calculation (${vesselReliefValveCalc.calculationElapsedTime}ms)`);
+    console.log(`vessel_relief_valve_calculation.dischargeResult.releaseMass: ${vesselReliefValveCalc.dischargeResult!.releaseMass} [kg]`);
+
+    // Set up entities for dispersion calculation
+    const bund = new Bund({
+      specifyBund,
+      bundHeight,
+      bundDiameter,
+    });
+
+    const substrate = new Substrate({
+      bund,
+      surfaceType,
+      surfaceRoughness,
+    });
+
+    const weather = new Weather({
+      windSpeed,
+      stabilityClass,
+      windProfileFlag
+    });
+
+    const dispersionParams = new DispersionParameters();
+
+    // Dispersion calculation
+    const dispersionCalc = new DispersionCalculation(
+      vesselReliefValveCalc.exitMaterial!,
+      substrate,
+      vesselReliefValveCalc.dischargeResult!,
+      vesselReliefValveCalc.dischargeRecords!,
+      vesselReliefValveCalc.dischargeRecords!.length,
+      weather,
+      dispersionParams,
+      endPointConcentration
+    );
+
+    console.log("Running dispersion_calculation...");
+    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: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+
+    // Distances and footprints to concentration levels calculation
+    const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: endPointConcentration })];
+
+    const distancesFootprintsCalc = new DistancesAndFootprintsToConcentrationLevelsCalculation(
+      dispersionCalc.scalarUdmOutputs!,
+      weather,
+      dispersionCalc.dispersionRecords!,
+      dispersionCalc.dispersionRecords!.length,
+      substrate,
+      dispersionOutputConfigs,
+      dispersionOutputConfigs.length,
+      dispersionParams,
+      vesselReliefValveCalc.exitMaterial!
+    );
+
+    console.log("Running distances_and_footprints_to_concentration_levels_calculation...");
+    const distancesFootprintsResult = await distancesFootprintsCalc.run();
+
+    if (distancesFootprintsCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesFootprintsCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesFootprintsResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesFootprintsCalc.contourPoints!.length).toBe(651);
+
+    if (distancesFootprintsCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesFootprintsCalc.contourPoints![distancesFootprintsCalc.contourPoints!.length - 3].x - 3.5444266994358022) /
+        3.5444266994358022
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const distanceError = Math.abs(
+      (distancesFootprintsCalc.distancesConcentration![0] - 658.8828694811095) / 658.8828694811095
+    );
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_and_footprints_to_concentration_levels_calculation (${distancesFootprintsCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/distances-to-conc-levels-calculation/testCase121.test.ts

@@ -0,0 +1,149 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesToConcLevelsCalculation } from "../../src/calculations/dispersionView";
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+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("Test Case 121 - Distances to Concentration Levels Scenario", () => {
+    test("should run vessel, rupture, dispersion, and distances calculations with regression checks", async () => {
+      // Define material and state
+      const material = new Material({
+        name: "ETHANE_BUTANE_PROPANE",
+        components: [
+          new MaterialComponent({ name: "ETHANE", moleFraction: 0.5 }),
+          new MaterialComponent({ name: "N-BUTANE", moleFraction: 0.3 }),
+          new MaterialComponent({ name: "PROPANE", moleFraction: 0.2 }),
+        ],
+        componentCount: 3,
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.0e5,
+        liquidFraction: 0.8,
+      });
+  
+      // Vessel state calculation
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+  
+      console.log("Running vessel_state_calculation...");
+      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: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+  
+      // Define vessel
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalc.vesselConditions,
+      });
+  
+      // Vessel catastrophic rupture calculation
+      const dischargeParams = new DischargeParameters();
+      const vesselRuptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParams);
+  
+      console.log("Running vessel_catastrophic_rupture_calculation...");
+      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: vessel_catastrophic_rupture_calculation (${vesselRuptureCalc.calculationElapsedTime}ms)`);
+  
+      // Set up entities for dispersion calculation
+      const bund = new Bund({
+        specifyBund: true,
+        bundHeight: 1.0,
+        bundDiameter: 8.0,
+      });
+  
+      const substrate = new Substrate({
+        bund,
+        surfaceType: SurfaceType.LAND,
+        surfaceRoughness: 0.2,
+      });
+  
+      const weather = new Weather({
+        windSpeed: 5.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE,
+      });
+  
+      const dispersionParams = new DispersionParameters();
+  
+      // Dispersion calculation
+      const dispersionCalc = new DispersionCalculation(
+        vesselRuptureCalc.exitMaterial!,
+        substrate,
+        vesselRuptureCalc.dischargeResult!,
+        vesselRuptureCalc.dischargeRecords!,
+        vesselRuptureCalc.dischargeRecords!.length,
+        weather,
+        dispersionParams,
+        0.0 // endPointConcentration
+      );
+  
+      console.log("Running dispersion_calculation...");
+      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: dispersion_calculation (${dispersionCalc.calculationElapsedTime}ms)`);
+  
+      // Distances to concentration levels calculation
+      const dispersionOutputConfigs = [new DispersionOutputConfig({ concentration: 0.0 })];
+  
+      const distancesCalc = new DistancesToConcLevelsCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfigs,
+        dispersionOutputConfigs.length,
+        vesselRuptureCalc.exitMaterial!,
+        dispersionParams
+      );
+  
+      console.log("Running distances_to_conc_levels_calculation...");
+      const distancesResult = await distancesCalc.run();
+  
+      if (distancesCalc.messages.length > 0) {
+        console.log("Messages:");
+        distancesCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(distancesResult).toBe(ResultCode.SUCCESS);
+  
+      // Regression check
+      const distanceError = Math.abs(
+        (distancesCalc.distances![0] - 33.46354835021753) / 33.46354835021753
+      );
+      expect(distanceError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: distances_to_conc_levels_calculation (${distancesCalc.calculationElapsedTime}ms)`);
+    });
+  });