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

package/tests/flash-calculation/testCase27.test.ts

@@ -0,0 +1,69 @@
+import { Material, MaterialComponent, State } from "../../src/entities";
+import { FlashCalculation } from "../../src/calculations/properties";
+import { ResultCode } 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("Flash Calculation Scenario - Test Case 27", () => {
+  test("should run the flash calculation and perform regression check", async () => {
+    // Set the case properties
+    const stateTemperature = 270.0;
+    const statePressure = 1.5e5;
+    const stateLiquidFraction = 0.7;
+
+    // Define the initial state of the vessel
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: stateLiquidFraction
+    });
+
+    // Define the material (AMMONIA+TRIMETHYLAMINE+WATER)
+    const material = new Material({
+      name: "Case27_Material",
+      components: [
+        new MaterialComponent({ name: "AMMONIA", moleFraction: 0.333 }),
+        new MaterialComponent({ name: "TRIMETHYLAMINE", moleFraction: 0.333 }),
+        new MaterialComponent({ name: "WATER", moleFraction: 0.334 })
+      ],
+      componentCount: 3
+    });
+
+    // Create and run flash calculation
+    const flashCalc = new FlashCalculation(material, state);
+
+    console.log("Running flashCalculation...");
+    const resultCode = await flashCalc.run();
+
+    if (flashCalc.messages.length > 0) {
+      console.log("Messages:");
+      flashCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const totalFluidDensityError = Math.abs(
+      (flashCalc.flashResult!.totalFluidDensity! - 96.46994608249469) / 96.46994608249469
+    );
+    const bubblePointTempError = Math.abs(
+      (flashCalc.flashResult!.bubblePointTemperature! - 269.42243315914885) / 269.42243315914885
+    );
+    const bubblePointPressureError = Math.abs(
+      (flashCalc.flashResult!.bubblePointPressure! - 153386.54309610242) / 153386.54309610242
+    );
+
+    expect(totalFluidDensityError).toBeLessThan(1e-3);
+    expect(flashCalc.flashResult!.fluidPhase).toBe(2);
+    expect(bubblePointTempError).toBeLessThan(1e-3);
+    expect(bubblePointPressureError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: flashCalculation (${flashCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/flash-calculation/testCase28.test.ts

@@ -0,0 +1,69 @@
+import { Material, MaterialComponent, State } from "../../src/entities";
+import { FlashCalculation } from "../../src/calculations/properties";
+import { ResultCode } 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("Flash Calculation Scenario - Test Case 28", () => {
+  test("should run the flash calculation and perform regression check", async () => {
+    // Set the case properties
+    const stateTemperature = 350.0;
+    const statePressure = 2.0e5;
+    const stateLiquidFraction = 0.7;
+
+    // Define the initial state of the vessel
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: stateLiquidFraction
+    });
+
+    // Define the material
+    const material = new Material({
+      name: "Case28_Material",
+      components: [
+        new MaterialComponent({ name: "N-DECANE", moleFraction: 0.333 }),
+        new MaterialComponent({ name: "N-UNDECANE", moleFraction: 0.333 }),
+        new MaterialComponent({ name: "WATER", moleFraction: 0.334 })
+      ],
+      componentCount: 3
+    });
+
+    // Create and run flash calculation
+    const flashCalc = new FlashCalculation(material, state);
+
+    console.log("Running flashCalculation...");
+    const resultCode = await flashCalc.run();
+
+    if (flashCalc.messages.length > 0) {
+      console.log("Messages:");
+      flashCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const totalFluidDensityError = Math.abs(
+      (flashCalc.flashResult!.totalFluidDensity! - 705.2670016215116) / 705.2670016215116
+    );
+    const bubblePointTempError = Math.abs(
+      (flashCalc.flashResult!.bubblePointTemperature! - 425.9402358853448) / 425.9402358853448
+    );
+    const bubblePointPressureError = Math.abs(
+      (flashCalc.flashResult!.bubblePointPressure! - 15560.140921506196) / 15560.140921506196
+    );
+
+    expect(totalFluidDensityError).toBeLessThan(1e-3);
+    expect(flashCalc.flashResult!.fluidPhase).toBe(3);
+    expect(bubblePointTempError).toBeLessThan(1e-3);
+    expect(bubblePointPressureError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: flashCalculation (${flashCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/flash-calculation/testCase29.test.ts

@@ -0,0 +1,67 @@
+import { Material, MaterialComponent, State } from "../../src/entities";
+import { FlashCalculation } from "../../src/calculations/properties";
+import { ResultCode } 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("Flash Calculation Scenario - Test Case 29", () => {
+  test("should run the flash calculation and perform regression check", async () => {
+    // Set the case properties
+    const stateTemperature = 300.0;
+    const statePressure = 2.0e5;
+    const stateLiquidFraction = 0.8;
+
+    // Define the initial state of the vessel
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: stateLiquidFraction
+    });
+
+    // Define the material
+    const material = new Material({
+      name: "N-BUTANE",
+      components: [
+        new MaterialComponent({ name: "N-BUTANE", moleFraction: 1.0 })
+      ],
+      componentCount: 1
+    });
+
+    // Create and run flash calculation
+    const flashCalc = new FlashCalculation(material, state);
+
+    console.log("Running flashCalculation...");
+    const resultCode = await flashCalc.run();
+
+    if (flashCalc.messages.length > 0) {
+      console.log("Messages:");
+      flashCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const totalFluidDensityError = Math.abs(
+      (flashCalc.flashResult!.totalFluidDensity! - 4.922619520710173) / 4.922619520710173
+    );
+    const bubblePointTempError = Math.abs(
+      (flashCalc.flashResult!.bubblePointTemperature! - 291.9424041360644) / 291.9424041360644
+    );
+    const bubblePointPressureError = Math.abs(
+      (flashCalc.flashResult!.bubblePointPressure! - 258003.82350284143) / 258003.82350284143
+    );
+
+    expect(totalFluidDensityError).toBeLessThan(1e-3);
+    expect(flashCalc.flashResult!.fluidPhase).toBe(1);
+    expect(bubblePointTempError).toBeLessThan(1e-3);
+    expect(bubblePointPressureError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: flashCalculation (${flashCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/flash-calculation/testCase30.test.ts

@@ -0,0 +1,70 @@
+import { Material, MaterialComponent, State } from "../../src/entities";
+import { FlashCalculation } from "../../src/calculations/properties";
+import { ResultCode } 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("Flash Calculation Scenario - Test Case 30", () => {
+  test("should run the flash calculation and perform regression check", async () => {
+    // Set the case properties
+    const stateTemperature = 290.0;
+    const statePressure = 1.0e6;
+    const stateLiquidFraction = 0.8;
+
+    // Define the initial state of the vessel
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: stateLiquidFraction
+    });
+
+    // Define the material
+    const material = new Material({
+      name: "Case30_Material",
+      components: [
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.25 }),
+        new MaterialComponent({ name: "ETHANE", moleFraction: 0.25 }),
+        new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.25 }),
+        new MaterialComponent({ name: "HYDROGEN SULFIDE", moleFraction: 0.25 })
+      ],
+      componentCount: 4
+    });
+
+    // Create and run flash calculation
+    const flashCalc = new FlashCalculation(material, state);
+
+    console.log("Running flashCalculation...");
+    const resultCode = await flashCalc.run();
+
+    if (flashCalc.messages.length > 0) {
+      console.log("Messages:");
+      flashCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Regression checks
+    const totalFluidDensityError = Math.abs(
+      (flashCalc.flashResult!.totalFluidDensity! - 8.777167721290303) / 8.777167721290303
+    );
+    const bubblePointTempError = Math.abs(
+      (flashCalc.flashResult!.bubblePointTemperature! - 45.7498568184341) / 45.7498568184341
+    );
+    const bubblePointPressureError = Math.abs(
+      (flashCalc.flashResult!.bubblePointPressure! - 13803578.156685727) / 13803578.156685727
+    );
+
+    expect(totalFluidDensityError).toBeLessThan(1e-3);
+    expect(flashCalc.flashResult!.fluidPhase).toBe(1);
+    expect(bubblePointTempError).toBeLessThan(1e-3);
+    expect(bubblePointPressureError).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: flashCalculation (${flashCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/general/operation-id-demo.test.ts

@@ -0,0 +1,64 @@
+import { Material, MaterialComponent, State, Vessel } from "../../src/entities";
+import { GetMassFromVesselCalculation } from "../../src/calculations/utilities";
+import { ResultCode, VesselConditions, 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("Get Mass From Vessel Calculation - Demo Test", () => {
+  test("should calculate mass from vessel with carbon dioxide", async () => {
+    // Define test case properties
+    const materialName = "CARBON DIOXIDE (TOXIC)";
+    const stateTemperature = 280.0;
+    const statePressure = 8.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 5.0;
+
+    // Define the initial state
+    const state = new State({
+      temperature: stateTemperature,
+      pressure: statePressure,
+      liquidFraction: 0.8
+    });
+
+    // Define the material
+    const material = new Material({
+      name: materialName,
+      components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })]
+    });
+
+    // Create vessel
+    const vessel = new Vessel({
+      state: state,
+      material: material,
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      vesselConditions: VesselConditions.PRESSURIZED_LIQUID_VESSEL,
+      liquidFillFractionByVolume: 0.6
+    });
+
+    // Create and run get mass from vessel calculation
+    const getMassFromVesselCalc = new GetMassFromVesselCalculation(vessel);
+    
+    console.log("Running getMassFromVesselCalculation...");
+    const resultCode = await getMassFromVesselCalc.run();
+
+    // Log operation ID
+    console.log(`operation_id: ${getMassFromVesselCalc.operationId}`);
+
+    // Log any messages
+    if (getMassFromVesselCalc.messages.length > 0) {
+      console.log("Messages:");
+      getMassFromVesselCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    // Assertions
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: getMassFromVesselCalculation (${getMassFromVesselCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/get-component-by-id/get-component-by-id-METHANE.test.ts

@@ -0,0 +1,35 @@
+import { MaterialComponent } from "../../src/entities";
+import { getComponentById } from "../../src/materials"; // Assuming this is where the function would live in TS
+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("Material Component Retrieval - Test Case", () => {
+  test("should get material component data by ID for METHANE", async () => {
+    // Test description
+    /**
+     * Test to get the material component data by id for METHANE.
+     * METHANE entity id = 9ad96d64-098e-4079-b604-a432145eba99.
+     */
+
+    // Define the methane component ID
+    const methaneId = "9ad96d64-098e-4079-b604-a432145eba99";
+
+    console.log("Running getComponentById...");
+    
+    // Invoke the method
+    const materialComponentData = await getComponentById(methaneId);
+
+    console.log("Material Component Data:", materialComponentData);
+
+    // Basic assertions - adjust these based on expected MaterialComponent properties
+    expect(materialComponentData).toBeDefined();
+    expect(materialComponentData.name).toBe("METHANE"); // Assuming name is a property
+    expect(materialComponentData.id).toBe(methaneId);   // Assuming id is a property
+  });
+});

package/tests/get-mass-from-vessel-calculation/testCase139.test.ts

@@ -0,0 +1,65 @@
+import { Material, MaterialComponent, State, Vessel } from "../../src/entities";
+import { GetMassFromVesselCalculation } from "../../src/calculations/utilities";
+import { ResultCode, VesselConditions, 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("Get Mass From Vessel - Test Case 139", () => {
+  test("should calculate mass from vessel and perform regression check", async () => {
+    // Define the case properties
+    const materialName = "CARBON DIOXIDE (TOXIC)";
+    const stateTemperature = 280.0;
+    const statePressure = 8.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 5.0;
+
+    // Define the material
+    const material = new Material({
+      name: materialName,
+      components: [new MaterialComponent({ name: materialName, moleFraction: 1.0 })]
+    });
+
+    // Create vessel
+    const vessel = new Vessel({
+      state: new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: 0.8
+      }),
+      material: material,
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      vesselConditions: VesselConditions.PRESSURIZED_LIQUID_VESSEL,
+      liquidFillFractionByVolume: 0.6
+    });
+
+    // Create and run get mass from vessel calculation
+    const getMassFromVesselCalc = new GetMassFromVesselCalculation(vessel);
+    
+    console.log("Running getMassFromVesselCalculation...");
+    const resultCode = await getMassFromVesselCalc.run();
+
+    if (getMassFromVesselCalc.messages.length > 0) {
+      console.log("Messages:");
+      getMassFromVesselCalc.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    
+    // Regression check
+    const massError = Math.abs(
+      (getMassFromVesselCalc.massInventory! - 34659.76615856555) / 34659.76615856555
+    );
+    
+    expect(massError).toBeLessThan(1e-3);
+    
+    console.log(`SUCCESS: getMassFromVesselCalculation (${getMassFromVesselCalc.calculationElapsedTime}ms)`);
+    console.log(`Mass from vessel = ${getMassFromVesselCalc.massInventory}`);
+  });
+});

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

@@ -0,0 +1,141 @@
+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 36", () => {
+    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 windSpeed = 2.0;
+      const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+      const surfaceRoughness = 0.18;
+      const timeOfInterest = 10.0;
+  
+      // 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: 0.0
+      });
+  
+      // 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
+      });
+  
+      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)`);
+    });
+  });