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

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

@@ -0,0 +1,176 @@
+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 Test Case 45", () => {
+  test("should produce correct radiation results for pool fire", async () => {
+    // Define the test case properties
+    const materialName = 'TOLUENE';
+    const stateTemperature = 280.0;
+    const statePressure = 1.50e5;
+    const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+    const vesselLength = 5.0;
+    const vesselDiameter = 2.0;
+    const leakHoleDiameter = 0.05;
+    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: materialName,
+      components: [
+        new MaterialComponent({ name: materialName, moleFraction: 1.0 }),
+      ],
+      componentCount: 1,
+    });
+
+    // 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,
+      length: vesselLength,
+      shape: vesselShape,
+      liquidFillFractionByVolume: 0.5,
+    });
+
+    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: 1.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_C,
+      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 = [
+      { 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 })
+      });
+    });
+
+    // 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 - 63.6457305261025) / 63.6457305261025
+      )
+    ).toBeLessThan(1e-3);
+    expect(
+      Math.abs((radiationCalc.poolFireFlameResult.flameDiameter! - 49.78919982910156) /49.78919982910156)).toBeLessThan(1e-3);
+    });
+});

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

@@ -0,0 +1,182 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { PoolFireCalculation } from "../../src/calculations/poolFire";
+import { DistancesAndEllipsesToRadiationLevelsForPoolFiresCalculation, 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 - Test Case 45a", () => {
+  test("should produce correct radiation results for pool fire", async () => {
+    // Set the case properties.
+    const materialName = 'TOLUENE';
+    const stateTemperature = 280.0;
+    const statePressure = 1.50e5;
+    const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+    const vesselLength = 5.0;
+    const vesselDiameter = 2.0;
+    const leakHoleDiameter = 0.05;
+    const timeVaryingOption = TimeVaryingOption.TIME_VARYING_RATE;
+    const leakHoleHeightFraction = 0.0;
+    const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE
+
+    // Define the initial state of the vessel.
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: 0.0,
+    });
+
+    // Define the material contained by the vessel.
+    const material = new Material({
+      name: materialName,
+      components: [
+        new MaterialComponent({ name: materialName, moleFraction: 1.0 })
+      ],
+      componentCount: 1,
+    });
+
+    // Create a vessel state calculation using the material and state.
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    let resultCode = await vesselStateCalc.run();
+
+    // Print any messages.
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create a vessel to use in the leak calculation using the previously defined entities.
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      diameter: vesselDiameter,
+      length: vesselLength,
+      shape: vesselShape,
+      liquidFillFractionByVolume: 0.5,
+    });
+
+    // Create a leak to use in the vessel leak calculation.
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Create discharge parameters to use in the vessel leak calculation taking all the default values.
+    const dischargeParams = new DischargeParameters();
+
+    // Create a vessel leak calculation using the vessel, leak, and discharge parameters.
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+    resultCode = await vesselLeakCalc.run();
+
+    // Print any messages.
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Define the weather.
+    const weather = new Weather({
+      windSpeed: 1.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_C,
+      windProfileFlag: windProfileFlag,
+    });
+
+    // Define the substrate.
+    const substrate = new Substrate();
+
+    // Create a dispersion calculation based on the vessel leak calculation, weather, substrate, and dispersion parameters.
+    const dispersionCalc = new DispersionCalculation(
+      vesselLeakCalc.exitMaterial!,
+      substrate,
+      vesselLeakCalc.dischargeResult!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      weather,
+      new DispersionParameters(),
+      0.0,
+    );
+
+    resultCode = await dispersionCalc.run();
+
+    // Print any messages.
+    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,
+    });
+
+    // Create a pool fire calculation based on the dispersion calculation, weather, substrate, and flammable parameters.
+    const poolFireCalc = new PoolFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      dispersionCalc.poolRecords!,
+      dispersionCalc.poolRecords!.length,
+      weather,
+      substrate,
+      flammableParams
+    );
+    resultCode = await poolFireCalc.run();
+
+    // Print any messages.
+    if (poolFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      poolFireCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Define a flammable output config.
+    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 })
+      });
+    });
+
+    // Create a radiation points calculation based on the pool fire calculation, weather, substrate, and flammable output config.
+    const radiationCalc = new RadiationAtPointsForPoolFiresCalculation(
+      poolFireCalc.poolFireFlameResult!,
+      poolFireCalc.flameRecords!,
+      poolFireCalc.flameRecords!.length,
+      weather,
+      flammableParams,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+    resultCode = await radiationCalc.run();
+
+    // Print any messages.
+    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(Math.abs((radiationCalc.radiation![0] - 139644.9375) / 139644.9375)).toBeLessThan(1e-3);
+    expect(Math.abs((radiationCalc.poolFireFlameResult.flameDiameter! - 49.78919982910156) / 49.78919982910156)).toBeLessThan(1e-3);
+  });
+});

