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

package/tests/materials/test-get-components.test.ts

@@ -0,0 +1,47 @@
+import { getComponents } from "../../src/materials";
+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('getComponents function', () => {
+  it('should fetch DNV components', async () => {
+    console.log('Running get_components for DNV components');
+    
+    // Fetch DNV components (ID 1 in this case)
+    const components = await getComponents(1);
+
+    // Assert that components are returned
+    expect(components).not.toBeNull();
+    
+    if (components) {
+      // Print out the list of component names
+      console.log('DNV components:');
+      components.forEach((component) => {
+        console.log(`${component.name}, ${component.id}`);
+      });
+    }
+  });
+
+  it('should fetch DIPPR components', async () => {
+    console.log('Running get_components for DIPPR components');
+
+    // Fetch DIPPR components (ID 2 in this case)
+    const components = await getComponents(2);
+
+    // Assert that components are returned
+    expect(components).not.toBeNull();
+
+    if (components) {
+      // Print out the list of component names
+      console.log('DIPPR components:');
+      components.forEach((component) => {
+        console.log(`${component.name}, ${component.id}`);
+      });
+    }
+  });
+});

package/tests/materials/test-get-dippr-components.test.ts

@@ -0,0 +1,28 @@
+import { getDipprComponents } from "../../src/materials";
+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('getDipprComponents Test', () => {
+  test('should retrieve DIPPR components successfully', async () => {
+    console.log('Running get_dippr_components');
+    
+    // Call the method to fetch DIPPR components
+    const dipprComponents = await getDipprComponents();
+
+    // Assert if there are no components returned
+    expect(dipprComponents).not.toBeNull();
+    expect(dipprComponents.length).toBeGreaterThan(0); // Ensure there's at least one component
+    
+    // Log out the names of the components
+    console.log('Components:');
+    dipprComponents.forEach((component) => {
+      console.log(component.name);
+    });
+  });
+});

package/tests/materials/test-get-dnv-components.test.ts

@@ -0,0 +1,28 @@
+import { getDnvComponents } from "../../src/materials";
+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_dnv_components', () => {
+  test('should return a list of DNV components', async () => {
+    console.log('Running get_dnv_components');
+    
+    // Invoke the method to fetch the DNV components
+    const dnvComponents = await getDnvComponents();
+
+    // Assert if no components were returned
+    expect(dnvComponents).not.toBeNull();
+    expect(dnvComponents.length).toBeGreaterThan(0); // Make sure there's at least one component
+
+    // Print out the list of component names
+    console.log('Components:');
+    dnvComponents.forEach((component: { name: string }) => {
+      console.log(component.name);
+    });
+  });
+});

package/tests/materials/test-get-material-by-cas-id-1-2-PROPYLENE-OXIDE.test.ts

@@ -0,0 +1,29 @@
+import { getMaterialByCasId } from "../../src/materials";;
+import { Material } from "../../src/entities";
+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
+describe('getMaterialByCasId - Test Case 1,2-PROPYLENE OXIDE', () => {
+  it('should return the material for CAS ID 75569 as 1,2-PROPYLENE OXIDE', async () => {
+    console.log('Running getMaterialByCasId');
+
+    // Call the function to get materials by CAS ID
+    const material = await getMaterialByCasId(75569);
+
+    // Check that materials is not null and has at least one entry
+    expect(material).not.toBeNull();
+
+    // Check if the material name is 1,2-PROPYLENE OXIDE
+    const foundMaterialName = material[0].name === '1,2-PROPYLENE OXIDE';
+    expect(foundMaterialName).toBe(true);
+    
+    // Log the materials for verification
+    console.log('Material:', material[0].name);
+  });
+});

package/tests/materials/test-get-material-by-cas-id-CARBON-MONOXIDE.test.ts

