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

package/tests/max-conc-footprint-calculation/testCase35.test.ts

@@ -0,0 +1,188 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig, ReliefValve } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation, VesselReliefValveCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { MaxConcFootprintCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, VesselShape, TimeVaryingOption, 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("Max Concentration Footprint Calculation - Test Case 35", () => {
+    test("should calculate max concentration footprint correctly for CHLORINE", async () => {
+      const material = new Material({
+        name: "CHLORINE",
+        components: [
+          new MaterialComponent({ name: "CHLORINE", moleFraction: 1.0 }),
+        ],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: 320.0,
+        pressure: 1.0e6,
+        liquidFraction: 1.0,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const stateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(stateResult).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`
+      );
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+        liquidFillFractionByVolume: 0.7,
+        shape: VesselShape.HORIZONTAL_CYLINDER,
+        diameter: 2.0,
+        length: 5.0,
+      });
+  
+      const reliefValve = new ReliefValve({
+        pipeDiameter: 0.02,
+        pipeLength: 10.0,
+        pipeHeightFraction: 1,
+        reliefValveConstrictionDiameter: 0.02,
+      });
+  
+      const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+        vessel,
+        reliefValve,
+        new DischargeParameters()
+      );
+  
+      const reliefResult = await vesselReliefValveCalculation.run();
+  
+      if (vesselReliefValveCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselReliefValveCalculation.messages.forEach((msg) =>
+          console.log(msg)
+        );
+      }
+  
+      expect(reliefResult).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: vessel_relief_valve_calculation (${vesselReliefValveCalculation.calculationElapsedTime}ms)`
+      );
+      console.log(
+        `vessel_relief_valve_calculation.discharge_result.release_mass: ${vesselReliefValveCalculation.dischargeResult!.releaseMass} [kg]`
+      );
+  
+      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 dispersionParameters = new DispersionParameters();
+  
+      const endPointConcentration = 0.0;
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselReliefValveCalculation.exitMaterial!,
+        substrate,
+        vesselReliefValveCalculation.dischargeResult!,
+        vesselReliefValveCalculation.dischargeRecords!,
+        vesselReliefValveCalculation.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration
+      );
+  
+      const dispersionResult = await dispersionCalculation.run();
+  
+      if (dispersionCalculation.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(dispersionResult).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`
+      );
+      console.log(
+        `Length dispersion records = ${dispersionCalculation.dispersionRecords!.length}`
+      );
+      console.log(
+        `Minimum concentration = ${dispersionCalculation.scalarUdmOutputs!.minimumConcentration}`
+      );
+      console.log(
+        `Observer count = ${dispersionCalculation.scalarUdmOutputs!.observerCount}`
+      );
+  
+      const lastRecord = dispersionCalculation.dispersionRecords!.at(-1)!;
+      console.log(
+        `Final centreline concentration = ${lastRecord.centrelineConcentration}`
+      );
+      console.log(`Final downwind distance = ${lastRecord.downwindDistance}`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+      });
+  
+      const maxConcFootprintCalculation = new MaxConcFootprintCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        vesselReliefValveCalculation.exitMaterial!,
+        dispersionParameters
+      );
+  
+      const footprintResult = await maxConcFootprintCalculation.run();
+  
+      if (maxConcFootprintCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxConcFootprintCalculation.messages.forEach((msg) =>
+          console.log(msg)
+        );
+      }
+  
+      expect(footprintResult).toBe(ResultCode.SUCCESS);
+  
+      const expectedLength = 651;
+      const expectedX = 3.5444266994358022;
+      const checkPoint =
+        maxConcFootprintCalculation.contourPoints![
+          maxConcFootprintCalculation.contourPoints!.length - 3
+        ];
+  
+      expect(maxConcFootprintCalculation.contourPoints!.length).toBe(
+        expectedLength
+      );
+      const xError = Math.abs((checkPoint.x - expectedX) / expectedX);
+      expect(xError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: max_conc_footprint_calculation (${maxConcFootprintCalculation.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/max-distance-to-conc-calculation/testCase111.test.ts

@@ -0,0 +1,138 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import {  MaxDistanceToConcCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, 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("Max Distance to Concentration Calculation - Test Case 111", () => {
+  test("should calculate max distance to concentration correctly", async () => {
+    // Define the material components
+    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
+  });
+
+    // Define the state of the vessel
+    const state = new State({ temperature: 265.0, pressure: 5.0e5, liquidFraction: 0.8 });
+
+    // Define surface type, roughness, and weather conditions
+    const surfaceType = SurfaceType.LAND;
+    const surfaceRoughness = 0.2;
+    const windSpeed = 5.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_A_;
+    const endPointConcentration = 0.0;
+    const specifyBund = true;
+    const bundHeight = 1.0;
+    const bundDiameter = 8.0;
+    const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+
+    // Run VesselStateCalculation
+    const vesselStateCalculation = new VesselStateCalculation(material, state);
+    const vesselStateResultCode = await vesselStateCalculation.run();
+
+    if (vesselStateCalculation.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalculation.messages.forEach((message) => console.log(message));
+    }
+
+    expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+    // Set up the vessel
+    const vessel = new Vessel({
+      state: state,
+      material: material,
+      liquidFillFractionByVolume: 0.8,
+      shape: VesselShape.VERTICAL_CYLINDER,
+      vesselConditions: vesselStateCalculation.vesselConditions
+    });
+
+    // Run VesselCatastrophicRuptureCalculation
+    const dischargeParameters = new DischargeParameters();
+    const vesselCatastrophicRuptureCalculation = new VesselCatastrophicRuptureCalculation(
+      vessel,
+      dischargeParameters
+    );
+    const vesselCatastrophicRuptureResultCode = await vesselCatastrophicRuptureCalculation.run();
+
+    if (vesselCatastrophicRuptureCalculation.messages.length > 0) {
+      console.log("Messages:");
+      vesselCatastrophicRuptureCalculation.messages.forEach((message) => console.log(message));
+    }
+
+    expect(vesselCatastrophicRuptureResultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselCatastrophicRuptureCalculation.calculationElapsedTime}ms)`);
+
+    // Set up the entities for DispersionCalculation
+    const bund = new Bund({specifyBund: specifyBund, bundHeight: bundHeight, bundDiameter: bundDiameter});
+    const substrate = new Substrate({bund, surfaceType, surfaceRoughness});
+    const weather = new Weather({ windSpeed: windSpeed, stabilityClass: stabilityClass, windProfileFlag: windProfileFlag });
+    const dispersionParameters = new DispersionParameters();
+    const dispersionCalculation = new DispersionCalculation(
+      vesselCatastrophicRuptureCalculation.exitMaterial!,
+      substrate,
+      vesselCatastrophicRuptureCalculation.dischargeResult!,
+      vesselCatastrophicRuptureCalculation.dischargeRecords!,
+      vesselCatastrophicRuptureCalculation.dischargeRecords!.length,
+      weather,
+      dispersionParameters,
+      endPointConcentration
+    );
+
+    const dispersionCalculationResultCode = await dispersionCalculation.run();
+
+    if (dispersionCalculation.messages.length > 0) {
+      console.log("Messages:");
+      dispersionCalculation.messages.forEach((message) => console.log(message));
+    }
+
+    expect(dispersionCalculationResultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+
+    // Set up the entities for MaxDistanceToConcCalculation
+    const dispersionOutputConfig = new DispersionOutputConfig({concentration: endPointConcentration});
+    const maxDistanceToConcCalculation = new MaxDistanceToConcCalculation(
+      dispersionCalculation.scalarUdmOutputs!,
+      weather,
+      dispersionCalculation.dispersionRecords!,
+      dispersionCalculation.dispersionRecords!.length,
+      substrate,
+      dispersionOutputConfig,
+      dispersionParameters,
+      vesselCatastrophicRuptureCalculation.exitMaterial!
+    );
+
+    const maxDistanceToConcResultCode = await maxDistanceToConcCalculation.run();
+
+    if (maxDistanceToConcCalculation.messages.length > 0) {
+      console.log("Messages:");
+      maxDistanceToConcCalculation.messages.forEach((message) => console.log(message));
+    }
+
+    expect(maxDistanceToConcResultCode).toBe(ResultCode.SUCCESS);
+
+    // Check the result for max distance to concentration
+    const expectedDistance = 33.46354835021753;
+    const distanceError = Math.abs(
+      (maxDistanceToConcCalculation.distance! - expectedDistance) / expectedDistance
+    );
+
+    expect(distanceError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: max_distance_to_conc_calculation (${maxDistanceToConcCalculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/max-distance-to-conc-calculation/testCase112.test.ts

@@ -0,0 +1,174 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import {  MaxDistanceToConcCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, 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("Max Distance to Concentration Calculation - Test Case 112", () => {
+    test("should calculate max distance to concentration correctly", async () => {
+      // Material and components
+      const material = new Material({
+        name: "HEXANE",
+        components: [
+          new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 }),
+        ],
+        componentCount: 1,
+      });
+  
+      // State of the vessel
+      const state = new State({
+        temperature: 280.0,
+        pressure: 2.0e5,
+        liquidFraction: 0.8,
+      });
+  
+      // Environmental and bund configuration
+      const surfaceType = SurfaceType.WATER;
+      const surfaceRoughness = 0.05;
+      const windSpeed = 2.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+      const endPointConcentration = 0.0;
+      const specifyBund = true;
+      const bundHeight = 1.0;
+      const bundDiameter = 8.0;
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      // Vessel state calculation
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResultCode = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((message) =>
+          console.log(message)
+        );
+      }
+  
+      expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`
+      );
+  
+      // Create the vessel
+      const vessel = new Vessel({
+        state: state,
+        material: material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const vesselCatastrophicRuptureCalculation =
+        new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+  
+      const vesselCatastrophicRuptureResultCode =
+        await vesselCatastrophicRuptureCalculation.run();
+  
+      if (vesselCatastrophicRuptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselCatastrophicRuptureCalculation.messages.forEach((message) =>
+          console.log(message)
+        );
+      }
+  
+      expect(vesselCatastrophicRuptureResultCode).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: vessel_catastrophic_rupture_calculation (${vesselCatastrophicRuptureCalculation.calculationElapsedTime}ms)`
+      );
+  
+      // Dispersion Calculation
+      const bund = new Bund({
+        specifyBund: specifyBund,
+        bundHeight: bundHeight,
+        bundDiameter: bundDiameter,
+      });
+  
+      const substrate = new Substrate({
+        bund,
+        surfaceType,
+        surfaceRoughness,
+      });
+  
+      const weather = new Weather({
+        windSpeed: windSpeed,
+        stabilityClass: stabilityClass,
+        windProfileFlag: windProfileFlag
+      });
+  
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        substrate,
+        vesselCatastrophicRuptureCalculation.dischargeResult!,
+        vesselCatastrophicRuptureCalculation.dischargeRecords!,
+        vesselCatastrophicRuptureCalculation.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration
+      );
+  
+      const dispersionCalculationResultCode = await dispersionCalculation.run();
+  
+      if (dispersionCalculation.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalculation.messages.forEach((message) =>
+          console.log(message)
+        );
+      }
+  
+      expect(dispersionCalculationResultCode).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`
+      );
+  
+      // Max Distance to Concentration Calculation
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+      });
+  
+      const maxDistanceToConcCalculation = new MaxDistanceToConcCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        dispersionParameters,
+        vesselCatastrophicRuptureCalculation.exitMaterial!
+      );
+  
+      const maxDistanceToConcResultCode = await maxDistanceToConcCalculation.run();
+  
+      if (maxDistanceToConcCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxDistanceToConcCalculation.messages.forEach((message) =>
+          console.log(message)
+        );
+      }
+  
+      expect(maxDistanceToConcResultCode).toBe(ResultCode.SUCCESS);
+  
+      // Validate the calculated distance
+      const expectedDistance = 13.21859690146534;
+      const distanceError = Math.abs(
+        (maxDistanceToConcCalculation.distance! - expectedDistance) /
+          expectedDistance
+      );
+  
+      expect(distanceError).toBeLessThan(1e-3);
+      console.log(
+        `SUCCESS: max_distance_to_conc_calculation (${maxDistanceToConcCalculation.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/max-distance-to-conc-calculation/testCase113.test.ts

@@ -0,0 +1,153 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig, Leak } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import {  MaxDistanceToConcCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, VesselShape, TimeVaryingOption, 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("Max Distance to Concentration Calculation - Test Case 113", () => {
+    test("should calculate max distance to concentration correctly", async () => {
+      // Case properties
+      const materialName = "CARBON DIOXIDE (TOXIC)";
+      const stateTemperature = 280.0;
+      const statePressure = 8.0e6;
+      const vesselShape = VesselShape.VESSEL_SPHERE;
+      const vesselDiameter = 5.0;
+      const leakHoleDiameter = 0.008;
+      const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+      const leakHoleHeightFraction = 0.5;
+      const surfaceType = SurfaceType.WATER;
+      const surfaceRoughness = 0.01;
+      const windSpeed = 4.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_C;
+      const endPointConcentration = 0.0;
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      // Initial state and material setup
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResultCode = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalculation.outputState!,
+        material: vesselStateCalculation.material!,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        liquidFillFractionByVolume: 0.8,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption: timeVaryingOption,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+  
+      const vesselLeakCalculation = new VesselLeakCalculation(vessel, leak, dischargeParameters);
+      const vesselLeakResultCode = await vesselLeakCalculation.run();
+  
+      if (vesselLeakCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselLeakCalculation.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(vesselLeakResultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalculation.calculationElapsedTime}ms)`);
+  
+      const substrate = new Substrate({
+        surfaceType,
+        surfaceRoughness,
+      });
+  
+      const weather = new Weather({
+        windSpeed: windSpeed,
+        stabilityClass: stabilityClass,
+        windProfileFlag: windProfileFlag
+      });
+  
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselLeakCalculation.exitMaterial!,
+        substrate,
+        vesselLeakCalculation.dischargeResult!,
+        vesselLeakCalculation.dischargeRecords!,
+        vesselLeakCalculation.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration
+      );
+  
+      const dispersionResultCode = await dispersionCalculation.run();
+  
+      if (dispersionCalculation.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalculation.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(dispersionResultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation: 2.5,
+      });
+  
+      const maxDistanceToConcCalculation = new MaxDistanceToConcCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        dispersionParameters,
+        vesselLeakCalculation.exitMaterial!
+      );
+  
+      const maxDistanceResultCode = await maxDistanceToConcCalculation.run();
+  
+      if (maxDistanceToConcCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxDistanceToConcCalculation.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(maxDistanceResultCode).toBe(ResultCode.SUCCESS);
+  
+      const expectedDistance = 10.10724753690727;
+      const distanceError = Math.abs(
+        (maxDistanceToConcCalculation.distance! - expectedDistance) / expectedDistance
+      );
+  
+      expect(distanceError).toBeLessThan(1e-3);
+      console.log(`SUCCESS: max_distance_to_conc_calculation (${maxDistanceToConcCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+