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

package/tests/set-phase-to-be-released-for-leak-calculation/testCase150.test.ts

@@ -0,0 +1,67 @@
+import { SetPhaseToReleaseForLeakScenarioCalculation } from "../../src/calculations/utilities";
+import { Material, MaterialComponent, State, Vessel } from "../../src/entities";
+import { Phase, ResultCode, VesselConditions, 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("SetPhaseToReleaseForLeakScenarioCalculation", () => {
+  test("should set correct phase to release for leak scenario", async () => {
+    const material = new Material({
+      name: "N-PENTANE+METHANE",
+      components: [
+        new MaterialComponent({ name: "N-PENTANE", moleFraction: 0.5 }),
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.5 }),
+      ],
+      componentCount: 2,
+    });
+
+    const state = new State({
+      temperature: 280.0,
+      pressure: 8.0e6,
+      liquidFraction: 0.8,
+    });
+
+    const vessel = new Vessel({
+      state,
+      material,
+      diameter: 5.0,
+      shape: VesselShape.VESSEL_SPHERE,
+      vesselConditions: VesselConditions.STRATIFIED_TWO_PHASE_VESSEL,
+      liquidFillFractionByVolume: 0.6,
+    });
+
+    const calc = new SetPhaseToReleaseForLeakScenarioCalculation(
+      Phase.LIQUID,
+      1.0,
+      vessel
+    );
+
+    console.log("Running set_phase_to_be_released_for_leak_scenario_calculation...");
+    const resultCode = await calc.run();
+    calc.messages.forEach((msg) => console.log(msg));
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Validation
+    const expectedPhaseToRelease = 3; // Phase.LIQUID
+    const actualPhaseToRelease = calc.phaseToRelease;
+    expect(actualPhaseToRelease).toBe(expectedPhaseToRelease);
+
+    const expectedHoleHeightFraction = 0.5668689228522562;
+    const actualHoleHeightFraction = calc.holeHeightFractionUpdated!;
+    const relError = Math.abs(
+      (actualHoleHeightFraction - expectedHoleHeightFraction) /
+      expectedHoleHeightFraction
+    );
+    expect(relError).toBeLessThan(1e-3);
+
+    console.log(
+      `SUCCESS: set_phase_to_be_released_for_leak_scenario_calculation (${calc.calculationElapsedTime}ms)`
+    );
+  });
+});

package/tests/set-phase-to-be-released-for-line-rupture-calculation/testCase151.test.ts

@@ -0,0 +1,67 @@
+import { SetPhaseToReleaseForLineRuptureScenarioCalculation } from "../../src/calculations/utilities";
+import { Material, MaterialComponent, State, Vessel } from "../../src/entities";
+import { Phase, ResultCode, VesselConditions, 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("SetPhaseToReleaseForLineRuptureScenarioCalculation", () => {
+  test("should set correct phase to release for line rupture scenario", async () => {
+    const material = new Material({
+      name: "N-PENTANE+METHANE",
+      components: [
+        new MaterialComponent({ name: "N-PENTANE", moleFraction: 0.5 }),
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.5 }),
+      ],
+      componentCount: 2,
+    });
+
+    const state = new State({
+      temperature: 280.0,
+      pressure: 8.0e6,
+      liquidFraction: 0.8,
+    });
+
+    const vessel = new Vessel({
+      state,
+      material,
+      diameter: 5.0,
+      shape: VesselShape.VESSEL_SPHERE,
+      vesselConditions: VesselConditions.STRATIFIED_TWO_PHASE_VESSEL,
+      liquidFillFractionByVolume: 0.6,
+    });
+
+    const calc = new SetPhaseToReleaseForLineRuptureScenarioCalculation(
+      Phase.LIQUID,
+      1.0,
+      vessel
+    );
+
+    console.log("Running set_phase_to_be_released_for_line_rupture_scenario_calculation...");
+    const resultCode = await calc.run();
+    calc.messages.forEach((msg) => console.log(msg));
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Validation
+    const expectedPhaseToRelease = 3; // Phase.LIQUID
+    const actualPhaseToRelease = calc.phaseToRelease;
+    expect(actualPhaseToRelease).toBe(expectedPhaseToRelease);
+
+    const expectedPipeHeightFraction = 0.5668689228522562;
+    const actualPipeHeightFraction = calc.pipeHeightFractionUpdated!;
+    const relError = Math.abs(
+      (actualPipeHeightFraction - expectedPipeHeightFraction) /
+      expectedPipeHeightFraction
+    );
+    expect(relError).toBeLessThan(1e-3);
+
+    console.log(
+      `SUCCESS: set_phase_to_be_released_for_line_rupture_scenario_calculation (${calc.calculationElapsedTime}ms)`
+    );
+  });
+});