@@ -0,0 +1,31 @@
+import { getMaterialByCasId } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialByCasId - Test Case 2, CARBON MONOXIDE', () => {
+  it('should return the material for CAS ID 630080 as CARBON MONOXIDE', async () => {
+    console.log('Running getMaterialByCasId');
+
+    // Call the function to get materials by CAS ID
+    const material = await getMaterialByCasId(630080);
+
+    // Check that material is not null
+    expect(material).not.toBeNull();
+
+    // Check if the material name is CARBON MONOXIDE
+    const foundMaterialName = material[0].name === 'CARBON MONOXIDE';
+    expect(foundMaterialName).toBe(true);
+
+    // Log the materials for verification
+    console.log('Material:', material[0].name);
+  });
+});

package/tests/materials/test-get-material-by-cas-id-METHANE.test.ts

@@ -0,0 +1,30 @@
+import { getMaterialByCasId } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialByCasId - Test Case METHANE', () => {
+  it('should return the material for CAS ID 74828 as METHANE', async () => {
+    console.log('Running getMaterialByCasId');
+
+    // Call the function to get materials by CAS ID
+    const material = await getMaterialByCasId(74828);
+
+    // Check that material is not null
+    expect(material).not.toBeNull();
+
+    // Check if the material name is METHANE
+    const foundMaterialName = material[0].name === 'METHANE';
+    expect(foundMaterialName).toBe(true);
+
+    // Log the material for verification
+    console.log('Material:', material[0].name);
+  });
+});

package/tests/materials/test-get-material-by-cas-id-ZERO.test.ts

