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

package/tests/max-distance-to-conc-calculation/testCase114.test.ts

@@ -0,0 +1,162 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig, LineRupture } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation, VesselLeakCalculation, VesselLineRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import {  MaxDistanceToConcCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, VesselShape, TimeVaryingOption, SpecialConcentration, 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("Max Distance to Concentration Calculation - Test Case 114", () => {
+    test("should calculate max distance to concentration correctly", async () => {
+      const stateTemperature = 290.0;
+      const statePressure = 7.0e6;
+      const stateLiquidFraction = 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 state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: stateLiquidFraction,
+      });
+  
+      const material = new Material({
+        name: "AMMONIA",
+        components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResultCode = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        vesselConditions: vesselStateCalculation.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 vesselLineRuptureCalculation = new VesselLineRuptureCalculation(
+        vessel,
+        lineRupture,
+        new DischargeParameters()
+      );
+  
+      const vesselLineRuptureResultCode = await vesselLineRuptureCalculation.run();
+  
+      if (vesselLineRuptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselLineRuptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselLineRuptureResultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+  
+      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 dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselLineRuptureCalculation.exitMaterial!,
+        substrate,
+        vesselLineRuptureCalculation.dischargeResult!,
+        vesselLineRuptureCalculation.dischargeRecords!,
+        vesselLineRuptureCalculation.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration
+      );
+  
+      const dispersionResultCode = await dispersionCalculation.run();
+  
+      if (dispersionCalculation.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(dispersionResultCode).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation: 1.0,
+        specialConcentration: SpecialConcentration.LFL,
+      });
+  
+      const maxDistanceToConcCalculation = new MaxDistanceToConcCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        dispersionParameters,
+        vesselLineRuptureCalculation.exitMaterial!
+      );
+  
+      const maxDistanceResultCode = await maxDistanceToConcCalculation.run();
+  
+      if (maxDistanceToConcCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxDistanceToConcCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistanceResultCode).toBe(ResultCode.SUCCESS);
+  
+      const expectedDistance = 42.28674862332736;
+      const distanceError = Math.abs(
+        (maxDistanceToConcCalculation.distance! - expectedDistance) / expectedDistance
+      );
+  
+      expect(distanceError).toBeLessThan(1e-3);
+      console.log(`SUCCESS: max_distance_to_conc_calculation (${maxDistanceToConcCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+  

package/tests/max-distance-to-conc-calculation/testCase115.test.ts

@@ -0,0 +1,167 @@
+import { Material, MaterialComponent, State, Vessel, Bund, Substrate, DischargeParameters, Weather, DispersionParameters, DispersionOutputConfig, ReliefValve } from "../../src/entities";
+import { VesselCatastrophicRuptureCalculation, VesselStateCalculation, VesselReliefValveCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import {  MaxDistanceToConcCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, VesselShape, TimeVaryingOption, SpecialConcentration, 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("Max Distance to Concentration Calculation - Test Case 115", () => {
+    test("should calculate max distance to concentration for CHLORINE vessel with relief valve", async () => {
+      // Define vessel and relief valve parameters
+      const stateTemperature = 320.0;
+      const statePressure = 1.0e6;
+      const stateLiquidFraction = 1.0;
+      const vesselShape = VesselShape.HORIZONTAL_CYLINDER;
+      const vesselDiameter = 2.0;
+      const vesselLength = 5.0;
+      const liquidFillFractionByVolume = 0.7;
+  
+      const reliefValvePipeDiameter = 0.02;
+      const reliefValvePipeLength = 10.0;
+      const reliefValvePipeHeightFraction = 1.0;
+      const reliefValveConstrictionDiameter = 0.02;
+  
+      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;
+  
+      // Define state and material
+      const state = new State({
+        temperature: stateTemperature,
+        pressure: statePressure,
+        liquidFraction: stateLiquidFraction,
+      });
+  
+      const material = new Material({
+        name: "CHLORINE",
+        components: [new MaterialComponent({ name: "CHLORINE", moleFraction: 1.0 })],
+        componentCount: 1,
+      });
+  
+      // Run VesselStateCalculation
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const stateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(stateResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      // Define Vessel
+      const vessel = new Vessel({
+        state,
+        material,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+        liquidFillFractionByVolume: liquidFillFractionByVolume,
+        shape: vesselShape,
+        diameter: vesselDiameter,
+        length: vesselLength,
+      });
+  
+      // Define Relief Valve
+      const reliefValve = new ReliefValve({
+        pipeDiameter: reliefValvePipeDiameter,
+        pipeLength: reliefValvePipeLength,
+        pipeHeightFraction: reliefValvePipeHeightFraction,
+        reliefValveConstrictionDiameter: reliefValveConstrictionDiameter,
+      });
+  
+      // Run VesselReliefValveCalculation
+      const vesselReliefValveCalculation = new VesselReliefValveCalculation(
+        vessel,
+        reliefValve,
+        new DischargeParameters()
+      );
+  
+      const reliefResult = await vesselReliefValveCalculation.run();
+  
+      if (vesselReliefValveCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselReliefValveCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(reliefResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_relief_valve_calculation (${vesselReliefValveCalculation.calculationElapsedTime}ms)`);
+      console.log(`Release mass: ${vesselReliefValveCalculation.dischargeResult?.releaseMass} kg`);
+  
+      // Set up DispersionCalculation
+      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 dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselReliefValveCalculation.exitMaterial!,
+        substrate,
+        vesselReliefValveCalculation.dischargeResult!,
+        vesselReliefValveCalculation.dischargeRecords!,
+        vesselReliefValveCalculation.dischargeRecords!.length,
+        weather,
+        dispersionParameters,
+        endPointConcentration
+      );
+  
+      const dispersionResult = await dispersionCalculation.run();
+  
+      if (dispersionCalculation.messages.length > 0) {
+        console.log("Messages:");
+        dispersionCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(dispersionResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+  
+      // Set up MaxDistanceToConcCalculation
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: 1e-4,
+        elevation: 3.5,
+        specialConcentration: SpecialConcentration.NOT_DEFINED,
+      });
+  
+      const maxDistanceToConcCalculation = new MaxDistanceToConcCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        dispersionParameters,
+        vesselReliefValveCalculation.exitMaterial!
+      );
+  
+      const maxDistResult = await maxDistanceToConcCalculation.run();
+  
+      if (maxDistanceToConcCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxDistanceToConcCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistResult).toBe(ResultCode.SUCCESS);
+  
+      const expectedDistance = 319.19195887085976;
+      const actualDistance = maxDistanceToConcCalculation.distance!;
+      const distanceError = Math.abs((actualDistance - expectedDistance) / expectedDistance);
+  
+      expect(distanceError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: max_distance_to_conc_calculation (${maxDistanceToConcCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+  

package/tests/mixture-constant-properties-calculation/testCase97.test.ts

@@ -0,0 +1,83 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { MixtureConstantPropertiesCalculation } from "../../src/calculations/applicationTools";
+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);
+// Define the test case
+describe("Mixture Constant Properties Calculation - Test Case 97", () => {
+  test("should calculate the correct mixture constant properties", async () => {
+    // Set the material
+    const material = new Material(
+        {
+            name: "NATURAL GAS", 
+            components:
+            [
+                new MaterialComponent({name: "METHANE", moleFraction: 0.85}),
+                new MaterialComponent({name: "ETHANE", moleFraction: 0.1}),
+                new MaterialComponent({name: "PROPANE", moleFraction: 0.05}),
+            ],
+            componentCount: 3
+        });
+
+    // Create a mixture constant properties calculation using the material
+    const mixtureConstantPropertiesCalculation = new MixtureConstantPropertiesCalculation(material);
+
+    // Run the calculation
+    console.log('Running mixtureConstantPropertiesCalculation...');
+    const resultCode = await mixtureConstantPropertiesCalculation.run();
+    
+    // Print any messages
+    if (mixtureConstantPropertiesCalculation.messages.length > 0) {
+      console.log('Messages:');
+      mixtureConstantPropertiesCalculation.messages.forEach((message) => console.log(message));
+    }
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    // Check the result code and assertions
+    
+    expect(
+    Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.lowerFlammabilityLimit! - 0.04402515723270441) /
+        0.04402515723270441
+    )
+    ).toBeLessThan(1e-3);
+    expect(
+    Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.upperFlammabilityLimit! - 0.14286869340232858) /
+        0.14286869340232858
+    )
+    ).toBeLessThan(1e-3);
+    expect(
+    Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.criticalPressure! - 4608750.0) /
+        4608750.0
+    )
+    ).toBeLessThan(1e-3);
+    expect(
+    Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.criticalTemperature! - 210.991) /
+        210.991
+    )
+    ).toBeLessThan(1e-3);
+    expect(
+    Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.molecularWeight! - 18.847806000000002) /
+        18.847806000000002
+    )
+    ).toBeLessThan(1e-3);
+    expect(
+    Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.bubblePoint! - 113.67514401917592) /
+        113.67514401917592
+    )
+    ).toBeLessThan(1e-3);
+    
+    console.log(`SUCCESS: mixtureConstantPropertiesCalculation (${mixtureConstantPropertiesCalculation.calculationElapsedTime}ms)`);
+    
+  });
+});

