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

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

@@ -0,0 +1,161 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import { DischargeParameters, DispersionParameters, FlammableOutputConfig, FlammableParameters, LineRupture, LocalPosition, Material, MaterialComponent, State, Substrate, Vessel, Weather} 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 Line Rupture Calculation Integration - Test Case 43", () => {
+  test("should produce correct radiation results for pool fire after line rupture", async () => {
+    const state = new State({
+      temperature: 280.0,
+      pressure: 1.5e5,
+      liquidFraction: 1.0,
+    });
+
+    const material = new Material({
+      name: "N-DECANE",
+      components: [new MaterialComponent({ name: "N-DECANE", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    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);
+
+    const vessel = new Vessel({
+      state,
+      material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      liquidFillFractionByVolume: 0.7,
+      shape: VesselShape.VERTICAL_CYLINDER,
+      height: 3.0,
+      diameter: 1.5
+    });
+
+    const lineRupture = new LineRupture({
+      pipeDiameter: 0.02,
+      pipeLength: 10.0,
+      pipeHeightFraction: 0.0,
+    });
+
+    const lineRuptureCalc = new VesselLineRuptureCalculation(
+      vessel,
+      lineRupture,
+      new DischargeParameters()
+    );
+    resultCode = await lineRuptureCalc.run();
+
+    if (lineRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      lineRuptureCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const substrate = new Substrate();
+
+    const dispersionCalc = new DispersionCalculation(
+      lineRuptureCalc.exitMaterial!,
+      substrate,
+      lineRuptureCalc.dischargeResult!,
+      lineRuptureCalc.dischargeRecords!,
+      lineRuptureCalc.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);
+
+    const flammableParams = new FlammableParameters({
+      poolFireType: PoolFireType.LATE,
+    });
+
+    const poolFireCalc = new PoolFireCalculation(
+      lineRuptureCalc.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);
+
+    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((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    expect(radiationCalc.contourPoints!.length).toBe(150);
+    expect(
+      Math.abs(
+        (radiationCalc.contourPoints![radiationCalc.contourPoints!.length - 1].x -
+          49.262370814360395) / 49.262370814360395
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (radiationCalc.poolFireFlameResult!.flameDiameter! -
+          30.674606323242188) / 30.674606323242188
+      )
+    ).toBeLessThan(1e-3);
+  });
+});

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

@@ -0,0 +1,157 @@
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { RadiationAtPointsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import { VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { Bund, DischargeParameters, DispersionParameters, FlammableOutputConfig, FlammableParameters, LineRupture, LocalPosition, Material, MaterialComponent, State, Substrate, Vessel, Weather } from "../../src/entities";
+import { AtmosphericStabilityClass, PoolFireType, ResultCode, TimeVaryingOption, VesselShape, WindProfileFlag } from "../../src/enums";
+import { VesselStateCalculation } from "../../src/calculations/discharge";
+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 Line Rupture Calculation Integration - Test Case 43a", () => {
+  test("should compute correct radiation and flame diameter for a line rupture scenario", async () => {
+    const state = new State({
+      temperature: 280.0,
+      pressure: 1.5e5,
+      liquidFraction: 1.0,
+    });
+
+    const material = new Material({
+      name: "N-DECANE",
+      components: [new MaterialComponent({ name: "N-DECANE", moleFraction: 1.0 })],
+      componentCount: 1,
+    });
+
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    let resultCode = await vesselStateCalc.run();
+
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      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.VERTICAL_CYLINDER,
+      height: 3.0,
+      diameter: 1.5,
+    });
+
+    const lineRupture = new LineRupture({
+      pipeDiameter: 0.02,
+      pipeLength: 10.0,
+      pipeHeightFraction: 0.0,
+    });
+
+    const ruptureCalc = new VesselLineRuptureCalculation(
+      vessel,
+      lineRupture,
+      new DischargeParameters()
+    );
+    resultCode = await ruptureCalc.run();
+
+    if (ruptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      ruptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    expect(ruptureCalc.dischargeResult?.releaseMass).toBeGreaterThan(0);
+
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_D,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const substrate = new Substrate();
+
+    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 = [
+      { 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((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const expectedRadiation = 136477.34375;
+    const expectedFlameDiameter = 30.674606323242188;
+
+    const actualRadiation = radiationCalc.radiation![0];
+    const actualFlameDiameter = radiationCalc.poolFireFlameResult.flameDiameter!;
+
+    expect(Math.abs((actualRadiation - expectedRadiation) / expectedRadiation)).toBeLessThan(1e-3);
+    expect(Math.abs((actualFlameDiameter - expectedFlameDiameter) / expectedFlameDiameter)).toBeLessThan(1e-3);
+  });
+});

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

@@ -0,0 +1,147 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import { DischargeParameters, DispersionParameters, FlammableOutputConfig, FlammableParameters, LineRupture, LocalPosition, Material, MaterialComponent, State, Substrate, Vessel, Weather} 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 44", () => {
+    test("should correctly simulate ammonia rupture and fire radiation", async () => {
+      const material = new Material({
+        name: "AMMONIA",
+        components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.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((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+        liquidFillFractionByVolume: 0.8,
+      });
+  
+      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((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const weather = new Weather({
+        windSpeed: 10.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+      });
+  
+      const substrate = new Substrate();
+  
+      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((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableParams = new FlammableParameters({
+        poolFireType: PoolFireType.EARLY,
+      });
+  
+      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((message) => console.log(message));
+      }
+  
+      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((message) => console.log(message));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      expect(radiationCalc.contourPoints!.length).toBe(150);
+  
+      const lastPointX = radiationCalc.contourPoints![radiationCalc.contourPoints!.length - 1].x;
+      expect(Math.abs((lastPointX - 57.950279071403216) / 57.950279071403216)).toBeLessThan(1e-3);
+  
+      const flameDiameter = radiationCalc.poolFireFlameResult!.flameDiameter!;
+      expect(Math.abs((flameDiameter - 41.44367599487305) / 41.44367599487305)).toBeLessThan(1e-3);
+    });
+  });
+  

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

@@ -0,0 +1,152 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import {  RadiationAtPointsForPoolFiresCalculation } from "../../src/calculations/radiation";
+import { DischargeParameters, DispersionParameters, FlammableOutputConfig, FlammableParameters, LineRupture, LocalPosition, Material, MaterialComponent, State, Substrate, Vessel, Weather} 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 44a", () => {
+    test("should produce correct radiation and flame diameter for ammonia pool fire", async () => {
+      const material = new Material({
+        name: "AMMONIA",
+        components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.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,
+        material,
+        vesselConditions: vesselStateCalc.vesselConditions,
+        liquidFillFractionByVolume: 0.8
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+  
+      const ruptureCalc = new VesselCatastrophicRuptureCalculation(
+        vessel,
+        dischargeParameters
+      );
+      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: 10.0,
+        stabilityClass: AtmosphericStabilityClass.STABILITY_A_,
+        windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+      });
+  
+      const substrate = new Substrate();
+  
+      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((m) => console.log(m));
+      }
+  
+      expect(resultCode).toBe(ResultCode.SUCCESS);
+  
+      const flammableParams = new FlammableParameters({
+        poolFireType: PoolFireType.EARLY,
+      });
+  
+      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 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);
+  
+      const expectedRadiation = 33916.10546875;
+      const expectedFlameDiameter = 41.44367599487305;
+      const actualRadiation = radiationCalc.radiation![0];
+      const actualFlameDiameter = radiationCalc.poolFireFlameResult.flameDiameter!;
+  
+      expect(
+        Math.abs((actualRadiation - expectedRadiation) / expectedRadiation)
+      ).toBeLessThan(1e-3);
+  
+      expect(
+        Math.abs((actualFlameDiameter - expectedFlameDiameter) / expectedFlameDiameter)
+      ).toBeLessThan(1e-3);
+    });
+  });
+