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

package/tests/max-conc-distance-calculation/testCase107.test.ts

@@ -0,0 +1,148 @@
+import { Material, MaterialComponent, State, Vessel, Substrate, Weather, DischargeParameters, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { MaxConcDistanceCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, Resolution, 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("Max Concentration Distance Calculation - Test Case 107", () => {
+    test("should match regression values", async () => {
+      const materialName = "ETHANE_BUTANE_PROPANE";
+      const endPointConcentration = 0.0;
+      const elevation = 2.0;
+      const resolution = Resolution.HIGH;
+      const specialConcentration = SpecialConcentration.UFL;
+      const lflFraction = 0.5;
+      const componentToTrackName = "N-BUTANE";
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const material = new Material({
+        name: materialName,
+        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.0,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+      const ruptureResult = await ruptureCalc.run();
+  
+      if (ruptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${ruptureCalc.calculationElapsedTime}ms)`);
+  
+      const substrate = new Substrate();
+      const weather = new Weather({windProfileFlag: windProfileFlag});
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalc = new DispersionCalculation(
+        ruptureCalc.exitMaterial!,
+        substrate,
+        ruptureCalc.dischargeResult!,
+        ruptureCalc.dischargeRecords!,
+        ruptureCalc.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration
+      );
+  
+      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)`);
+      console.log(`length dispersion records = ${dispersionCalc.dispersionRecords!.length}`);
+      console.log(`minimum concentration = ${dispersionCalc.scalarUdmOutputs!.minimumConcentration}`);
+      console.log(`observer count = ${dispersionCalc.scalarUdmOutputs!.observerCount}`);
+      console.log(`final centreline concentration = ${dispersionCalc.dispersionRecords!.at(-1)!.centrelineConcentration}`);
+      console.log(`final downwind distance = ${dispersionCalc.dispersionRecords!.at(-1)!.downwindDistance}`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation,
+        resolution,
+        specialConcentration,
+        lflFractionValue: lflFraction,
+        componentToTrackName,
+      });
+  
+      const maxConcDistanceCalc = new MaxConcDistanceCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        ruptureCalc.exitMaterial!,
+        dispersionParameters
+      );
+  
+      const maxDistanceResult = await maxConcDistanceCalc.run();
+  
+      if (maxConcDistanceCalc.messages.length > 0) {
+        console.log("Messages:");
+        maxConcDistanceCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistanceResult).toBe(ResultCode.SUCCESS);
+  
+      const records = maxConcDistanceCalc.concentrationRecords!;
+      expect(records.length).toBe(168);
+  
+      const lastRecord = records.at(-1)!;
+      const expectedConcentration = 0.02941206246379815;
+      const expectedX = 4.048969882876413;
+  
+      const concError = Math.abs((lastRecord.concentration! - expectedConcentration) / expectedConcentration);
+      const xError = Math.abs((lastRecord.position.x - expectedX) / expectedX);
+  
+      expect(concError).toBeLessThan(1e-3);
+      expect(xError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: max_conc_distance_calculation (${maxConcDistanceCalc.calculationElapsedTime}ms)`);
+    });
+  });
+  

package/tests/max-conc-distance-calculation/testCase108.test.ts

@@ -0,0 +1,172 @@
+import { Material, MaterialComponent, State, Vessel, Substrate, Weather, DischargeParameters, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { MaxConcDistanceCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, Resolution, 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("Max Concentration Distance Calculation - Test Case 108", () => {
+    test("should match regression expectations", async () => {
+      const materialName = "N-HEXANE";
+      const endPointConcentration = 0.0;
+      const elevation = 4.0;
+      const resolution = Resolution.EXTREME;
+      const specialConcentration = SpecialConcentration.LFL;
+      const lflFraction = 0.3;
+      const componentToTrackName = "";
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName })],
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.0e5,
+        liquidFraction: 0.0,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`
+      );
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const ruptureCalculation = new VesselCatastrophicRuptureCalculation(
+        vessel,
+        dischargeParameters
+      );
+  
+      const ruptureResult = await ruptureCalculation.run();
+  
+      if (ruptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(
+        `SUCCESS: vessel_catastrophic_rupture_calculation (${ruptureCalculation.calculationElapsedTime}ms)`
+      );
+  
+      const substrate = new Substrate();
+      const weather = new Weather({windProfileFlag: windProfileFlag});
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        ruptureCalculation.exitMaterial!,
+        substrate,
+        ruptureCalculation.dischargeResult!,
+        ruptureCalculation.dischargeRecords!,
+        ruptureCalculation.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 lastDispersionRecord =
+        dispersionCalculation.dispersionRecords!.at(-1)!;
+      console.log(
+        `Final centreline concentration = ${lastDispersionRecord.centrelineConcentration}`
+      );
+      console.log(
+        `Final downwind distance = ${lastDispersionRecord.downwindDistance}`
+      );
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation,
+        resolution,
+        specialConcentration,
+        lflFractionValue: lflFraction,
+        componentToTrackName,
+      });
+  
+      const maxConcDistanceCalculation = new MaxConcDistanceCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        ruptureCalculation.exitMaterial!,
+        dispersionParameters
+      );
+  
+      const maxDistanceResult = await maxConcDistanceCalculation.run();
+  
+      if (maxConcDistanceCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxConcDistanceCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistanceResult).toBe(ResultCode.SUCCESS);
+  
+      const records = maxConcDistanceCalculation.concentrationRecords!;
+      expect(records.length).toBe(108);
+  
+      const lastRecord = records.at(-1)!;
+  
+      const expectedConcentration = 0.3615707454077038;
+      const expectedX = 6.446181601923854;
+  
+      const concError = Math.abs(
+        (lastRecord.concentration! - expectedConcentration) / expectedConcentration
+      );
+      const xError = Math.abs(
+        (lastRecord.position.x - expectedX) / expectedX
+      );
+  
+      expect(concError).toBeLessThan(1e-3);
+      expect(xError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: max_conc_distance_calculation (${maxConcDistanceCalculation.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/max-conc-distance-calculation/testCase109.test.ts

@@ -0,0 +1,146 @@
+import { Material, MaterialComponent, State, Vessel, Substrate, Weather, DischargeParameters, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { MaxConcDistanceCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, Resolution, 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("Max Concentration Distance Calculation - Test Case 109", () => {
+    test("should run calculation and perform regression check", async () => {
+      const materialName = "HYDROGEN";
+      const endPointConcentration = 0.0;
+      const elevation = 10.0;
+      const resolution = Resolution.MEDIUM;
+      const specialConcentration = SpecialConcentration.LFL_FRACTION;
+      const lflFraction = 0.7;
+      const componentToTrackName = "";
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName })],
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.0e5,
+        liquidFraction: 0.0,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const ruptureCalculation = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+  
+      const ruptureResult = await ruptureCalculation.run();
+  
+      if (ruptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${ruptureCalculation.calculationElapsedTime}ms)`);
+  
+      const substrate = new Substrate();
+      const weather = new Weather({windProfileFlag: windProfileFlag});
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        ruptureCalculation.exitMaterial!,
+        substrate,
+        ruptureCalculation.dischargeResult!,
+        ruptureCalculation.dischargeRecords!,
+        ruptureCalculation.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 lastDispersionRecord = dispersionCalculation.dispersionRecords!.at(-1)!;
+      console.log(`Final centreline concentration = ${lastDispersionRecord.centrelineConcentration}`);
+      console.log(`Final downwind distance = ${lastDispersionRecord.downwindDistance}`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation,
+        resolution,
+        specialConcentration,
+        lflFractionValue: lflFraction,
+        componentToTrackName,
+      });
+  
+      const maxConcDistanceCalculation = new MaxConcDistanceCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        ruptureCalculation.exitMaterial!,
+        dispersionParameters
+      );
+  
+      const maxDistanceResult = await maxConcDistanceCalculation.run();
+  
+      if (maxConcDistanceCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxConcDistanceCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistanceResult).toBe(ResultCode.SUCCESS);
+  
+      const records = maxConcDistanceCalculation.concentrationRecords!;
+      expect(records.length).toBe(6);
+  
+      const lastRecord = records.at(-1)!;
+  
+      const expectedConcentration = 0.02586928069095842;
+      const expectedX = 26.782730275398364;
+  
+      const concError = Math.abs((lastRecord.concentration! - expectedConcentration) / expectedConcentration);
+      const xError = Math.abs((lastRecord.position.x - expectedX) / expectedX);
+  
+      expect(concError).toBeLessThan(1e-3);
+      expect(xError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: max_conc_distance_calculation (${maxConcDistanceCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+  

package/tests/max-conc-distance-calculation/testCase110.test.ts

@@ -0,0 +1,146 @@
+import { Material, MaterialComponent, State, Vessel, Substrate, Weather, DischargeParameters, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { MaxConcDistanceCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, Resolution, 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("Max Concentration Distance Calculation - Test Case 110", () => {
+    test("should match expected concentration regression for ETHANE", async () => {
+      const materialName = "ETHANE";
+      const endPointConcentration = 0.0;
+      const elevation = 3.0;
+      const resolution = Resolution.VERY_HIGH;
+      const specialConcentration = SpecialConcentration.UFL;
+      const lflFraction = 0.1;
+      const componentToTrackName = "";
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName })],
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.0e5,
+        liquidFraction: 0.0,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const vesselCatastrophicRuptureCalculation = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+      const ruptureResult = await vesselCatastrophicRuptureCalculation.run();
+  
+      if (vesselCatastrophicRuptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselCatastrophicRuptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselCatastrophicRuptureCalculation.calculationElapsedTime}ms)`);
+  
+      const substrate = new Substrate();
+      const weather = new Weather({windProfileFlag: windProfileFlag});
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        substrate,
+        vesselCatastrophicRuptureCalculation.dischargeResult!,
+        vesselCatastrophicRuptureCalculation.dischargeRecords!,
+        vesselCatastrophicRuptureCalculation.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 lastDispersionRecord = dispersionCalculation.dispersionRecords!.at(-1)!;
+      console.log(`Final centreline concentration = ${lastDispersionRecord.centrelineConcentration}`);
+      console.log(`Final downwind distance = ${lastDispersionRecord.downwindDistance}`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation,
+        resolution,
+        specialConcentration,
+        lflFractionValue: lflFraction,
+        componentToTrackName,
+      });
+  
+      const maxConcDistanceCalculation = new MaxConcDistanceCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        dispersionParameters
+      );
+  
+      const maxDistanceResult = await maxConcDistanceCalculation.run();
+  
+      if (maxConcDistanceCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxConcDistanceCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistanceResult).toBe(ResultCode.SUCCESS);
+  
+      const records = maxConcDistanceCalculation.concentrationRecords!;
+      expect(records.length).toBe(418);
+  
+      const lastRecord = records.at(-1)!;
+  
+      const expectedConcentration = 0.11220565556406681;
+      const expectedX = 3.5835448524927003;
+  
+      const concError = Math.abs((lastRecord.concentration! - expectedConcentration) / expectedConcentration);
+      const xError = Math.abs((lastRecord.position.x - expectedX) / expectedX);
+  
+      expect(concError).toBeLessThan(1e-3);
+      expect(xError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: max_conc_distance_calculation (${maxConcDistanceCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+