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

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

@@ -0,0 +1,169 @@
+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 { MaxConcFootprintCalculation } 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 Concentration Footprint Calculation - Test Case 31", () => {
+    test("should calculate max concentration footprint correctly", async () => {
+      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,
+      });
+  
+      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;
+  
+      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 bund = new Bund({
+        specifyBund,
+        bundHeight,
+        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 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,
+        vesselCatastrophicRuptureCalculation.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);
+  
+      // Regression check
+      const expectedLength = 723;
+      const expectedX = -7.7737846974650235;
+      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-conc-footprint-calculation/testCase32.test.ts

@@ -0,0 +1,183 @@
+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 { MaxConcFootprintCalculation } 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 Concentration Footprint Calculation - Test Case 32", () => {
+    test("should calculate max concentration footprint correctly for HEXANE", async () => {
+      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,
+      });
+  
+      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;
+  
+      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 bund = new Bund({
+        specifyBund,
+        bundHeight,
+        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 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}`
+      );
+      console.log(
+        `final centreline concentration = ${
+          dispersionCalculation.dispersionRecords!.at(-1)!.centrelineConcentration
+        }`
+      );
+      console.log(
+        `final downwind distance = ${
+          dispersionCalculation.dispersionRecords!.at(-1)!.downwindDistance
+        }`
+      );
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+      });
+  
+      const maxConcFootprintCalculation = new MaxConcFootprintCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        vesselCatastrophicRuptureCalculation.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);
+  
+      // Regression check
+      const expectedLength = 569;
+      const expectedX = -5.466432738453024;
+      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-conc-footprint-calculation/testCase33.test.ts

@@ -0,0 +1,161 @@
+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 { 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 33", () => {
+    test("should correctly calculate maximum concentration footprint", async () => {
+      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;
+  
+      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 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: vesselStateCalculation.outputState!,
+        material: vesselStateCalculation.material,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+        diameter: vesselDiameter,
+        shape: vesselShape,
+        liquidFillFractionByVolume: 0.8,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const vesselLeakCalculation = new VesselLeakCalculation(vessel, leak, dischargeParameters);
+      const leakResult = await vesselLeakCalculation.run();
+  
+      if (vesselLeakCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselLeakCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(leakResult).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 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,
+        elevation: 2.5,
+      });
+  
+      const maxConcFootprintCalculation = new MaxConcFootprintCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        vesselLeakCalculation.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 = 553;
+      const expectedX = -0.09459660419095317;
+      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-conc-footprint-calculation/testCase34.test.ts

@@ -0,0 +1,172 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig, LineRupture } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation, VesselLeakCalculation, VesselLineRuptureCalculation } 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 34", () => {
+    test("should calculate max concentration footprint correctly", async () => {
+      const material = new Material(
+        {
+            name: "AMMONIA", 
+            components: 
+            [
+                new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 }),
+            ]
+        });
+  
+      const state = new State({
+        temperature: 290.0,
+        pressure: 7.0e6,
+        liquidFraction: 1.0,
+      });
+  
+      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;
+  
+      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,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+        liquidFillFractionByVolume: 0.7,
+        shape: VesselShape.VESSEL_CUBOID,
+        height: 2.0,
+        width: 1.0,
+        length: 3.0,
+      });
+  
+      const lineRupture = new LineRupture({
+        pipeDiameter: 0.1,
+        pipeLength: 1.0,
+        pipeHeightFraction: 0.1,
+      });
+  
+      const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(
+        vessel,
+        lineRupture,
+        new DischargeParameters()
+      );
+  
+      const ruptureResult = await vesselLineRuptureCalculation.run();
+  
+      if (vesselLineRuptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselLineRuptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+  
+      const bund = new Bund({
+        specifyBund,
+        bundHeight,
+        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(
+        vesselLineRuptureCalculation.exitMaterial!,
+        substrate,
+        vesselLineRuptureCalculation.dischargeResult!,
+        vesselLineRuptureCalculation.dischargeRecords!,
+        vesselLineRuptureCalculation.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,
+        vesselLineRuptureCalculation.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);
+  
+      // Regression Check
+      const expectedLength = 587;
+      const expectedX = -0.3224436750622628;
+      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)`);
+    });
+  });
+