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

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

@@ -0,0 +1,194 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { DistancesAndEllipsesToRadiationLevelsCalculation} from "../../src/calculations/radiation";
+import { Bund, DischargeParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, TimeVaryingOption, VesselShape } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("Test Case 64 - Distances and Ellipses to Radiation Levels Scenario", () => {
+  test("should run vessel state, leak, jet fire, and distances/ellipses calculations with regression checks", async () => {
+    // Define case properties
+    const materialName = "METHANE";
+    const stateTemperature = 280.0;
+    const statePressure = 1.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.5;
+    const liquidFillFractionByVolume = 0.0;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 3600.0;
+    const radiationResolution = Resolution.MEDIUM;
+
+    // Define material and state
+    const material = new Material({
+      name: materialName,
+      components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: 0.0,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+
+    console.log("Running vessel_state_calculation...");
+    const vesselStateResult = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState!,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition({ x: 0, y: 0, z: 0 }),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+
+    console.log("Running vessel_leak_calculation...");
+    const leakResult = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(leakResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Set up entities for jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+    });
+
+    const substrate = new Substrate({
+      bund: new Bund({ specifyBund: false }),
+    });
+
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+    });
+
+    // Jet fire calculation
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jet_fire_calculation...");
+    const jetFireResult = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(jetFireResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: jet_fire_calculation (${jetFireCalc.calculationElapsedTime}ms)`);
+
+    // Flammable output configurations
+    const flammableOutputConfigs = [
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 1.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 2.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+    ];
+
+    // Distances and ellipses to radiation levels calculation
+    const distancesEllipsesCalc = new DistancesAndEllipsesToRadiationLevelsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters!,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    console.log("Running distances_and_ellipses_to_radiation_levels_calculation...");
+    const distancesEllipsesResult = await distancesEllipsesCalc.run();
+
+    if (distancesEllipsesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesEllipsesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesEllipsesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesEllipsesCalc.contourPoints!.length).toBe(150);
+
+    if (distancesEllipsesCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesEllipsesCalc.contourPoints![distancesEllipsesCalc.contourPoints!.length - 1].x - 58.40830479872616) / 58.40830479872616
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const areaError = Math.abs(
+      (distancesEllipsesCalc.areas![0] - 3563.332415345197) / 3563.332415345197
+    );
+    expect(areaError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_and_ellipses_to_radiation_levels_calculation (${distancesEllipsesCalc.calculationElapsedTime}ms)`);
+  });
+});

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