package/tests/radiation-at-ponts/testCase69.test.ts

@@ -0,0 +1,167 @@
+import { VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { RadiationAtPointsCalculation } from "../../src/calculations/radiation";
+import { State, Material, MaterialComponent, Vessel, Leak, DischargeParameters, Weather, Substrate, FlammableParameters, FlammableOutputConfig, Transect, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, Resolution, 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("RadiationAtPointsCalculation Integration - Test Case 69", () => {
+  test("should produce correct radiation results for METHANE", async () => {
+    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 liquidFillFraction = 0.0;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 3600.0;
+    const radiationResolution = Resolution.MEDIUM;
+    const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+
+    // Define the initial state of the vessel
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: 0.0,
+    });
+
+    // Define the material contained by the vessel
+    const material = new Material({
+      name: materialName,
+      components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })],
+    });
+
+    // Create a vessel state calculation using the material and state
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    let resultCode = await vesselStateCalc.run();
+
+    // Check if there are any messages
+    if (vesselStateCalc.messages.length > 0) {
+      vesselStateCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the vessel state calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create a vessel to use in the leak calculation using the previously defined entities
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition(),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFraction,
+    });
+
+    // Create a leak to use in the vessel leak calculation
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Create discharge parameters for the vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+
+    // Create a vessel leak calculation using the vessel, leak, and discharge parameters
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+    resultCode = await vesselLeakCalc.run();
+
+    // Check if there are any messages
+    if (vesselLeakCalc.messages.length > 0) {
+      vesselLeakCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the vessel leak calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Instantiate the data required by the jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+      windProfileFlag: windProfileFlag,
+    });
+
+    const substrate = new Substrate();
+    const flammableParams = new FlammableParameters({ timeOfInterest });
+
+    // Create a jet fire calculation using the required input data
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+    resultCode = await jetFireCalc.run();
+
+    // Check if there are any messages
+    if (jetFireCalc.messages.length > 0) {
+      jetFireCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the jet fire calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create flammable output configurations
+    const flammableOutputConfigs = [
+      { x: 10.0, y: 0.0, z: 0.0 },
+      { x: 15.0, y: 0.0, z: 1.0 },
+      { x: 20.0, y: 0.0, z: 2.0 },
+    ].map(({ x, y, z }) => {
+      return new FlammableOutputConfig({
+        position: new LocalPosition({ x, y, z }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition(),
+          transectEndPoint: new LocalPosition(),
+        }),
+        radiationResolution: radiationResolution,
+      });
+    });
+    
+    // Create a radiation at points calculation using the flame result, flame records, weather, flammable parameters, and flammable output configurations
+    const radiationAtPointsCalc = new RadiationAtPointsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    // Run the radiation at points calculation
+    resultCode = await radiationAtPointsCalc.run();
+
+    // Check if there are any messages
+    if (radiationAtPointsCalc.messages.length > 0) {
+      radiationAtPointsCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the radiation at points calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const radiationResult = radiationAtPointsCalc.radiation![0];
+    const expectedRadiation = 24404.931814667765;
+    const radiationTolerance = 1e-3;
+    expect(Math.abs((radiationResult - expectedRadiation) / expectedRadiation)).toBeLessThan(radiationTolerance);
+
+    const flameLength = radiationAtPointsCalc.flameResult.flameLength!;
+    const expectedFlameLength = 33.750426875730376;
+    expect(Math.abs((flameLength - expectedFlameLength) / expectedFlameLength)).toBeLessThan(radiationTolerance);
+  });
+});