package/tests/set-phase-to-be-released-for-relief-valve-calculation/TestCase152.test.ts

@@ -0,0 +1,61 @@
+import {SetPhaseToReleaseForReliefValveScenarioCalculation} from "../../src/calculations/utilities";
+import {Material,MaterialComponent,State,Vessel} from "../../src/entities";
+import {Phase,ResultCode,VesselConditions,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("SetPhaseToReleaseForReliefValveScenarioCalculation", () => {
+    test("should set correct phase to release for relief valve scenario", async () => {
+      const material = new Material({
+        name: "N-PENTANE+METHANE",
+        components: [
+          new MaterialComponent({ name: "N-PENTANE", moleFraction: 0.5 }),
+          new MaterialComponent({ name: "METHANE", moleFraction: 0.5 }),
+        ],
+        componentCount: 2,
+      });
+  
+      const state = new State({
+        temperature: 280.0,
+        pressure: 8.0e6,
+        liquidFraction: 0.8,
+      });
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        diameter: 5.0,
+        shape: VesselShape.VESSEL_SPHERE,
+        vesselConditions: VesselConditions.STRATIFIED_TWO_PHASE_VESSEL,
+        liquidFillFractionByVolume: 0.6,
+      });
+  
+      const calc = new SetPhaseToReleaseForReliefValveScenarioCalculation(Phase.VAPOUR, 1.0, vessel);
+  
+      console.log("Running set_phase_to_be_released_for_relief_valve_scenario_calculation...");
+      const resultCode = await calc.run();
+      calc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Validation
+      const expectedPhaseToRelease = 1.0;
+      const actualPhaseToRelease = calc.phaseToRelease;
+      expect(actualPhaseToRelease).toBeCloseTo(expectedPhaseToRelease, 6);
+  
+      const expectedPipeHeightFraction = 1.0;
+      const actualPipeHeightFraction = calc.pipeHeightFractionUpdated!;
+      const relError = Math.abs((actualPipeHeightFraction - expectedPipeHeightFraction) / expectedPipeHeightFraction);
+      expect(relError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: set_phase_to_be_released_for_relief_valve_scenario_calculation (${calc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/sideview/testCase31b.test.ts

@@ -0,0 +1,150 @@
+import {VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { SideviewAtTimeCalculation} from "../../src/calculations/dispersionView";
+import {Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, LocalPosition, 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("SideviewAtTimeCalculation", () => {
+    test("should calculate correct sideview dispersion for ETHANE_BUTANE_PROPANE", 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 vesselStateCalc = new VesselStateCalculation(material, state);
+  
+      console.log("Running vessel_state_calculation...");
+      let resultCode = await vesselStateCalc.run();
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalc.vesselConditions!,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(
+        vessel,
+        dischargeParams
+      );
+  
+      console.log("Running vessel_catastrophic_rupture_calculation...");
+      resultCode = await ruptureCalc.run();
+      ruptureCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      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 dispersionParams = new DispersionParameters();
+      const dispersionCalc = new DispersionCalculation(
+        ruptureCalc.exitMaterial!,
+        substrate,
+        ruptureCalc.dischargeResult!,
+        ruptureCalc.dischargeRecords!,
+        ruptureCalc.dischargeRecords!.length,
+        weather,
+        dispersionParams,
+        endPointConcentration
+      );
+  
+      console.log("Running dispersion_calculation...");
+      resultCode = await dispersionCalc.run();
+      dispersionCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const outputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        time: 0,
+      });
+  
+      const sideviewCalc = new SideviewAtTimeCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        outputConfig,
+        ruptureCalc.exitMaterial!,
+        dispersionParams,
+      );
+  
+      console.log("Running sideview_at_time_calculation...");
+      resultCode = await sideviewCalc.run();
+      sideviewCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const contourPoints = sideviewCalc.contourPoints!;
+      const dispersionRecords = sideviewCalc.dispersionRecords!;
+  
+      // Check number of contour points
+      expect(contourPoints.length).toBe(190);
+  
+      // Check one of the final contour point's x-values
+      const targetContourPoint = contourPoints[contourPoints.length - 3];
+      const expectedX = 2.8916389790099224;
+      const xError = Math.abs((targetContourPoint.x - expectedX) / expectedX);
+      expect(xError).toBeLessThan(1e-3);
+  
+      // Check final dispersion record's centreline concentration
+      const lastDispersion = dispersionRecords[dispersionRecords.length - 1];
+      const expectedConc = 0.004768006933732604;
+      const concError = Math.abs(
+        (lastDispersion.centrelineConcentration! - expectedConc) / expectedConc
+      );
+      expect(concError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: sideview_at_time_calculation (${sideviewCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/sideview/testCase32b.test.ts

@@ -0,0 +1,145 @@
+import {VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { SideviewAtTimeCalculation} from "../../src/calculations/dispersionView";
+import {Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, LocalPosition, 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("SideviewAtTimeCalculation", () => {
+    test("should calculate correct sideview dispersion for HEXANE", async () => {
+      const material = new Material({
+        name: "HEXANE",
+        components: [new MaterialComponent({ name: "N-HEXANE", moleFraction: 1.0 })],
+      });
+  
+      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 vesselStateCalc = new VesselStateCalculation(material, state);
+  
+      console.log("Running vessel_state_calculation...");
+      let resultCode = await vesselStateCalc.run();
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalc.vesselConditions!,
+      });
+  
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(
+        vessel,
+        new DischargeParameters()
+      );
+  
+      console.log("Running vessel_catastrophic_rupture_calculation...");
+      resultCode = await ruptureCalc.run();
+      ruptureCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      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 dispersionParams = new DispersionParameters();
+  
+      const dispersionCalc = new DispersionCalculation(
+        ruptureCalc.exitMaterial!,
+        substrate,
+        ruptureCalc.dischargeResult!,
+        ruptureCalc.dischargeRecords!,
+        ruptureCalc.dischargeRecords!.length,
+        weather,
+        dispersionParams,
+        endPointConcentration
+      );
+  
+      console.log("Running dispersion_calculation...");
+      resultCode = await dispersionCalc.run();
+      dispersionCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const outputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        time: 0.5,
+      });
+  
+      const sideviewCalc = new SideviewAtTimeCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        outputConfig,
+        ruptureCalc.exitMaterial!,
+        dispersionParams
+      );
+  
+      console.log("Running sideview_at_time_calculation...");
+      resultCode = await sideviewCalc.run();
+      sideviewCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const contourPoints = sideviewCalc.contourPoints!;
+      const dispersionRecords = sideviewCalc.dispersionRecords!;
+  
+      // Check number of contour points
+      expect(contourPoints.length).toBe(279);
+  
+      // Check x-value of the third-from-last contour point
+      const targetContourPoint = contourPoints[contourPoints.length - 3];
+      const expectedX = 3.8448647902534274;
+      const xError = Math.abs((targetContourPoint.x - expectedX) / expectedX);
+      expect(xError).toBeLessThan(1e-3);
+  
+      // Check centreline concentration of the last dispersion record
+      const lastDispersion = dispersionRecords[dispersionRecords.length - 1];
+      const expectedConc = 0.0033212173007439575;
+      const concError = Math.abs(
+        (lastDispersion.centrelineConcentration! - expectedConc) / expectedConc
+      );
+      expect(concError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: sideview_at_time_calculation (${sideviewCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/sideview/testCase33b.test.ts

@@ -0,0 +1,130 @@
+import {VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { SideviewAtTimeCalculation} from "../../src/calculations/dispersionView";
+import {Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, LocalPosition, Leak, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, 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("SideviewAtTimeCalculation", () => {
+    test("should calculate correct sideview dispersion for CARBON DIOXIDE (TOXIC)", async () => {
+      const material = new Material({
+        name: "CARBON DIOXIDE (TOXIC)",
+        components: [new MaterialComponent({ name: "CARBON DIOXIDE (TOXIC)", moleFraction: 1.0 })],
+      });
+  
+      const state = new State({
+        temperature: 280.0,
+        pressure: 8.0e6,
+        liquidFraction: 0.0,
+      });
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+  
+      console.log("Running vessel_state_calculation...");
+      let resultCode = await vesselStateCalc.run();
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState!,
+        material: vesselStateCalc.material!,
+        vesselConditions: vesselStateCalc.vesselConditions!,
+        diameter: 5.0,
+        shape: VesselShape.VESSEL_SPHERE,
+        liquidFillFractionByVolume: 0.8,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: 0.008,
+        holeHeightFraction: 0.5,
+        timeVaryingOption: TimeVaryingOption.INITIAL_RATE,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const leakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+  
+      console.log("Running vessel_leak_calculation...");
+      resultCode = await leakCalc.run();
+      leakCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const substrate = new Substrate({
+        surfaceType: SurfaceType.WATER,
+        surfaceRoughness: 0.01,
+      });
+  
+      const weather = new Weather({
+        windSpeed: 4.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_C,
+        windProfileFlag: windProfileFlag
+      });
+  
+      const dispersionParams = new DispersionParameters();
+  
+      const dispersionCalc = new DispersionCalculation(
+        leakCalc.exitMaterial!,
+        substrate,
+        leakCalc.dischargeResult!,
+        leakCalc.dischargeRecords!,
+        leakCalc.dischargeRecords!.length,
+        weather,
+        dispersionParams,
+        0.0
+      );
+  
+      console.log("Running dispersion_calculation...");
+      resultCode = await dispersionCalc.run();
+      dispersionCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const outputConfig = new DispersionOutputConfig({
+        concentration: 0.0,
+      });
+  
+      const sideviewCalc = new SideviewAtTimeCalculation(
+        dispersionCalc.scalarUdmOutputs!,
+        weather,
+        dispersionCalc.dispersionRecords!,
+        dispersionCalc.dispersionRecords!.length,
+        substrate,
+        outputConfig,
+        leakCalc.exitMaterial!,
+        dispersionParams
+      );
+  
+      console.log("Running sideview_at_time_calculation...");
+      resultCode = await sideviewCalc.run();
+      sideviewCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const contourPoints = sideviewCalc.contourPoints!;
+      const dispersionRecords = sideviewCalc.dispersionRecords!;
+  
+      expect(contourPoints.length).toBe(171);
+  
+      const targetContourPoint = contourPoints[contourPoints.length - 3];
+      const expectedX = 6.9777184369577;
+      const xError = Math.abs((targetContourPoint.x - expectedX) / expectedX);
+      expect(xError).toBeLessThan(1e-3);
+  
+      const lastDispersion = dispersionRecords[dispersionRecords.length - 1];
+      const expectedConc = 0.03998493262289725;
+      const concError = Math.abs(
+        (lastDispersion.centrelineConcentration! - expectedConc) / expectedConc
+      );
+      expect(concError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: sideview_at_time_calculation (${sideviewCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+