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

package/tests/sideview/testCase34b.test.ts

@@ -0,0 +1,153 @@
+import {VesselCatastrophicRuptureCalculation, VesselStateCalculation, VesselLeakCalculation, VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { SideviewAtTimeCalculation} from "../../src/calculations/dispersionView";
+import {Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, LineRupture, 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 - AMMONIA line rupture", () => {
+    test("should calculate correct sideview dispersion for AMMONIA with line rupture", 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 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,
+        vesselConditions: vesselStateCalc.vesselConditions!,
+        liquidFillFractionByVolume: 0.7,
+        shape: VesselShape.VESSEL_CUBOID,
+        height: 2,
+        width: 1,
+        length: 3,
+      });
+  
+      const lineRupture = new LineRupture({
+        pipeDiameter: 0.1,
+        pipeLength: 1.0,
+        pipeHeightFraction: 0.1,
+      });
+  
+      const ruptureCalc = new VesselLineRuptureCalculation(
+        vessel,
+        lineRupture,
+        new DischargeParameters()
+      );
+  
+      console.log("Running vessel_line_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,
+      });
+  
+      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(56);
+  
+      // Check x-value of the third-from-last contour point
+      const targetContourPoint = contourPoints[contourPoints.length - 3];
+      const expectedX = 288.38690766280035;
+      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.0005178235809216942;
+      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/testCase35b.test.ts

@@ -0,0 +1,140 @@
+import {VesselStateCalculation, VesselLeakCalculation, VesselReliefValveCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { SideviewAtTimeCalculation} from "../../src/calculations/dispersionView";
+import {Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, LocalPosition, Leak, ReliefValve, 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 CHLORINE via relief valve", async () => {
+      const state = new State({
+        temperature: 320.0,
+        pressure: 1.0e6,
+        liquidFraction: 1.0,
+      });
+  
+      const material = new Material({
+        name: "CHLORINE",
+        components: [new MaterialComponent({ name: "CHLORINE", moleFraction: 1.0 })],
+      });
+  
+      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,
+        vesselConditions: vesselStateCalc.vesselConditions!,
+        liquidFillFractionByVolume: 0.7,
+        shape: VesselShape.HORIZONTAL_CYLINDER,
+        diameter: 2.0,
+        length: 5.0,
+      });
+  
+      const reliefValve = new ReliefValve({
+        pipeDiameter: 0.02,
+        pipeLength: 10.0,
+        pipeHeightFraction: 1.0,
+        reliefValveConstrictionDiameter: 0.02,
+      });
+  
+      const reliefValveCalc = new VesselReliefValveCalculation(
+        vessel,
+        reliefValve,
+        new DischargeParameters()
+      );
+  
+      console.log("Running vessel_relief_valve_calculation...");
+      resultCode = await reliefValveCalc.run();
+      reliefValveCalc.messages.forEach((msg) => console.log(msg));
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+      console.log(`Relief valve release mass: ${reliefValveCalc.dischargeResult!.releaseMass} [kg]`);
+  
+      const bund = new Bund({
+        specifyBund: true,
+        bundHeight: 0.5,
+        bundDiameter: 5.0,
+      });
+  
+      const substrate = new Substrate({
+        bund,
+        surfaceType: SurfaceType.LAND,
+        surfaceRoughness: 0.183,
+      });
+  
+      const weather = new Weather({
+        windSpeed: 1.5,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+      });
+  
+      const dispersionParams = new DispersionParameters();
+  
+      const dispersionCalc = new DispersionCalculation(
+        reliefValveCalc.exitMaterial!,
+        substrate,
+        reliefValveCalc.dischargeResult!,
+        reliefValveCalc.dischargeRecords!,
+        reliefValveCalc.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,
+        reliefValveCalc.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(197);
+  
+      const targetX = 130.8644880935483;
+      const actualX = contourPoints[contourPoints.length - 3].x;
+      const xError = Math.abs((actualX - targetX) / targetX);
+      expect(xError).toBeLessThan(1e-3);
+  
+      const expectedConc = 1.4451621633042375e-05;
+      const actualConc = dispersionRecords[dispersionRecords.length - 1].centrelineConcentration!;
+      const concError = Math.abs((actualConc - expectedConc) / expectedConc);
+      expect(concError).toBeLessThan(1e-3);
+  
+      console.log(
+        `SUCCESS: sideview_at_time_calculation (${sideviewCalc.calculationElapsedTime}ms)`
+      );
+    });
+  });
+  

