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

package/tests/pool-fire-calculation/testCase41.test.ts

@@ -0,0 +1,153 @@
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import { Material, MaterialComponent, State, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, FlammableParameters, FlammableOutputConfig, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, PoolFireType, ResultCode, 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("Vessel Catastrophic Rupture Integration - Test Case 41", () => {
+    test("should perform full integration including pool fire radiation output", async () => {
+  
+      // Define the material and its state
+      const material = new Material({
+        name: "N-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 vesselStateCalc = new VesselStateCalculation(material, state);
+      let resultCode = await vesselStateCalc.run();
+  
+      if (vesselStateCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: state,
+        material: material,
+        liquidFillFractionByVolume: 0.8,
+        vesselConditions: vesselStateCalc.vesselConditions,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParams);
+      resultCode = await ruptureCalc.run();
+  
+      if (ruptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+      });
+  
+      const substrate = new Substrate();
+  
+      const dispersionCalc = new DispersionCalculation(
+        ruptureCalc.exitMaterial!,
+        substrate,
+        ruptureCalc.dischargeResult!,
+        ruptureCalc.dischargeRecords!,
+        1,
+        weather,
+        new DispersionParameters(),
+        0.0
+      );
+  
+      resultCode = await dispersionCalc.run();
+  
+      if (dispersionCalc.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableParams = new FlammableParameters({
+        poolFireType: PoolFireType.LATE,
+      });
+  
+      const poolFireCalc = new PoolFireCalculation(
+        ruptureCalc.exitMaterial!,
+        dispersionCalc.poolRecords!,
+        dispersionCalc.poolRecords!.length,
+        weather,
+        substrate,
+        flammableParams
+      );
+  
+      resultCode = await poolFireCalc.run();
+  
+      if (poolFireCalc.messages.length > 0) {
+        console.log("Messages:");
+        poolFireCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [
+        { x: 0.0, y: 0.0, z: 0.0 },
+        { x: 0.0, y: 0.0, z: 1.0 },
+        { x: 0.0, y: 0.0, z: 2.0 },
+      ].map(({ x, y, z }) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({ x, y, z })
+        });
+      });
+  
+      const radiationCalc = new DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation(
+        poolFireCalc.poolFireFlameResult!,
+        poolFireCalc.flameRecords!,
+        poolFireCalc.flameRecords!.length,
+        weather,
+        flammableParams,
+        flammableOutputConfigs,
+        flammableOutputConfigs.length
+      );
+  
+      resultCode = await radiationCalc.run();
+  
+      if (radiationCalc.messages.length > 0) {
+        console.log("Messages:");
+        radiationCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Regression checks
+      expect(radiationCalc.contourPoints!.length).toBe(150);
+      const lastX = radiationCalc.contourPoints![radiationCalc.contourPoints!.length - 1].x!;
+      const expectedX = 76.36825073266586;
+      const relErrorX = Math.abs((lastX - expectedX) / expectedX);
+      expect(relErrorX).toBeLessThan(1e-3);
+  
+      const flameDiameter = radiationCalc.poolFireFlameResult.flameDiameter!;
+      const expectedDiameter = 50.3738899230957;
+      const relErrorDiameter = Math.abs((flameDiameter - expectedDiameter) / expectedDiameter);
+      expect(relErrorDiameter).toBeLessThan(1e-3);
+    });
+  });
+  

package/tests/pool-fire-calculation/testCase41a.test.ts

@@ -0,0 +1,141 @@
+import {  VesselCatastrophicRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { RadiationAtPointsForPoolFiresCalculation } from "../../src/calculations/radiation"; 
+import { Bund, Material, MaterialComponent, State, Vessel, Weather, Substrate, DischargeParameters, DispersionParameters, FlammableParameters, FlammableOutputConfig, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, PoolFireType, ResultCode, 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("Vessel Catastrophic Rupture Integration - Test Case 41a", () => {
+    test("should match radiation and flame diameter regression values", async () => {
+      const material = new Material(
+        {
+            name: "N-HEXANE", 
+            components:[ new MaterialComponent({name: "N-HEXANE", moleFraction: 1.0})]
+        });
+  
+      const state = new State({
+        temperature: 280.0,
+        pressure: 2.0e5,
+        liquidFraction: 0.8,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      let resultCode = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(vessel, dischargeParams);
+  
+      resultCode = await ruptureCalc.run();
+  
+      if (ruptureCalc.messages.length > 0) {
+        console.log("Messages:");
+        ruptureCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_F,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+      });
+  
+      const substrate = new Substrate({ bund: new Bund() });
+  
+      const dispersionCalc = new DispersionCalculation(
+        ruptureCalc.exitMaterial!,
+        substrate,
+        ruptureCalc.dischargeResult!,
+        ruptureCalc.dischargeRecords!,
+        ruptureCalc.dischargeRecords!.length,
+        weather,
+        new DispersionParameters(),
+        0.0
+      );
+  
+      resultCode = await dispersionCalc.run();
+  
+      if (dispersionCalc.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableParams = new FlammableParameters({
+        poolFireType: PoolFireType.LATE,
+      });
+  
+      const poolFireCalc = new PoolFireCalculation(
+        ruptureCalc.exitMaterial!,
+        dispersionCalc.poolRecords!,
+        dispersionCalc.poolRecords!.length,
+        weather,
+        substrate,
+        flammableParams
+      );
+  
+      resultCode = await poolFireCalc.run();
+  
+      if (poolFireCalc.messages.length > 0) {
+        console.log("Messages:");
+        poolFireCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [
+        new FlammableOutputConfig({ position: new LocalPosition({ x: 50.0, y: 0.0, z: 0.0 }) }),
+        new FlammableOutputConfig({ position: new LocalPosition({ x: 50.0, y: 0.0, z: 1.0 }) }),
+        new FlammableOutputConfig({ position: new LocalPosition({ x: 50.0, y: 3.0, z: 2.0 }) }),
+      ];
+  
+      const radiationCalc = new RadiationAtPointsForPoolFiresCalculation(
+        poolFireCalc.poolFireFlameResult!,
+        poolFireCalc.flameRecords!,
+        poolFireCalc.flameRecords!.length,
+        weather,
+        flammableParams,
+        flammableOutputConfigs,
+        flammableOutputConfigs.length
+      );
+  
+      resultCode = await radiationCalc.run();
+  
+      if (radiationCalc.messages.length > 0) {
+        console.log("Messages:");
+        radiationCalc.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const expectedRadiation = 11159.009681754622;
+      const expectedDiameter = 50.3738899230957;
+  
+      expect(Math.abs((radiationCalc.radiation![0] - expectedRadiation) / expectedRadiation)).toBeLessThan(1e-3);
+      expect(Math.abs((radiationCalc.poolFireFlameResult.flameDiameter! - expectedDiameter) / expectedDiameter)).toBeLessThan(1e-3);
+    });
+  });
+  

package/tests/pool-fire-calculation/testCase42.test.ts

@@ -0,0 +1,169 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire"
+import { DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import {Bund, DischargeParameters, DispersionParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, PoolFireType, ResultCode, TimeVaryingOption, 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("Vessel Leak Calculation Integration - Test Case 42", () => {
+    test("should produce correct radiation results for pool fire", async () => {
+      // Define the test case properties
+      const stateTemperature = 250.0;
+      const statePressure = 5.00e5;
+      const vesselShape = VesselShape.VERTICAL_CYLINDER;
+      const vesselHeight = 3.0;
+      const vesselDiameter = 1.5;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.TIME_VARYING_RATE;
+      const leakHoleHeightFraction = 0.0;
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      // Create state and material
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+      const material = new Material({name: 'N-OCTANE+N-HEPTANE', 
+        components: 
+        [
+            new MaterialComponent({name: 'N-OCTANE', moleFraction: 0.5}),
+            new MaterialComponent({name: 'N-HEPTANE', moleFraction: 0.5}),
+        ], 
+      componentCount: 2
+    });
+  
+      // Run vessel state calculation
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      let resultCode = await vesselStateCalc.run();
+  
+      if (vesselStateCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalc.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Create vessel and leak
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState,
+        material: vesselStateCalc.material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        diameter: vesselDiameter,
+        height: vesselHeight,
+        shape: vesselShape,
+        liquidFillFractionByVolume: 0.8,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption: timeVaryingOption,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+  
+      // Run vessel leak calculation
+      const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+      resultCode = await vesselLeakCalc.run();
+  
+      if (vesselLeakCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselLeakCalc.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Define weather and substrate
+      const weather = new Weather({
+        windSpeed: 2.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_E,
+        windProfileFlag: windProfileFlag
+      });
+      
+      const substrate = new Substrate();
+  
+      // Run dispersion calculation
+      const dispersionCalc = new DispersionCalculation(
+        vesselLeakCalc.exitMaterial!,
+        substrate,
+        vesselLeakCalc.dischargeResult!,
+        vesselLeakCalc.dischargeRecords!,
+        vesselLeakCalc.dischargeRecords!.length,
+        weather,
+        new DispersionParameters(),
+        0.0
+      );
+      resultCode = await dispersionCalc.run();
+  
+      if (dispersionCalc.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalc.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Define flammable parameters
+      const flammableParams = new FlammableParameters({
+        poolFireType: PoolFireType.LATE,
+      });
+  
+      // Run pool fire calculation
+    const poolFireCalc = new PoolFireCalculation(
+        vesselLeakCalc.exitMaterial!,
+        dispersionCalc.poolRecords!,
+        dispersionCalc.poolRecords!.length,
+        weather,
+        substrate,
+        flammableParams
+      );
+      resultCode = await poolFireCalc.run();
+  
+      if (poolFireCalc.messages.length > 0) {
+        console.log("Messages:");
+        poolFireCalc.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Define flammable output config
+      const flammableOutputConfigs = [0.0, 1.0, 2.0].map((z) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({ x: 0.0, y: 0.0, z }),
+        });
+      });
+  
+      // Run distances and ellipses to radiation levels for pool fires calculation
+      const radiationCalc = new DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation(
+        poolFireCalc.poolFireFlameResult!,
+        poolFireCalc.flameRecords!,
+        poolFireCalc.flameRecords!.length,
+        weather,
+        flammableParams,
+        flammableOutputConfigs,
+        flammableOutputConfigs.length
+      );
+      resultCode = await radiationCalc.run();
+  
+      if (radiationCalc.messages.length > 0) {
+        console.log("Messages:");
+        radiationCalc.messages.forEach((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Assertions for regression results
+      expect(radiationCalc.contourPoints!.length!).toBe(150);
+      expect(Math.abs((radiationCalc.contourPoints![radiationCalc.contourPoints!.length - 1].x - 57.57741153697067) / 57.57741153697067)).toBeLessThan(1e-3);
+      expect(Math.abs((radiationCalc.poolFireFlameResult.flameDiameter! - 36.82126235961914) / 36.82126235961914)).toBeLessThan(1e-3);
+    });
+  });
+  

package/tests/pool-fire-calculation/testCase42a.test.ts

@@ -0,0 +1,175 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { RadiationAtPointsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import {Bund, DischargeParameters, DispersionParameters, FlammableOutputConfig, FlammableParameters, Leak, LocalPosition, Material, MaterialComponent, State, Substrate, Transect, Vessel, Weather} from "../../src/entities";
+import { AtmosphericStabilityClass, PoolFireType, ResultCode, TimeVaryingOption, 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("Vessel Leak Calculation Integration - Case 42A", () => {
+    test("should complete all calculation steps and validate results", async () => {
+      const stateTemperature = 250.0;
+      const statePressure = 5.0e5;
+      const vesselShape = VesselShape.VERTICAL_CYLINDER;
+      const vesselHeight = 3.0;
+      const vesselDiameter = 1.5;
+      const leakHoleDiameter = 0.1;
+      const timeVaryingOption = TimeVaryingOption.TIME_VARYING_RATE;
+      const leakHoleHeightFraction = 0.0;
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.0,
+      });
+  
+      const material = new Material({
+        name: "N-OCTANE+N-HEPTANE",
+        components: [
+          new MaterialComponent({ name: "N-OCTANE", moleFraction: 0.5 }),
+          new MaterialComponent({ name: "N-HEPTANE", moleFraction: 0.5 }),
+        ],
+        componentCount: 2,
+      });
+  
+      const vesselStateCalc = new VesselStateCalculation(material, state);
+      let resultCode = await vesselStateCalc.run();
+  
+      if (vesselStateCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state: vesselStateCalc.outputState,
+        material: vesselStateCalc.material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        diameter: vesselDiameter,
+        height: vesselHeight,
+        shape: vesselShape,
+        liquidFillFractionByVolume: 0.8,
+      });
+  
+      const leak = new Leak({
+        holeDiameter: leakHoleDiameter,
+        holeHeightFraction: leakHoleHeightFraction,
+        timeVaryingOption,
+      });
+  
+      const dischargeParams = new DischargeParameters();
+      const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+      resultCode = await vesselLeakCalc.run();
+  
+      if (vesselLeakCalc.messages.length > 0) {
+        console.log("Messages:");
+        vesselLeakCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({
+        windSpeed: 2.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_E,
+        windProfileFlag: windProfileFlag
+      });
+  
+      const substrate = new Substrate();
+  
+      const dispersionCalc = new DispersionCalculation(
+        vesselLeakCalc.exitMaterial!,
+        substrate,
+        vesselLeakCalc.dischargeResult!,
+        vesselLeakCalc.dischargeRecords!,
+        vesselLeakCalc.dischargeRecords!.length,
+        weather,
+        new DispersionParameters(),
+        0.0
+      );
+  
+      resultCode = await dispersionCalc.run();
+  
+      if (dispersionCalc.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableParams = new FlammableParameters({
+        poolFireType: PoolFireType.LATE,
+      });
+  
+      const poolFireCalc = new PoolFireCalculation(
+        vesselLeakCalc.exitMaterial!,
+        dispersionCalc.poolRecords!,
+        dispersionCalc.poolRecords!.length,
+        weather,
+        substrate,
+        flammableParams
+      );
+  
+      resultCode = await poolFireCalc.run();
+  
+      if (poolFireCalc.messages.length > 0) {
+        console.log("Messages:");
+        poolFireCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableOutputConfigs = [
+        { x: 0.0, y: 0.0, z: 0.0 },
+        { x: 0.0, y: 0.0, z: 1.0 },
+        { x: 0.0, y: 0.0, z: 2.0 },
+      ].map(({ x, y, z }) => {
+        return new FlammableOutputConfig({
+          position: new LocalPosition({ x, y, z })
+        });
+      });
+  
+      const radiationCalc = new RadiationAtPointsForPoolFiresCalculation(
+        poolFireCalc.poolFireFlameResult!,
+        poolFireCalc.flameRecords!,
+        poolFireCalc.flameRecords!.length,
+        weather,
+        flammableParams,
+        flammableOutputConfigs,
+        flammableOutputConfigs.length
+      );
+  
+      resultCode = await radiationCalc.run();
+  
+      if (radiationCalc.messages.length > 0) {
+        console.log("Messages:");
+        radiationCalc.messages.forEach((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      // Regression assertions
+      const expectedRadiation = 138315.75;
+      const actualRadiation = radiationCalc.radiation![0];
+  
+      expect(
+        Math.abs((actualRadiation - expectedRadiation) / expectedRadiation)
+      ).toBeLessThan(1e-3);
+  
+      const expectedFlameDiameter = 36.82126235961914;
+      const actualFlameDiameter = radiationCalc.poolFireFlameResult.flameDiameter!;
+  
+      expect(
+        Math.abs((actualFlameDiameter - expectedFlameDiameter) / expectedFlameDiameter)
+      ).toBeLessThan(1e-3);
+    });
+  });
+