@@ -0,0 +1,197 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { DistancesAndEllipsesToRadiationLevelsCalculation } from "../../src/calculations/radiation";
+import { Bund, DischargeParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, TimeVaryingOption, VesselShape } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("Test Case 65 - Distances and Ellipses to Radiation Levels Scenario", () => {
+  test("should run vessel state, leak, jet fire, and distances/ellipses calculations with regression checks", async () => {
+    // Define case properties
+    const materialName = "N-BUTANE";
+    const stateTemperature = 220.0;
+    const statePressure = 1.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.5;
+    const liquidFillFractionByVolume = 0.5;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.HIGH;
+
+    // Define material and state
+    const material = new Material({
+      name: materialName,
+      components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: 0.0,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+
+    console.log("Running vessel_state_calculation...");
+    const vesselStateResult = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState!,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition({ x: 0, y: 0, z: 0 }),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+
+    console.log("Running vessel_leak_calculation...");
+    const leakResult = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(leakResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Set up entities for jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+    });
+
+    const substrate = new Substrate({
+      bund: new Bund({ specifyBund: false }),
+    });
+
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+    });
+
+    // Jet fire calculation
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jet_fire_calculation...");
+    const jetFireResult = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(jetFireResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: jet_fire_calculation (${jetFireCalc.calculationElapsedTime}ms)`);
+
+    // Flammable output configurations
+    const flammableOutputConfigs = [
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 2.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 4.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 5.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+    ];
+
+    // Distances and ellipses to radiation levels calculation
+    const distancesEllipsesCalc = new DistancesAndEllipsesToRadiationLevelsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters!,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    console.log("Running distances_and_ellipses_to_radiation_levels_calculation...");
+    const distancesEllipsesResult = await distancesEllipsesCalc.run();
+
+    if (distancesEllipsesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesEllipsesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesEllipsesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesEllipsesCalc.contourPoints!.length).toBe(150);
+
+    if (distancesEllipsesCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesEllipsesCalc.contourPoints![distancesEllipsesCalc.contourPoints!.length - 1].x - 302.89074103021574) /
+          302.89074103021574
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const areaError = Math.abs(
+      (distancesEllipsesCalc.areas![0] - 118325.3837897791) / 118325.3837897791
+    );
+    expect(areaError).toBeLessThan(1e-3);
+
+    console.log(
+      `SUCCESS: distances_and_ellipses_to_radiation_levels_calculation (${distancesEllipsesCalc.calculationElapsedTime}ms)`
+    );
+  });
+});

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

@@ -0,0 +1,194 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { DistancesAndEllipsesToRadiationLevelsCalculation } from "../../src/calculations/radiation";
+import { Bund, DischargeParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, TimeVaryingOption, VesselShape } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("Test Case 66 - Distances and Ellipses to Radiation Levels Scenario", () => {
+  test("should run vessel state, leak, jet fire, and distances/ellipses calculations with regression checks", async () => {
+    // Define case properties
+    const materialName = "PROPANE";
+    const stateTemperature = 290.0;
+    const statePressure = 5.0e5;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.3;
+    const liquidFillFractionByVolume = 0.4;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.LOW;
+
+    // Define material and state
+    const material = new Material({
+      name: materialName,
+      components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: 0.0,
+    });
+
+    // Vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+
+    console.log("Running vessel_state_calculation...");
+    const vesselStateResult = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Define vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState!,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition({ x: 0, y: 0, z: 0 }),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume,
+    });
+
+    // Define leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+
+    console.log("Running vessel_leak_calculation...");
+    const leakResult = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(leakResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Set up entities for jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+    });
+
+    const substrate = new Substrate({
+      bund: new Bund({ specifyBund: false }),
+    });
+
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+    });
+
+    // Jet fire calculation
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jet_fire_calculation...");
+    const jetFireResult = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(jetFireResult).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: jet_fire_calculation (${jetFireCalc.calculationElapsedTime}ms)`);
+
+    // Flammable output configurations
+    const flammableOutputConfigs = [
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 2.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 3.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+      new FlammableOutputConfig({
+        position: new LocalPosition({ x: 0.0, y: 0.0, z: 6.0 }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+          transectEndPoint: new LocalPosition({ x: 0.0, y: 0.0, z: 0.0 }),
+        }),
+        radiationResolution: radiationResolution,
+      }),
+    ];
+
+    // Distances and ellipses to radiation levels calculation
+    const distancesEllipsesCalc = new DistancesAndEllipsesToRadiationLevelsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters!,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    console.log("Running distances_and_ellipses_to_radiation_levels_calculation...");
+    const distancesEllipsesResult = await distancesEllipsesCalc.run();
+
+    if (distancesEllipsesCalc.messages.length > 0) {
+      console.log("Messages:");
+      distancesEllipsesCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(distancesEllipsesResult).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    expect(distancesEllipsesCalc.contourPoints!.length).toBe(150);
+
+    if (distancesEllipsesCalc.contourPoints!.length > 0) {
+      const contourPointError = Math.abs(
+        (distancesEllipsesCalc.contourPoints![distancesEllipsesCalc.contourPoints!.length - 1].x - 54.11820446994824) / 54.11820446994824
+      );
+      expect(contourPointError).toBeLessThan(1e-3);
+    }
+
+    const areaError = Math.abs(
+      (distancesEllipsesCalc.areas![0] - 3641.2004589975213) / 3641.2004589975213
+    );
+    expect(areaError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: distances_and_ellipses_to_radiation_levels_calculation (${distancesEllipsesCalc.calculationElapsedTime}ms)`);
+  });
+});