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

package/tests/jet-fire-calculation/testCase37.test.ts

@@ -0,0 +1,148 @@
+import { Material, MaterialComponent, State, Leak, Vessel, FlammableParameters, Weather, Substrate, DischargeParameters } from "../../src/entities";
+import { VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { ResultCode, AtmosphericStabilityClass, VesselShape, TimeVaryingOption } 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("Integrated Jet Fire Scenario - Test Case 37", () => {
+  test("should run the full jet fire scenario and perform regression check", async () => {
+    // Set the case properties
+    const materialName = "N-BUTANE";
+    const stateTemperature = 300.0;
+    const statePressure = 3.0e5;
+    const vesselShape = VesselShape.VESSEL_CUBOID;
+    const vesselHeight = 2.0;
+    const vesselWidth = 1.0;
+    const vesselLength = 3.0;
+    const leakHoleDiameter = 0.05;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.2;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const surfaceRoughness = 0.18;
+    const timeOfInterest = 20.0;
+    const liquidFillFractionByVolume = 0.5;
+
+    // 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 and run vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vesselStateCalculation...");
+    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);
+    console.log(`SUCCESS: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Create vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      length: vesselLength,
+      width: vesselWidth,
+      height: vesselHeight,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume
+    });
+
+    // Create leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption
+    });
+
+    // Create and run vessel leak calculation
+    const vesselLeakCalc = new VesselLeakCalculation(
+      vessel,
+      leak,
+      new DischargeParameters()
+    );
+    
+    console.log("Running vesselLeakCalculation...");
+    resultCode = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vesselLeakCalculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Define weather and substrate
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass
+    });
+
+    const substrate = new Substrate({
+      surfaceRoughness: surfaceRoughness
+    });
+
+    // Create and run jet fire calculation
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+      jetFireAutoSelect: false,
+      timeAveraging: true
+    });
+
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jetFireCalculation...");
+    resultCode = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameLengthError = Math.abs(
+      (jetFireCalc.flameResult!.flameLength! - 52.735663839470966) / 52.735663839470966
+    );
+    const surfaceEmissivePowerError = Math.abs(
+      (jetFireCalc.flameResult!.surfaceEmissivePower! - 199020.3679914611) / 199020.3679914611
+    );
+
+    expect(flameLengthError).toBeLessThan(1e-3);
+    expect(surfaceEmissivePowerError).toBeLessThan(1e-3);
+    expect(jetFireCalc.flameRecords!.length).toBe(2);
+
+    console.log(`SUCCESS: jetFireCalculation (${jetFireCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/jet-fire-calculation/testCase38.test.ts

@@ -0,0 +1,147 @@
+import { Material, MaterialComponent, State, Vessel, LineRupture, FlammableParameters, Weather, Substrate, DischargeParameters } from "../../src/entities";
+import { VesselStateCalculation, VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { ResultCode, AtmosphericStabilityClass, VesselShape } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("Integrated Jet Fire Scenario - Test Case 38", () => {
+  test("should run the full jet fire scenario with line rupture and perform regression check", async () => {
+    // Set the case properties
+    const materialName = "PROPANE";
+    const stateTemperature = 250.0;
+    const statePressure = 3.0e5;
+    const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+    const vesselDiameter = 2.0;
+    const liquidFillFractionByVolume = 0.7;
+    const pipeDiameter = 0.1;
+    const pipeLength = 5.0;
+    const pipeHeightFraction = 0.3;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const surfaceRoughness = 0.18;
+    const timeOfInterest = 120.0;
+    const jetFireAutoSelect = false;
+    const timeAveraging = false;
+
+    // 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 and run vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vesselStateCalculation...");
+    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);
+    console.log(`SUCCESS: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Create vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      diameter: vesselDiameter,
+      length: 5.0,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume
+    });
+
+    // Create line rupture
+    const lineRupture = new LineRupture({
+      pipeDiameter: pipeDiameter,
+      pipeLength: pipeLength,
+      pipeHeightFraction: pipeHeightFraction
+    });
+
+    // Create and run vessel line rupture calculation
+    const vesselLineRuptureCalc = new VesselLineRuptureCalculation(
+      vessel,
+      lineRupture,
+      new DischargeParameters()
+    );
+    
+    console.log("Running vesselLineRuptureCalculation...");
+    resultCode = await vesselLineRuptureCalc.run();
+
+    if (vesselLineRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLineRuptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vesselLineRuptureCalculation (${vesselLineRuptureCalc.calculationElapsedTime}ms)`);
+
+    // Define weather and substrate
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass
+    });
+
+    const substrate = new Substrate({
+      surfaceRoughness: surfaceRoughness
+    });
+
+    // Create and run jet fire calculation
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+      jetFireAutoSelect: jetFireAutoSelect,
+      timeAveraging: timeAveraging
+    });
+
+    const jetFireCalc = new JetFireCalculation(
+      vesselLineRuptureCalc.exitMaterial!,
+      vesselLineRuptureCalc.dischargeRecords!,
+      vesselLineRuptureCalc.dischargeRecords!.length,
+      vesselLineRuptureCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jetFireCalculation...");
+    resultCode = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameLengthError = Math.abs(
+      (jetFireCalc.flameResult!.flameLength! - 98.19868637938056) / 98.19868637938056
+    );
+    const surfaceEmissivePowerError = Math.abs(
+      (jetFireCalc.flameResult!.surfaceEmissivePower! - 175803.22174161073) / 175803.22174161073
+    );
+
+    expect(flameLengthError).toBeLessThan(1e-3);
+    expect(surfaceEmissivePowerError).toBeLessThan(1e-3);
+    expect(jetFireCalc.flameRecords!.length).toBe(2);
+
+    console.log(`SUCCESS: jetFireCalculation (${jetFireCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/jet-fire-calculation/testCase39.test.ts

@@ -0,0 +1,146 @@
+import { Material, MaterialComponent, State, Leak, Vessel, FlammableParameters, Weather, Substrate, DischargeParameters } from "../../src/entities";
+import { VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { ResultCode, AtmosphericStabilityClass, VesselShape, TimeVaryingOption } 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("Integrated Jet Fire Scenario - Test Case 39", () => {
+  test("should run the full jet fire scenario and perform regression check", async () => {
+    // Set the case properties
+    const materialName = "METHANE";
+    const stateTemperature = 280.0;
+    const statePressure = 1.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.5;
+    const liquidFillFractionByVolume = 0.0;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const surfaceRoughness = 0.18;
+    const timeOfInterest = 3600.0;
+    const jetFireAutoSelect = false;
+    const timeAveraging = true;
+
+    // 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 and run vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vesselStateCalculation...");
+    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);
+    console.log(`SUCCESS: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Create vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume
+    });
+
+    // Create leak
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption
+    });
+
+    // Create and run vessel leak calculation
+    const vesselLeakCalc = new VesselLeakCalculation(
+      vessel,
+      leak,
+      new DischargeParameters()
+    );
+    
+    console.log("Running vesselLeakCalculation...");
+    resultCode = await vesselLeakCalc.run();
+
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vesselLeakCalculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Define weather and substrate
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass
+    });
+
+    const substrate = new Substrate({
+      surfaceRoughness: surfaceRoughness
+    });
+
+    // Create and run jet fire calculation
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+      jetFireAutoSelect: jetFireAutoSelect,
+      timeAveraging: timeAveraging
+    });
+
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jetFireCalculation...");
+    resultCode = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameLengthError = Math.abs(
+      (jetFireCalc.flameResult!.flameLength! - 33.750426875730376) / 33.750426875730376
+    );
+    const surfaceEmissivePowerError = Math.abs(
+      (jetFireCalc.flameResult!.surfaceEmissivePower! - 309079.19061404973) / 309079.19061404973
+    );
+
+    expect(flameLengthError).toBeLessThan(1e-3);
+    expect(surfaceEmissivePowerError).toBeLessThan(1e-3);
+    expect(jetFireCalc.flameRecords!.length).toBe(2);
+
+    console.log(`SUCCESS: jetFireCalculation (${jetFireCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/jet-fire-calculation/testCase40.test.ts

@@ -0,0 +1,152 @@
+import { Material, MaterialComponent, State, Vessel, LineRupture, Weather, Substrate, DischargeParameters, FlammableParameters } from "../../src/entities";
+import { VesselStateCalculation, VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { ResultCode, AtmosphericStabilityClass, VesselShape } from "../../src/enums";
+import { setAccessToken } from "../../src/utilities";
+const accessToken = process.env.PWS_ACCESS_TOKEN;
+
+if (!accessToken) {
+  throw new Error("ACCESS_TOKEN environment variable is not set.");
+}
+
+setAccessToken(accessToken);
+
+describe("Integrated Jet Fire Scenario - Test Case 40", () => {
+  test("should run the full jet fire scenario with line rupture and perform regression check", async () => {
+    // Set the case properties
+    const materialName = "ETHANE_METHANE_HYDROGEN";
+    const stateTemperature = 260.0;
+    const statePressure = 5.0e5;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const liquidFillFractionByVolume = 0.7;
+    const pipeDiameter = 0.5;
+    const pipeLength = 1.0;
+    const pipeHeightFraction = 0.5;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const surfaceRoughness = 0.18;
+    const timeOfInterest = 600.0;
+    const jetFireAutoSelect = false;
+    const timeAveraging = true;
+
+    // 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: "METHANE", moleFraction: 0.5 }),
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.3 }),
+        new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.2 })
+      ],
+       componentCount: 3
+    });
+
+    // Create and run vessel state calculation
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    
+    console.log("Running vesselStateCalculation...");
+    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);
+    console.log(`SUCCESS: vesselStateCalculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Create vessel
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      diameter: vesselDiameter,
+      length: 5.0,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFractionByVolume
+    });
+
+    // Create line rupture
+    const lineRupture = new LineRupture({
+      pipeDiameter: pipeDiameter,
+      pipeLength: pipeLength,
+      pipeHeightFraction: pipeHeightFraction
+    });
+
+    // Create and run vessel line rupture calculation
+    const vesselLineRuptureCalc = new VesselLineRuptureCalculation(
+      vessel,
+      lineRupture,
+      new DischargeParameters()
+    );
+    
+    console.log("Running vesselLineRuptureCalculation...");
+    resultCode = await vesselLineRuptureCalc.run();
+
+    if (vesselLineRuptureCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLineRuptureCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vesselLineRuptureCalculation (${vesselLineRuptureCalc.calculationElapsedTime}ms)`);
+
+    // Define weather and substrate
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass
+    });
+
+    const substrate = new Substrate({
+      surfaceRoughness: surfaceRoughness
+    });
+
+    // Create and run jet fire calculation
+    const flammableParams = new FlammableParameters({
+      timeOfInterest: timeOfInterest,
+      jetFireAutoSelect: jetFireAutoSelect,
+      timeAveraging: timeAveraging
+    });
+
+    const jetFireCalc = new JetFireCalculation(
+      vesselLineRuptureCalc.exitMaterial!,
+      vesselLineRuptureCalc.dischargeRecords!,
+      vesselLineRuptureCalc.dischargeRecords!.length,
+      vesselLineRuptureCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+
+    console.log("Running jetFireCalculation...");
+    resultCode = await jetFireCalc.run();
+
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const flameLengthError = Math.abs(
+      (jetFireCalc.flameResult!.flameLength! - 96.77758243403922) / 96.77758243403922
+    );
+    const surfaceEmissivePowerError = Math.abs(
+      (jetFireCalc.flameResult!.surfaceEmissivePower! - 350000.0) / 350000.0
+    );
+
+    expect(flameLengthError).toBeLessThan(1e-3);
+    expect(surfaceEmissivePowerError).toBeLessThan(1e-3);
+    expect(jetFireCalc.flameRecords!.length).toBe(2);
+
+    console.log(`SUCCESS: jetFireCalculation (${jetFireCalc.calculationElapsedTime}ms)`);
+  });
+});