package/tests/tank-fire-calculation/testCase79.test.ts

@@ -0,0 +1,61 @@
+import { TankFireCalculation } from "../../src/calculations/standalones";
+import { Material, MaterialComponent, FlammableParameters, AtmosphericStorageTank , State, Weather, Substrate, } from "../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, PoolFireType } 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('TankFireCalculation', () => {
+    test('should calculate fire properties correctly', async () => {
+        // Set the case properties.
+        const materialName = "N-HEXANE";
+        const diameter = 1.0;
+        const height = 3.0;
+        const windSpeed = 1.5;
+        const fireType = PoolFireType.LATE;
+        const weatherStability = AtmosphericStabilityClass.STABILITY_F;
+
+        // Define the initial state of the tank.
+        const state = new State({temperature: 250.0, pressure: 1.0E+06, liquidFraction: 0.0});
+
+        // Define the material contained by the tank.
+        const material = new Material({name: materialName, components: [new MaterialComponent({name:materialName, moleFraction: 1.0})]});
+
+        // Define the weather conditions
+        const weather = new Weather({windSpeed: windSpeed, stabilityClass: weatherStability});
+
+        // Define the substrate
+        const substrate = new Substrate();
+
+        // Define the flammable parameters
+        const flammableParameters = new FlammableParameters({poolFireType: fireType});
+
+        // Define the conditions of the tank
+        const tank = new AtmosphericStorageTank({state: state, material: material, diameter: diameter, height: height});
+
+        // Create the TankFireCalculation object
+        const tankFireCalculation = new TankFireCalculation(tank, weather, substrate, flammableParameters);
+
+        // Run the calculation
+        console.log("Running the calculation...");
+        const resultCode = await tankFireCalculation.run();
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        // Print any messages
+        if (tankFireCalculation.messages.length > 0) {
+            console.log('Messages:');
+            tankFireCalculation.messages.forEach(message => console.log(message));
+        }
+
+        // Validate results
+        
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.surfaceEmissivePower! - 126425.34375) / 126425.34375)).toBeLessThan(1e-3);
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.flameLength! - 3.9397664070129395) / 3.9397664070129395)).toBeLessThan(1e-3);
+        console.log(`SUCCESS: tank_fire_calculation (${tankFireCalculation.calculationElapsedTime}ms)`);
+
+    });
+});

package/tests/tank-fire-calculation/testCase80.test.ts

