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

package/tests/distances-and-ellipses-to-radiation-levels-calculation/testCase67.test.ts

@@ -0,0 +1,198 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { DistancesAndEllipsesToRadiationLevelsCalculation } from "../../src/calculations/radiation";
+import { Bund, DischargeParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, TimeVaryingOption, VesselShape } 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 67 - Distances and Ellipses to Radiation Levels Scenario", () => {
+  test("should run vessel state, leak, jet fire, and distances/ellipses calculations with regression checks", async () => {
+    // Define case properties
+    const materialName = "ETHANE_METHANE_HYDROGEN";
+    const stateTemperature = 360.0;
+    const statePressure = 3.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.3;
+    const liquidFillFractionByVolume = 0.4;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.EXTREME;
+
+    // Define material and state
+    const material = new Material({
+      name: materialName,
+      components: [
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.5 }),
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.3 }),
+        new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.2 }),
+      ],
+      componentCount: 3,
+    });
+
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      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,
+      location: new LocalPosition({ x: 0, y: 0, z: 0 }),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // 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 jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+    });
+
+    const substrate = new Substrate({
+      bund: new Bund({ specifyBund: false }),
+    });
+
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+    });
+
+    // Jet fire calculation
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jet_fire_calculation...");
+    const jetFireResult = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(jetFireResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: jet_fire_calculation (${jetFireCalc.calculationElapsedTime}ms)`);
+
+    // Flammable output configurations
+    const flammableOutputConfigs = [
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 2.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 2.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 2.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+    ];
+
+    // Distances and ellipses to radiation levels calculation
+    const distancesEllipsesCalc = new DistancesAndEllipsesToRadiationLevelsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters!,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    console.log("Running distances_and_ellipses_to_radiation_levels_calculation...");
+    const distancesEllipsesResult = await distancesEllipsesCalc.run();
+
+    if (distancesEllipsesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesEllipsesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesEllipsesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesEllipsesCalc.contourPoints!.length).toBe(150);
+
+    if (distancesEllipsesCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesEllipsesCalc.contourPoints![distancesEllipsesCalc.contourPoints!.length - 1].x - 96.74496662598202) / 96.74496662598202
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const areaError = Math.abs(
+      (distancesEllipsesCalc.areas![0] - 11027.574303452657) / 11027.574303452657
+    );
+    expect(areaError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_and_ellipses_to_radiation_levels_calculation (${distancesEllipsesCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/distances-and-ellipses-to-radiation-levels-calculation/testCase68.test.ts

@@ -0,0 +1,178 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { DistancesAndEllipsesToRadiationLevelsCalculation } from "../../src/calculations/radiation";
+import { DischargeParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, TimeVaryingOption, VesselShape } 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 68 - Distances and Ellipses to Radiation Levels Scenario", () => {
+  test("should run vessel state, leak, jet fire, and distances/ellipses calculations with regression checks", async () => {
+    // Define case properties
+    const materialName = "N-BUTANE";
+    const stateTemperature = 360.0;
+    const statePressure = 3.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.3;
+    const liquidFillFractionByVolume = 0.4;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.EXTREME;
+
+    // Define material and state
+    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: 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,
+      location: new LocalPosition({ x: 0, y: 0, z: 0 }),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // 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 jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+    });
+
+    const substrate = new Substrate({
+      bund: undefined, // Substrate in Python test uses default bund (equivalent to unspecified in TS)
+    });
+
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+    });
+
+    // Jet fire calculation
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jet_fire_calculation...");
+    const jetFireResult = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(jetFireResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: jet_fire_calculation (${jetFireCalc.calculationElapsedTime}ms)`);
+
+    // Flammable output configurations
+    const flammableOutputConfigs = [
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 5.0, y: 0.0, z: 0.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+    ];
+
+    // Distances and ellipses to radiation levels calculation
+    const distancesEllipsesCalc = new DistancesAndEllipsesToRadiationLevelsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters!,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    console.log("Running distances_and_ellipses_to_radiation_levels_calculation...");
+    const distancesEllipsesResult = await distancesEllipsesCalc.run();
+
+    if (distancesEllipsesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesEllipsesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesEllipsesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesEllipsesCalc.contourPoints!.length).toBe(50);
+
+    if (distancesEllipsesCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesEllipsesCalc.contourPoints![distancesEllipsesCalc.contourPoints!.length - 1].x - 296.1082631873717) / 296.1082631873717
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const areaError = Math.abs(
+      (distancesEllipsesCalc.areas![0] - 114055.56705017174) / 114055.56705017174
+    );
+    expect(areaError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_and_ellipses_to_radiation_levels_calculation (${distancesEllipsesCalc.calculationElapsedTime}ms)`);
+  });
+});

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

@@ -0,0 +1,158 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesAndFootprintsToConcentrationLevelsCalculation } 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 31a - Distances and Footprints to Concentration Levels Scenario", () => {
+  test("should run vessel, rupture, dispersion, and distances/footprints 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 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,
+      vesselRuptureCalc.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(723);
+
+    if (distancesFootprintsCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesFootprintsCalc.contourPoints![distancesFootprintsCalc.contourPoints!.length - 3].x - (-7.7737846974650235)) / (-7.7737846974650235)
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const distanceError = Math.abs(
+      (distancesFootprintsCalc.distancesConcentration![0] - 33.477492122323696) / 33.477492122323696
+    );
+    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/testCase32a.test.ts

@@ -0,0 +1,156 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { DistancesAndFootprintsToConcentrationLevelsCalculation } 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 32a - Distances and Footprints to Concentration Levels Scenario", () => {
+  test("should run vessel, rupture, dispersion, and distances/footprints calculations with regression checks", async () => {
+    // Define material and state
+    const material = new Material({
+      name: "HEXANE",
+      components: [
+        new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: 280.0,
+      pressure: 2.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.WATER,
+      surfaceRoughness: 0.05,
+    });
+
+    const weather = new Weather({
+      windSpeed: 2.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+      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 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,
+      vesselRuptureCalc.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(569);
+
+    if (distancesFootprintsCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesFootprintsCalc.contourPoints![distancesFootprintsCalc.contourPoints!.length - 3].x - (-5.466432738453024)) / (-5.466432738453024)
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const distanceError = Math.abs(
+      (distancesFootprintsCalc.distancesConcentration![0] - 14.139820655455761) / 14.139820655455761
+    );
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_and_footprints_to_concentration_levels_calculation (${distancesFootprintsCalc.calculationElapsedTime}ms)`);
+  });
+});