package/tests/mixture-constant-properties-calculation/testCase98.test.ts

@@ -0,0 +1,90 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { MixtureConstantPropertiesCalculation } from "../../src/calculations/applicationTools";
+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);
+// Define the test case
+describe("Mixture Constant Properties Calculation - Test Case 98", () => {
+  test("should calculate the correct mixture constant properties", async () => {
+    // Set the material
+    const material = new Material(
+      {
+        name: "GASOLINE",
+        components: [
+          new MaterialComponent({ name: "N-OCTANE", moleFraction: 0.77 }),
+          new MaterialComponent({ name: "N-HEPTANE", moleFraction: 0.13 }),
+          new MaterialComponent({ name: "N-NONANE", moleFraction: 0.05 }),
+          new MaterialComponent({ name: "TOLUENE", moleFraction: 0.05 }),
+        ],
+        componentCount: 4,
+      }
+    );
+
+    // Create a mixture constant properties calculation using the material
+    const mixtureConstantPropertiesCalculation = new MixtureConstantPropertiesCalculation(material);
+
+    // Run the calculation
+    console.log('Running mixtureConstantPropertiesCalculation...');
+    const resultCode = await mixtureConstantPropertiesCalculation.run();
+
+    // Print any messages
+    if (mixtureConstantPropertiesCalculation.messages.length > 0) {
+      console.log('Messages:');
+      mixtureConstantPropertiesCalculation.messages.forEach((message) => console.log(message));
+    }
+
+    // Check if the result code is success
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Validate regression results with a tolerance of 1e-3
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.lowerFlammabilityLimit! - 0.00970712693329131) /
+        0.00970712693329131
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.upperFlammabilityLimit! - 0.06500456558538582) /
+        0.06500456558538582
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.criticalPressure! - 2593400.0) /
+        2593400.0
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.criticalTemperature! - 567.4425) /
+        567.4425
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.molecularWeight! - 112.00188860000002) /
+        112.00188860000002
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.bubblePoint! - 393.99970870791725) /
+        393.99970870791725
+      )
+    ).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: mixtureConstantPropertiesCalculation (${mixtureConstantPropertiesCalculation.calculationElapsedTime}ms)`);
+  });
+});

package/tests/mixture-constant-properties-calculation/testCase99.test.ts

@@ -0,0 +1,87 @@
+import { Material, MaterialComponent } from "../../src/entities";
+import { MixtureConstantPropertiesCalculation } from "../../src/calculations/applicationTools";
+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);
+// Define the test case
+describe("Mixture Constant Properties Calculation - Test Case 99", () => {
+  test("should calculate the correct mixture constant properties", async () => {
+    // Set the material
+    const material = new Material({
+      name: "ORIMULSION",
+      components: [
+        new MaterialComponent({ name: "N-DODECANE", moleFraction: 0.50 }),
+        new MaterialComponent({ name: "TOLUENE", moleFraction: 0.20 }),
+        new MaterialComponent({ name: "WATER", moleFraction: 0.30 }),
+      ],
+      componentCount: 3,
+    });
+
+    // Create a mixture constant properties calculation using the material
+    const mixtureConstantPropertiesCalculation = new MixtureConstantPropertiesCalculation(material);
+
+    // Run the calculation
+    console.log('Running mixtureConstantPropertiesCalculation...');
+    const resultCode = await mixtureConstantPropertiesCalculation.run();
+
+    // Print any messages
+    if (mixtureConstantPropertiesCalculation.messages.length > 0) {
+      console.log('Messages:');
+      mixtureConstantPropertiesCalculation.messages.forEach((message) => console.log(message));
+    }
+
+    // Ensure the result code is successful
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Check each property with tolerance
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.lowerFlammabilityLimit! - 0.009850746268656717) /
+        0.009850746268656717
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.upperFlammabilityLimit! - 0.0767991169977925) /
+        0.0767991169977925
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.criticalPressure! - 8350800.0) /
+        8350800.0
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.criticalTemperature! - 641.4788) /
+        641.4788
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.molecularWeight! - 108.999688) /
+        108.999688
+      )
+    ).toBeLessThan(1e-3);
+
+    expect(
+      Math.abs(
+        (mixtureConstantPropertiesCalculation.mixConstantPropResult!.bubblePoint! - 397.76504890039934) /
+        397.76504890039934
+      )
+    ).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: mixtureConstantPropertiesCalculation (${mixtureConstantPropertiesCalculation.calculationElapsedTime}ms)`);
+  });
+});