@@ -0,0 +1,67 @@
+import { TankFireCalculation } from "../../src/calculations/standalones";
+import { Material, MaterialComponent, FlammableParameters, AtmosphericStorageTank, State, Weather, Substrate } from "../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, PoolFireType } 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('TankFireCalculation', () => {
+    test('should calculate fire properties correctly', async () => {
+        // Set the case properties.
+        const materialName = "N-PENTANE";
+        const diameter = 0.5;
+        const height = 2.0;
+        const windSpeed = 2.0;
+        const fireType = PoolFireType.LATE;
+        const weatherStability = AtmosphericStabilityClass.STABILITY_E;
+
+        // Define the initial state of the tank.
+        const state = new State({temperature: 260.0, pressure: 101325, liquidFraction: 0.0});
+
+        // Define the material contained by the tank.
+        const material = new Material({
+            name: materialName,
+            components: [new MaterialComponent({name: materialName, moleFraction: 1.0})]
+        });
+
+        // Define the weather conditions
+        const weather = new Weather({windSpeed: windSpeed, stabilityClass: weatherStability});
+
+        // Define the substrate
+        const substrate = new Substrate();
+
+        // Define the flammable parameters
+        const flammableParameters = new FlammableParameters({poolFireType: fireType});
+
+        // Define the conditions of the tank
+        const tank = new AtmosphericStorageTank({state: state, material: material, diameter: diameter, height: height});
+
+        // Create the TankFireCalculation object
+        const tankFireCalculation = new TankFireCalculation(tank, weather, substrate, flammableParameters);
+
+        // Run the calculation
+        console.log("Running the calculation...");
+        const resultCode = await tankFireCalculation.run();
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        // Print any messages
+        if (tankFireCalculation.messages.length > 0) {
+            console.log('Messages:');
+            tankFireCalculation.messages.forEach(message => console.log(message));
+        }
+
+        // Check surface emissive power
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.surfaceEmissivePower! - 133009.03125) / 133009.03125)).toBeLessThan(1e-3);
+
+        // Check flame length
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.flameLength! - 2.8789072036743164) / 2.8789072036743164)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: tank_fire_calculation (${tankFireCalculation.calculationElapsedTime}ms)`);
+
+    });
+});

package/tests/tank-fire-calculation/testCase81.test.ts

@@ -0,0 +1,68 @@
+import { TankFireCalculation } from "../../src/calculations/standalones";
+import { Material, MaterialComponent, FlammableParameters, AtmosphericStorageTank, State, Weather, Substrate } from "../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, PoolFireType } 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('TankFireCalculation', () => {
+    test('should calculate fire properties correctly for N-OCTANE', async () => {
+        // Set the case properties.
+        const materialName = "N-OCTANE";
+        const diameter = 2.0;
+        const height = 5.0;
+        const windSpeed = 5.0;
+        const fireType = PoolFireType.LATE;
+        const weatherStability = AtmosphericStabilityClass.STABILITY_D;
+
+        // Define the initial state of the tank.
+        const state = new State({temperature: 280.0, pressure: 1.0E+06, liquidFraction: 0.0});
+
+        // Define the material contained by the tank.
+        const material = new Material({
+            name: materialName,
+            components: [new MaterialComponent({name: materialName, moleFraction: 1.0})]
+        });
+
+        // Define the weather conditions
+        const weather = new Weather({windSpeed: windSpeed, stabilityClass: weatherStability});
+
+        // Define the substrate
+        const substrate = new Substrate();
+
+        // Define the flammable parameters
+        const flammableParameters = new FlammableParameters({poolFireType: fireType});
+
+        // Define the conditions of the tank
+        const tank = new AtmosphericStorageTank({state: state, material: material, diameter: diameter, height: height});
+
+        // Create the TankFireCalculation object
+        const tankFireCalculation = new TankFireCalculation(tank, weather, substrate, flammableParameters);
+
+        // Run the calculation
+        console.log("Running the calculation...");
+        const resultCode = await tankFireCalculation.run();
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        // Print any messages
+        if (tankFireCalculation.messages.length > 0) {
+            console.log('Messages:');
+            tankFireCalculation.messages.forEach(message => console.log(message));
+        }
+
+        // Validate results
+
+        // Check surface emissive power
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.surfaceEmissivePower! - 114386.2734375) / 114386.2734375)).toBeLessThan(1e-3);
+
+        // Check flame length
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.flameLength! - 5.776425838470459) / 5.776425838470459)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: tank_fire_calculation (${tankFireCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/tank-fire-calculation/testCase82.test.ts

@@ -0,0 +1,68 @@
+import { TankFireCalculation } from "../../src/calculations/standalones";
+import { Material, MaterialComponent, FlammableParameters, AtmosphericStorageTank, State, Weather, Substrate } from "../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, PoolFireType } 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('TankFireCalculation', () => {
+    test('should calculate fire properties correctly for N-DECANE', async () => {
+        // Set the case properties.
+        const materialName = "N-DECANE";
+        const diameter = 2.0;
+        const height = 4.0;
+        const windSpeed = 10.0;
+        const fireType = PoolFireType.LATE;
+        const weatherStability = AtmosphericStabilityClass.STABILITY_A_;
+
+        // Define the initial state of the tank.
+        const state = new State({temperature: 300.0, pressure: 1.0E+06, liquidFraction: 0.0});
+
+        // Define the material contained by the tank.
+        const material = new Material({
+            name: materialName,
+            components: [new MaterialComponent({name: materialName, moleFraction: 1.0})]
+        });
+
+        // Define the weather conditions
+        const weather = new Weather({windSpeed: windSpeed, stabilityClass: weatherStability});
+
+        // Define the substrate
+        const substrate = new Substrate();
+
+        // Define the flammable parameters
+        const flammableParameters = new FlammableParameters({poolFireType: fireType});
+
+        // Define the conditions of the tank
+        const tank = new AtmosphericStorageTank({state: state, material: material, diameter: diameter, height: height});
+
+        // Create the TankFireCalculation object
+        const tankFireCalculation = new TankFireCalculation(tank, weather, substrate, flammableParameters);
+
+        // Run the calculation
+        console.log("Running the calculation...");
+        const resultCode = await tankFireCalculation.run();
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+        // Print any messages
+        if (tankFireCalculation.messages.length > 0) {
+            console.log('Messages:');
+            tankFireCalculation.messages.forEach(message => console.log(message));
+        }
+
+        // Validate results
+  
+        // Check surface emissive power
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.surfaceEmissivePower! - 114386.2734375) / 114386.2734375)).toBeLessThan(1e-3);
+
+        // Check flame length
+        expect(Math.abs((tankFireCalculation.poolFireFlameResult!.flameLength! - 5.283842086791992) / 5.283842086791992)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: tank_fire_calculation (${tankFireCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/tank-fire-calculation/testCase83.test.ts

@@ -0,0 +1,73 @@
+import { TankFireCalculation } from "../../src/calculations/standalones";
+import { Material, MaterialComponent, FlammableParameters, AtmosphericStorageTank, State, Weather, Substrate } from "../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, PoolFireType } 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('TankFireCalculation', () => {
+    test('should calculate fire properties correctly for N-HEPTANE_N-OCTANE mixture', async () => {
+        // Set the case properties.
+        const materialName = "N-HEPTANE_N-OCTANE";
+        const diameter = 3.0;
+        const height = 10.0;
+        const windSpeed = 1.0;
+        const fireType = PoolFireType.LATE;
+        const weatherStability = AtmosphericStabilityClass.STABILITY_C;
+
+        // Define the initial state of the tank.
+        const state = new State({ temperature: 290.0, pressure: 1.0E+06, liquidFraction: 0.0 });
+
+        // Define the material contained by the tank (binary mixture)
+        const material = new Material({
+            name: materialName,
+            components: [
+                new MaterialComponent({ name: "N-HEPTANE", moleFraction: 0.4 }),
+                new MaterialComponent({ name: "N-OCTANE", moleFraction: 0.6 }),
+            ],
+            componentCount: 2,
+        });
+
+        // Define the weather conditions
+        const weather = new Weather({ windSpeed: windSpeed, stabilityClass: weatherStability });
+
+        // Define the substrate
+        const substrate = new Substrate();
+
+        // Define the flammable parameters
+        const flammableParameters = new FlammableParameters({ poolFireType: fireType });
+
+        // Define the conditions of the tank
+        const tank = new AtmosphericStorageTank({ state, material, diameter, height });
+
+        // Create the TankFireCalculation object
+        const tankFireCalculation = new TankFireCalculation(tank, weather, substrate, flammableParameters);
+
+        // Run the calculation
+        console.log("Running the calculation...");
+        const resultCode = await tankFireCalculation.run();
+
+        // Print any messages
+        if (tankFireCalculation.messages.length > 0) {
+            console.log("Messages:");
+            tankFireCalculation.messages.forEach(msg => console.log(msg));
+        }
+
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+
+
+        const surfaceEmissivePower = tankFireCalculation.poolFireFlameResult!.surfaceEmissivePower!;
+        const flameLength = tankFireCalculation.poolFireFlameResult!.flameLength!;
+
+        expect(Math.abs((surfaceEmissivePower - 103709.09375) / 103709.09375)).toBeLessThan(1e-3);
+        expect(Math.abs((flameLength - 8.156496047973633) / 8.156496047973633)).toBeLessThan(1e-3);
+
+        console.log(`SUCCESS: tank_fire_calculation (${tankFireCalculation.calculationElapsedTime}ms)`);
+
+    });
+});

package/tests/utilities/convert-camel-case-to-snake-case.test.ts

@@ -0,0 +1,7 @@
+import { convertCamelCaseToSnakeCase } from '../../src/utilities';
+
+describe('convertCamelCaseToSnakeCase', () => {
+    test('should convert camelCase to snake_case', () => {
+        expect(convertCamelCaseToSnakeCase('convertToSnakeCase')).toBe('convert_to_snake_case');
+    });
+});

package/tests/utilities/convert-snake-case-to-camel-case.test.ts

@@ -0,0 +1,7 @@
+import { convertSnakeCaseToCamelCase } from '../../src/utilities';
+
+describe('convertSnakeCaseToCamelCase', () => {
+    test('should convert snake_case to camelCase', () => {
+        expect(convertSnakeCaseToCamelCase('convert_to_camel_case')).toBe('convertToCamelCase');
+    });
+});