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

package/tests/concentration-at-point-calculation/testCase118.test.ts

@@ -0,0 +1,143 @@
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { ConcentrationAtPointCalculation } from "../../src/calculations/dispersionView";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Material, MaterialComponent, State, Substrate, Vessel, Weather, Leak } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, 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('Test Case 118', () => {
+    test('Concentration at point calculation for CARBON DIOXIDE (TOXIC)', async () => {
+
+        // Set 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;
+        const leakHoleDiameter = 0.008;
+        const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+        const leakHoleHeightFraction = 0.5;
+        const surfaceType = SurfaceType.WATER;
+        const surfaceRoughness = 0.01;
+        const windSpeed = 4.0;
+        const stabilityClass = AtmosphericStabilityClass.STABILITY_C;
+        const endPointConcentration = 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})]
+            });
+
+        // Create a vessel state calculation using the material and state
+        const vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        // Check the result of vessel state calculation
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Create a vessel for the leak calculation using the previously defined entities
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            diameter: vesselDiameter,
+            shape: vesselShape,
+            liquidFillFractionByVolume: 0.8
+        });
+
+        // Create a leak for the vessel leak calculation
+        const leak = new Leak({
+            holeDiameter: leakHoleDiameter,
+            holeHeightFraction: leakHoleHeightFraction,
+            timeVaryingOption: timeVaryingOption
+        });
+
+        // Create discharge parameters for the leak calculation
+        const dischargeParameters = new DischargeParameters();
+
+        // Create a vessel leak calculation
+        const vesselLeakCalculation = new VesselLeakCalculation(vessel, leak, dischargeParameters);
+        const leakResultCode = await vesselLeakCalculation.run();
+
+        // Check the result of vessel leak calculation
+        expect(leakResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalculation.calculationElapsedTime}ms)`);
+
+        // Set up entities for the dispersion calculation
+        const substrate = new Substrate({
+            surfaceType: surfaceType,
+            surfaceRoughness: surfaceRoughness
+        });
+
+        const weather = new Weather({
+            windSpeed: windSpeed,
+            stabilityClass: stabilityClass,
+            windProfileFlag: windProfileFlag
+        });
+
+        const dispersionParameters = new DispersionParameters();
+
+        const dispersionCalculation = new DispersionCalculation(
+            vesselLeakCalculation.exitMaterial!,
+            substrate,
+            vesselLeakCalculation.dischargeResult!,
+            vesselLeakCalculation.dischargeRecords!,
+            vesselLeakCalculation.dischargeRecords!.length,
+            weather,
+            dispersionParameters,
+            endPointConcentration
+        );
+
+        const dispersionResultCode = await dispersionCalculation.run();
+
+        // Check the result of the dispersion calculation
+        expect(dispersionResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+        console.log(`Final centreline concentration = ${dispersionCalculation.dispersionRecords![dispersionCalculation.dispersionRecords!.length - 1].centrelineConcentration}`);
+        console.log(`Final downwind distance = ${dispersionCalculation.dispersionRecords![dispersionCalculation.dispersionRecords!.length - 1].downwindDistance}`);
+
+        // Set up the entities for the concentration at point calculation
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: endPointConcentration,
+            downwindDistance: 10
+        });
+
+        const concentrationAtPointCalculation = new ConcentrationAtPointCalculation(
+            dispersionCalculation.scalarUdmOutputs!,
+            weather,
+            dispersionCalculation.dispersionRecords!,
+            dispersionCalculation.dispersionRecords!.length,
+            substrate,
+            dispersionOutputConfig,
+            vesselLeakCalculation.exitMaterial!,
+            dispersionParameters
+        );
+
+        const concentrationResultCode = await concentrationAtPointCalculation.run();
+
+        // Check the result of concentration at point calculation
+        expect(concentrationResultCode).toBe(ResultCode.SUCCESS);
+
+        const expectedConcentration = 0.0040424883934447944;
+        expect(Math.abs(concentrationAtPointCalculation.concentration! - expectedConcentration) / expectedConcentration).toBeLessThan(1e-3);
+        console.log(`SUCCESS: concentration_at_point_calculation (${concentrationAtPointCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/concentration-at-point-calculation/testCase119.test.ts

@@ -0,0 +1,149 @@
+import { VesselLineRuptureCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { ConcentrationAtPointCalculation } from "../../src/calculations/dispersionView";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { Bund, DischargeParameters, DispersionOutputConfig, DispersionParameters, Material, MaterialComponent, State, Substrate, Vessel, Weather, LineRupture } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, 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('Test Case 119', () => {
+    test('Concentration at point calculation for AMMONIA', async () => {
+
+        // Set the case properties
+        const materialName = 'AMMONIA';
+        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;
+
+        // Define the initial state of the vessel
+        const state = new State({
+            temperature: stateTemperature,
+            pressure: statePressure,
+            liquidFraction: stateLiquidFraction
+        });
+
+        // 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 vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        // Check the result of vessel state calculation
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Create a vessel for the line rupture calculation using the previously defined entities
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: 0.7,
+            shape: VesselShape.VESSEL_CUBOID,
+            height: 2.0,
+            width: 1.0,
+            length: 3.0
+        });
+
+        // Create a line rupture for the vessel line rupture calculation
+        const lineRupture = new LineRupture({
+            pipeDiameter: 0.1,
+            pipeLength: 1.0,
+            pipeHeightFraction: 0.1
+        });
+
+        // Create a vessel line rupture calculation
+        const vesselLineRuptureCalculation = new VesselLineRuptureCalculation(vessel, lineRupture, new DischargeParameters());
+        const lineRuptureResultCode = await vesselLineRuptureCalculation.run();
+
+        // Check the result of vessel line rupture calculation
+        expect(lineRuptureResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_line_rupture_calculation (${vesselLineRuptureCalculation.calculationElapsedTime}ms)`);
+
+        // Set up entities for the dispersion calculation
+        const bund = new Bund({
+            specifyBund: specifyBund,
+            bundHeight: bundHeight,
+            bundDiameter: bundDiameter
+        });
+        
+        const substrate = new Substrate({
+            bund: bund,
+            surfaceType: surfaceType,
+            surfaceRoughness: 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();
+
+        // Check the result of dispersion calculation
+        expect(dispersionResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+
+        // Set up the entities for the concentration at point calculation
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: endPointConcentration,
+            downwindDistance: 140,
+            time: 5,
+            elevation: 1
+        });
+
+        const concentrationAtPointCalculation = new ConcentrationAtPointCalculation(
+            dispersionCalculation.scalarUdmOutputs!,
+            weather,
+            dispersionCalculation.dispersionRecords!,
+            dispersionCalculation.dispersionRecords!.length,
+            substrate,
+            dispersionOutputConfig,
+            vesselLineRuptureCalculation.exitMaterial!,
+            dispersionParameters
+        );
+
+        const concentrationResultCode = await concentrationAtPointCalculation.run();
+
+        // Check the result of concentration at point calculation
+        expect(concentrationResultCode).toBe(ResultCode.SUCCESS);
+
+        const expectedConcentration = 2.593311923058257e-08;
+        expect(Math.abs(concentrationAtPointCalculation.concentration! - expectedConcentration) / expectedConcentration).toBeLessThan(1e-3);
+        console.log(`SUCCESS: concentration_at_point_calculation (${concentrationAtPointCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/concentration-at-point-calculation/testCase120.test.ts

@@ -0,0 +1,155 @@
+import { VesselStateCalculation, VesselReliefValveCalculation} from "../../src/calculations/discharge";
+import { ConcentrationAtPointCalculation } from "../../src/calculations/dispersionView";
+import { DispersionCalculation } from "../../src/calculations/dispersion";
+import { Material, MaterialComponent, State, ReliefValve, Vessel, Substrate, Bund, Weather, DispersionOutputConfig, DischargeParameters, DispersionParameters } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, SurfaceType, 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('Test Case 120', () => {
+    test('Concentration at point calculation for CHLORINE', async () => {
+
+        // Set the case properties
+        const materialName = 'CHLORINE';
+        const stateTemperature = 320.0;
+        const statePressure = 1.0E+06;
+        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;
+        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 the initial state of the vessel
+        const state = new State({
+            temperature: stateTemperature,
+            pressure: statePressure,
+            liquidFraction: stateLiquidFraction
+        });
+
+        // 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 vesselStateCalculation = new VesselStateCalculation(material, state);
+        const vesselStateResultCode = await vesselStateCalculation.run();
+
+        // Check the result of vessel state calculation
+        expect(vesselStateResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalculation.calculationElapsedTime}ms)`);
+
+        // Create a vessel for the relief valve calculation using the previously defined entities
+        const vessel = new Vessel({
+            state: vesselStateCalculation.outputState!,
+            material: vesselStateCalculation.material,
+            vesselConditions: vesselStateCalculation.vesselConditions,
+            liquidFillFractionByVolume: liquidFillFractionByVolume,
+            shape: vesselShape,
+            diameter: vesselDiameter,
+            length: vesselLength
+        });
+
+        // Create a relief valve for the vessel relief valve calculation
+        const reliefValve = new ReliefValve({
+            pipeDiameter: reliefValvePipeDiameter,
+            pipeLength: reliefValvePipeLength,
+            pipeHeightFraction: reliefValvePipeHeightFraction,
+            reliefValveConstrictionDiameter: reliefValveConstrictionDiameter
+        });
+
+        // Create a vessel relief valve calculation
+        const vesselReliefValveCalculation = new VesselReliefValveCalculation(vessel, reliefValve, new DischargeParameters());
+        const reliefValveResultCode = await vesselReliefValveCalculation.run();
+
+        // Check the result of vessel relief valve calculation
+        expect(reliefValveResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: vessel_relief_valve_calculation (${vesselReliefValveCalculation.calculationElapsedTime}ms)`);
+        console.log(`vessel_relief_valve_calculation.discharge_result.release_mass: ${vesselReliefValveCalculation.dischargeResult?.releaseMass} [kg]`);
+
+        // Set up entities for the dispersion calculation
+        const bund = new Bund({
+            specifyBund: specifyBund,
+            bundHeight: bundHeight,
+            bundDiameter: bundDiameter
+        });
+
+        const substrate = new Substrate({
+            bund: bund,
+            surfaceType: surfaceType,
+            surfaceRoughness: 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 dispersionResultCode = await dispersionCalculation.run();
+
+        // Check the result of dispersion calculation
+        expect(dispersionResultCode).toBe(ResultCode.SUCCESS);
+        console.log(`SUCCESS: dispersion_calculation (${dispersionCalculation.calculationElapsedTime}ms)`);
+
+        // Set up entities for the concentration at point calculation
+        const dispersionOutputConfig = new DispersionOutputConfig({
+            concentration: endPointConcentration
+        });
+
+        const concentrationAtPointCalculation = new ConcentrationAtPointCalculation(
+            dispersionCalculation.scalarUdmOutputs!,
+            weather,
+            dispersionCalculation.dispersionRecords!,
+            dispersionCalculation.dispersionRecords!.length,
+            substrate,
+            dispersionOutputConfig,
+            vesselReliefValveCalculation.exitMaterial!,
+            dispersionParameters
+        );
+
+        const concentrationResultCode = await concentrationAtPointCalculation.run();
+
+        // Check the result of concentration at point calculation
+        expect(concentrationResultCode).toBe(ResultCode.SUCCESS);
+
+        const expectedConcentration = 0.0005274004825735066;
+        expect(Math.abs(concentrationAtPointCalculation.concentration! - expectedConcentration) / expectedConcentration).toBeLessThan(1e-3);
+        console.log(`SUCCESS: concentration_at_point_calculation (${concentrationAtPointCalculation.calculationElapsedTime}ms)`);
+    });
+});

package/tests/constants/testConstants.test.ts

@@ -0,0 +1,23 @@
+import { PWS_CLIENT_ID, REST_API_URI } from "../../src/constants"; // Adjust the import path as needed
+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("Test Constants", () => {
+  // Mock environment variable for local run simulation
+  
+
+  test("should verify PWS_CLIENT_ID", () => {
+    expect(PWS_CLIENT_ID).toBe("eeca6885-127e-4405-aa1f-3a8e69acc451");
+  });
+
+  test("should verify REST_API_URI", () => {
+    console.log("Running test_analytics_rest_api_uri");
+    expect(REST_API_URI).toBe("https://plantwebservices.dnv.com/api/");
+  });
+});

package/tests/convert-comp-mass-to-mole-calculation/testCase129.test.ts

@@ -0,0 +1,74 @@
+import { ConvertCompositionMassToMoleCalculation } from "../../src/calculations/utilities";
+import { Material, MaterialComponent } from "../../src/entities";
+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('Test Case 129', () => {
+    test('Convert composition mass to mole calculation for ETHANE, BUTANE, and PROPANE', async () => {
+
+        // Define the test case properties
+        const materialName = 'ETHANE_BUTANE_PROPANE';
+        const compositionMass = [0.3, 0.5, 0.2];
+
+        // Define the material
+        const material = new Material({
+            name: materialName,
+            components: [
+                new MaterialComponent({ name: 'ETHANE', moleFraction: 0.3 }),
+                new MaterialComponent({ name: 'N-BUTANE', moleFraction: 0.5 }),
+                new MaterialComponent({ name: 'PROPANE', moleFraction: 0.2 })
+            ],
+            componentCount: 3
+        });
+
+        // Create a ConvertCompositionMassToMoleCalculation using the material and composition mass
+        const convertCompMassToMoleCalculation = new ConvertCompositionMassToMoleCalculation(
+            material,
+            compositionMass,
+            compositionMass.length
+        );
+
+        // Run the ConvertCompositionMassToMoleCalculation
+        console.log('Running convertCompMassToMoleCalculation...');
+        const resultCode = await convertCompMassToMoleCalculation.run();
+
+        // Print any messages
+        if (convertCompMassToMoleCalculation.messages.length > 0) {
+            console.log('Messages:');
+            convertCompMassToMoleCalculation.messages.forEach((message) => {
+                console.log(message);
+            });
+        }
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        
+        // Log mole and mass fractions
+        console.log(`Mole fraction: ${convertCompMassToMoleCalculation.compositionMole}`);
+        console.log(`Mass fraction: ${convertCompMassToMoleCalculation.compositionMass}`);
+    
+        // Ensure the properties are defined before using them
+        expect(convertCompMassToMoleCalculation.compositionMole).toBeDefined();
+        expect(convertCompMassToMoleCalculation.compositionMass).toBeDefined();
+    
+        if (convertCompMassToMoleCalculation.compositionMole) {
+            // Regression check for the first mole fraction value
+            const expectedMoleFraction = 0.431622743966463;
+            const actualMoleFraction = convertCompMassToMoleCalculation.compositionMole[0];
+            const moleFractionDifference = Math.abs((actualMoleFraction - expectedMoleFraction) / expectedMoleFraction);
+    
+            // Perform the regression check and fail if the difference is too large
+            expect(moleFractionDifference).toBeLessThan(1e-3);
+    
+            console.log(`SUCCESS: convertCompMassToMoleCalculation (${convertCompMassToMoleCalculation.calculationElapsedTime}ms)`);
+        } else {
+            throw new Error('Composition mole data is undefined.');
+        }
+        
+    });
+});

package/tests/convert-comp-mass-to-mole-calculation/testCase130.test.ts

@@ -0,0 +1,73 @@
+import { ConvertCompositionMassToMoleCalculation } from "../../src/calculations/utilities";
+import { Material, MaterialComponent } from "../../src/entities";
+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('Test Case 130', () => {
+    test('Convert composition mass to mole calculation for ETHANE, METHANE, and PROPANE', async () => {
+
+        // Define the test case properties
+        const materialName = 'ETHANE_METHANE_PROPANE';
+        const compositionMass = [0.4, 0.2, 0.4];
+
+        // Define the material
+        const material = new Material({
+            name: materialName,
+            components: [
+                new MaterialComponent({ name: 'ETHANE', moleFraction: 0.4 }),
+                new MaterialComponent({ name: 'METHANE', moleFraction: 0.2 }),
+                new MaterialComponent({ name: 'PROPANE', moleFraction: 0.4 })
+            ],
+            componentCount: 3
+        });
+
+        // Create a ConvertCompositionMassToMoleCalculation using the material and composition mass
+        const convertCompMassToMoleCalculation = new ConvertCompositionMassToMoleCalculation(
+            material,
+            compositionMass,
+            compositionMass.length
+        );
+
+        // Run the ConvertCompositionMassToMoleCalculation
+        console.log('Running convertCompMassToMoleCalculation...');
+        const resultCode = await convertCompMassToMoleCalculation.run();
+
+        // Print any messages
+        if (convertCompMassToMoleCalculation.messages.length > 0) {
+            console.log('Messages:');
+            convertCompMassToMoleCalculation.messages.forEach((message) => {
+                console.log(message);
+            });
+        }
+        expect(resultCode).toBe(ResultCode.SUCCESS);
+        
+        // Log mole and mass fractions
+        console.log(`Mole fraction: ${convertCompMassToMoleCalculation.compositionMole}`);
+        console.log(`Mass fraction: ${convertCompMassToMoleCalculation.compositionMass}`);
+    
+        // Ensure the properties are defined before using them
+        expect(convertCompMassToMoleCalculation.compositionMole).toBeDefined();
+        expect(convertCompMassToMoleCalculation.compositionMass).toBeDefined();
+    
+        if (convertCompMassToMoleCalculation.compositionMole) {
+            // Regression check for the first mole fraction value
+            const expectedMoleFraction = 0.3818147205269292;
+            const actualMoleFraction = convertCompMassToMoleCalculation.compositionMole[0];
+            const moleFractionDifference = Math.abs((actualMoleFraction - expectedMoleFraction) / expectedMoleFraction);
+    
+            // Perform the regression check and fail if the difference is too large
+            expect(moleFractionDifference).toBeLessThan(1e-3);
+    
+            console.log(`SUCCESS: convertCompMassToMoleCalculation (${convertCompMassToMoleCalculation.calculationElapsedTime}ms)`);
+        } else {
+            throw new Error('Composition mole data is undefined.');
+        }
+    });
+});