@@ -0,0 +1,31 @@
+import { getMaterialByCasId } from "../../src/materials";
+import { Material } from "../../src/entities";
+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);
+
+// Disabled this test because it is not possible to get a material by CASID=0.
+
+describe.skip('getMaterialByCasId - Disabled Test Case for CAS ID 0', () => {
+  /**
+   * Test to get the material by CASID=0.
+   * This test is intentionally disabled since fetching material by CAS ID 0 is not supported.
+   */
+
+  it('should not return a material for CAS ID 0', async () => {
+    console.log('Running getMaterialByCasId for CAS ID 0');
+
+    const material = await getMaterialByCasId(0);
+
+    // Assert that the material is not null
+    expect(material).not.toBeNull();
+
+    // Log material details for inspection
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-material-by-id-1-2-PROPYLENE-OXIDE.test.ts

@@ -0,0 +1,30 @@
+import { getMaterialById } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialById - Test Case for 1,2-PROPYLENE OXIDE', () => {
+  it('should return the material for ID 00b93527-dcea-48b6-bc03-a98aae6e630a as 1,2-PROPYLENE OXIDE', async () => {
+    console.log('Running getMaterialById');
+
+    // Call the function to get material by ID
+    const material: Material = await getMaterialById('00b93527-dcea-48b6-bc03-a98aae6e630a');
+
+    // Assert the material is not null
+    expect(material).not.toBeNull();
+
+    // Assert the material name is 1,2-PROPYLENE OXIDE
+    expect(material.name).toBe('1,2-PROPYLENE OXIDE');
+
+    // Log the result
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-material-by-id-CARBON-MONOXIDE.test.ts

@@ -0,0 +1,29 @@
+import { getMaterialById } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialById - Test Case for CARBON MONOXIDE', () => {
+  it('should return the material for ID 12ad526e-de43-4c44-9643-a7250d29ba94 as CARBON MONOXIDE', async () => {
+    console.log('Running getMaterialById');
+
+    // Call the function to get material by ID
+    const material = await getMaterialById('12ad526e-de43-4c44-9643-a7250d29ba94');
+
+    // Assert the material is not null
+    expect(material).not.toBeNull();
+
+    // Assert the material name is CARBON MONOXIDE
+    expect(material.name).toBe('CARBON MONOXIDE');
+
+    // Log the material for verification
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-material-by-id-METHANE.test.ts

@@ -0,0 +1,29 @@
+import { getMaterialById } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialById - Test Case for METHANE', () => {
+  it('should return the material for ID 13fb9798-78d7-41ee-af93-a7e4464dc7c1 as METHANE', async () => {
+    console.log('Running getMaterialById');
+
+    // Call the function to get material by ID
+    const material = await getMaterialById('13fb9798-78d7-41ee-af93-a7e4464dc7c1');
+
+    // Assert the material is not null
+    expect(material).not.toBeNull();
+
+    // Assert the material name is METHANE
+    expect(material.name).toBe('METHANE');
+
+    // Log the material for verification
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-material-by-name-1-2-PROPYLENE-OXIDE.test.ts

@@ -0,0 +1,29 @@
+import { getMaterialByName } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialByName - Test Case for 1,2-PROPYLENE OXIDE', () => {
+  it('should return the material named 1,2-PROPYLENE OXIDE', async () => {
+    console.log('Running getMaterialByName');
+
+    // Call the function to get material by name
+    const material = await getMaterialByName('1,2-PROPYLENE OXIDE');
+
+    // Assert the material is not null
+    expect(material).not.toBeNull();
+
+    // Assert the name matches exactly
+    expect(material.name).toBe('1,2-PROPYLENE OXIDE');
+
+    // Log the result for verification
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-material-by-name-CARBON-MONOXIDE.test.ts

@@ -0,0 +1,29 @@
+import { getMaterialByName } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialByName - Test Case for CARBON MONOXIDE', () => {
+  it('should return the material named CARBON MONOXIDE', async () => {
+    console.log('Running getMaterialByName');
+
+    // Call the function to get material by name
+    const material = await getMaterialByName('CARBON MONOXIDE');
+
+    // Assert the material is not null
+    expect(material).not.toBeNull();
+
+    // Assert the material name is CARBON MONOXIDE
+    expect(material.name).toBe('CARBON MONOXIDE');
+
+    // Log the material for verification
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-material-by-name-METHANE.test.ts

@@ -0,0 +1,29 @@
+import { getMaterialByName } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterialByName - Test Case for METHANE', () => {
+  it('should return the material for name METHANE', async () => {
+    console.log('Running getMaterialByName');
+
+    // Call the function to get material by name
+    const material = await getMaterialByName('METHANE');
+
+    // Assert the material is not null
+    expect(material).not.toBeNull();
+
+    // Assert the material name is METHANE
+    expect(material.name).toBe('METHANE');
+
+    // Log the material for verification
+    console.log('Material:', material);
+  });
+});

package/tests/materials/test-get-materials.test.ts

@@ -0,0 +1,32 @@
+import { getMaterials } from "../../src/materials";
+import { Material } from "../../src/entities";
+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
+describe('getMaterials - Test Case for retrieving all materials', () => {
+  it('should return a list of materials', async () => {
+    console.log('Running getMaterials');
+
+    // Call the function to get the list of materials
+    const materials = await getMaterials();
+
+    // Assert materials is not null
+    expect(materials).not.toBeNull();
+
+    // Assert we got at least one material (optional but helpful)
+    expect(materials.length).toBeGreaterThan(0);
+
+    // Log the materials' names
+    console.log('Materials:');
+    materials.forEach((material: Material) => {
+      console.log(material.name);
+    });
+  });
+});

package/tests/max-conc-distance-calculation/testCase106.test.ts

@@ -0,0 +1,146 @@
+import { Material, MaterialComponent, State, Vessel, Substrate, Weather, DischargeParameters, DispersionParameters, DispersionOutputConfig } from "../../src/entities";
+import { VesselStateCalculation, VesselCatastrophicRuptureCalculation } from "../../src/calculations/discharge";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { MaxConcDistanceCalculation } from "../../src/calculations/dispersionView";
+import { ResultCode, SurfaceType, AtmosphericStabilityClass, Resolution, SpecialConcentration, 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("Max Concentration Distance Calculation - Test Case 106", () => {
+    test("should run max concentration distance calculation with regression check", async () => {
+      const materialName = "AMMONIA";
+      const endPointConcentration = 0.0;
+      const elevation = 3.0;
+      const resolution = Resolution.LOW;
+      const specialConcentration = SpecialConcentration.MIN;
+      const lflFraction = 0.8;
+      const componentToTrackName = "";
+      const windProfileFlag = WindProfileFlag.LOGARITHMIC_PROFILE;
+  
+      const material = new Material({
+        name: materialName,
+        components: [new MaterialComponent({ name: materialName })],
+      });
+  
+      const state = new State({
+        temperature: 265.0,
+        pressure: 5.0e5,
+        liquidFraction: 0.0,
+      });
+  
+      const vesselStateCalculation = new VesselStateCalculation(material, state);
+      const vesselStateResult = await vesselStateCalculation.run();
+  
+      if (vesselStateCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselStateCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(vesselStateResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+  
+      const vessel = new Vessel({
+        state,
+        material,
+        liquidFillFractionByVolume: 0.8,
+        shape: VesselShape.VERTICAL_CYLINDER,
+        vesselConditions: vesselStateCalculation.vesselConditions,
+      });
+  
+      const dischargeParameters = new DischargeParameters();
+      const vesselCatastrophicRuptureCalculation = new VesselCatastrophicRuptureCalculation(vessel, dischargeParameters);
+  
+      const ruptureResult = await vesselCatastrophicRuptureCalculation.run();
+  
+      if (vesselCatastrophicRuptureCalculation.messages.length > 0) {
+        console.log("Messages:");
+        vesselCatastrophicRuptureCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(ruptureResult).toBe(ResultCode.SUCCESS);
+      console.log(`SUCCESS: vessel_catastrophic_rupture_calculation (${vesselCatastrophicRuptureCalculation.calculationElapsedTime}ms)`);
+  
+      const substrate = new Substrate(); 
+      const weather = new Weather({windProfileFlag: windProfileFlag});    
+      const dispersionParameters = new DispersionParameters();
+  
+      const dispersionCalculation = new DispersionCalculation(
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        substrate,
+        vesselCatastrophicRuptureCalculation.dischargeResult!,
+        vesselCatastrophicRuptureCalculation.dischargeRecords!,
+        vesselCatastrophicRuptureCalculation.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)`);
+      console.log(`Length dispersion records = ${dispersionCalculation.dispersionRecords!.length}`);
+      console.log(`Minimum concentration = ${dispersionCalculation.scalarUdmOutputs!.minimumConcentration}`);
+      console.log(`Observer count = ${dispersionCalculation.scalarUdmOutputs!.observerCount}`);
+      const lastDispersionRecord = dispersionCalculation.dispersionRecords!.at(-1)!;
+      console.log(`Final centreline concentration = ${lastDispersionRecord.centrelineConcentration}`);
+      console.log(`Final downwind distance = ${lastDispersionRecord.downwindDistance}`);
+  
+      const dispersionOutputConfig = new DispersionOutputConfig({
+        concentration: endPointConcentration,
+        elevation,
+        resolution,
+        specialConcentration,
+        lflFractionValue: lflFraction,
+        componentToTrackName,
+      });
+  
+      const maxConcDistanceCalculation = new MaxConcDistanceCalculation(
+        dispersionCalculation.scalarUdmOutputs!,
+        weather,
+        dispersionCalculation.dispersionRecords!,
+        dispersionCalculation.dispersionRecords!.length,
+        substrate,
+        dispersionOutputConfig,
+        vesselCatastrophicRuptureCalculation.exitMaterial!,
+        dispersionParameters
+      );
+  
+      const maxDistanceResult = await maxConcDistanceCalculation.run();
+  
+      if (maxConcDistanceCalculation.messages.length > 0) {
+        console.log("Messages:");
+        maxConcDistanceCalculation.messages.forEach((msg) => console.log(msg));
+      }
+  
+      expect(maxDistanceResult).toBe(ResultCode.SUCCESS);
+  
+      const records = maxConcDistanceCalculation.concentrationRecords!;
+      expect(records.length).toBe(26);
+  
+      const lastRecord = records.at(-1)!;
+  
+      const expectedConcentration = 0.0012711289961270592;
+      const expectedX = 842.991655276627;
+  
+      const concError = Math.abs((lastRecord.concentration! - expectedConcentration) / expectedConcentration);
+      const xError = Math.abs((lastRecord.position.x - expectedX) / expectedX);
+  
+      expect(concError).toBeLessThan(1e-3);
+      expect(xError).toBeLessThan(1e-3);
+  
+      console.log(`SUCCESS: max_conc_distance_calculation (${maxConcDistanceCalculation.calculationElapsedTime}ms)`);
+    });
+  });
+