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

package/tests/linked-runners/vessel-leak-linked-run/test-vl-157.test.ts

@@ -0,0 +1,182 @@
+import { VesselLeakLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLeakScenarioCalculation } from "../../../src/calculations/utilities";
+import { Material, MaterialComponent, Weather, Substrate, DischargeParameters, FlammableParameters, DispersionParameters, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume, FlammableOutputConfig, DispersionOutputConfig } from "../../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, 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("VesselLeakLinkedRunCalculation - VLR_157", () => {
+  it("should run the calculation and validate regression outputs", async () => {
+    // Create material with Ammonia
+    const material = new Material({
+      name: "AMMONIA", 
+      components: [new MaterialComponent({ name: "AMMONIA", moleFraction: 1.0 })], 
+      componentCount: 1
+    });
+
+    // Create a load mass inventory vessel for leak scenario calculation using the material
+    const loadMassInventoryVesselForLeakScenarioCalculation = new LoadMassInventoryVesselForLeakScenarioCalculation(
+      material,
+      1e3,
+      11e5,
+      250,
+      0.008,
+      1.0,
+      0.35
+    );
+
+    // Run the calculation
+    console.log('Running load_mass_inventory_vessel_for_leak_scenario_calculation...');
+    const loadResultCode = await loadMassInventoryVesselForLeakScenarioCalculation.run();
+
+    // Print any messages
+    if (loadMassInventoryVesselForLeakScenarioCalculation.messages.length > 0) {
+      console.log('Messages:');
+      loadMassInventoryVesselForLeakScenarioCalculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(loadResultCode).toBe(ResultCode.SUCCESS);
+    
+    if (loadResultCode === ResultCode.SUCCESS) {
+      console.log(`SUCCESS: load_mass_inventory_vessel_for_leak_scenario_calculation (${loadMassInventoryVesselForLeakScenarioCalculation.calculationElapsedTime}ms)`);
+    }
+
+    // Define the weather conditions
+    const weather = new Weather({ 
+      windSpeed: 5.0, 
+      stabilityClass: AtmosphericStabilityClass.STABILITY_B, 
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE 
+    });
+
+    // Define the substrate
+    const substrate = new Substrate();
+
+    // Define the dispersion parameters
+    const dispersionParameters = [
+      new DispersionParameters({ averagingTime: 18.75 }), 
+      new DispersionParameters({ averagingTime: 18.75 })
+    ];
+
+    // Define the dispersion output configuration
+    const dispersionOutputConfigsFlammable = [
+      new DispersionOutputConfig({ 
+        specialConcentration: SpecialConcentration.LFL_FRACTION, 
+        elevation: 0.0 
+      })
+    ];
+    
+    const dispersionOutputConfigsToxic = [
+      new DispersionOutputConfig({ 
+        specialConcentration: SpecialConcentration.NOT_DEFINED, 
+        concentration: 5e-5, 
+        elevation: 0.0 
+      })
+    ];
+
+    // Define the flammable parameters
+    const flammableParameters = new FlammableParameters();
+
+    // Define the flammable output configuration
+    const flammableOutputConfigs = [new FlammableOutputConfig()];
+
+    // Define the explosion parameters
+    const explosionParameters = new ExplosionParameters();
+
+    // Define the explosion output configuration
+    const explosionOutputConfigs = [new ExplosionOutputConfig()];
+
+    // Define the explosion confined volumes
+    const explosionConfinedVolumes = [new ExplosionConfinedVolume()];
+
+    // Create the vessel leak linked run calculation
+    const vesselLeakLinkedRunCalculation = new VesselLeakLinkedRunCalculation(
+      loadMassInventoryVesselForLeakScenarioCalculation.vessel!,
+      loadMassInventoryVesselForLeakScenarioCalculation.leak!,
+      new DischargeParameters(),
+      substrate,
+      weather,
+      dispersionParameters,
+      dispersionParameters.length,
+      0.0,
+      flammableParameters,
+      explosionParameters,
+      dispersionOutputConfigsFlammable,
+      dispersionOutputConfigsFlammable.length,
+      dispersionOutputConfigsToxic,
+      dispersionOutputConfigsToxic.length,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length,
+      explosionOutputConfigs,
+      explosionOutputConfigs.length,
+      explosionConfinedVolumes,
+      explosionConfinedVolumes.length
+    );
+
+    // Run the calculation
+    console.log('Running vessel_leak_linked_run_calculation...');
+    const resultCode = await vesselLeakLinkedRunCalculation.run();
+
+    // Print any messages
+    if (vesselLeakLinkedRunCalculation.messages.length > 0) {
+      console.log('Messages:');
+      vesselLeakLinkedRunCalculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    if (resultCode === ResultCode.SUCCESS) {
+      // Check if the results match expected values within tolerance
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.dischargeRecord!.massFlow! - 1.2425987768572015) / 1.2425987768572015
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.jetFireFlameResult!.flameLength! - 20.59055621597361) / 20.59055621597361
+      ).toBeLessThan(1e-3);
+      
+      expect(vesselLeakLinkedRunCalculation.poolFireFlameResult!.flameDiameter).toBe(0.0);
+      
+      expect(vesselLeakLinkedRunCalculation.flamConcContourPoints!.length).toBe(0);
+      
+      expect(vesselLeakLinkedRunCalculation.toxicConcContourPoints!.length).toBe(603);
+      
+      expect(vesselLeakLinkedRunCalculation.areaFootprintFlamConc![0]).toBe(0.0);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.areaFootprintToxicConc![0] - 28937.347548819664) / 28937.347548819664
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.areaContourJet![0] - 239.35604734762828) / 239.35604734762828
+      ).toBeLessThan(1e-3);
+      
+      expect(vesselLeakLinkedRunCalculation.areaContourPool![0]).toBe(0.0);
+      
+      expect(vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].explodedMass).toBe(0.0);
+      
+      expect(vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].maximumDistance).toBe(0.0);
+
+      // Log key results
+      console.log(`Mass flow = ${vesselLeakLinkedRunCalculation.dischargeRecord!.massFlow}`);
+      console.log(`Flame length = ${vesselLeakLinkedRunCalculation.jetFireFlameResult!.flameLength}`);
+      console.log(`Flame diameter = ${vesselLeakLinkedRunCalculation.poolFireFlameResult!.flameDiameter}`);
+      console.log(`Length of the dispersion flammable contour array = ${vesselLeakLinkedRunCalculation.flamConcContourPoints!.length}`);
+      console.log(`Length of the dispersion toxic contour array = ${vesselLeakLinkedRunCalculation.toxicConcContourPoints!.length}`);
+      console.log(`Area of the flammable cloud = ${vesselLeakLinkedRunCalculation.areaFootprintFlamConc![0]}`);
+      console.log(`Area of the toxic cloud = ${vesselLeakLinkedRunCalculation.areaFootprintToxicConc![0]}`);
+      console.log(`Area of the jet fire = ${vesselLeakLinkedRunCalculation.areaContourJet![0]}`);
+      console.log(`Area of the pool = ${vesselLeakLinkedRunCalculation.areaContourPool![0]}`);
+      console.log(`Flammable mass = ${vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].explodedMass}`);
+      console.log(`Explosion maximum distance = ${vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].maximumDistance}`);
+      
+      console.log(`SUCCESS: vessel_leak_linked_run_calculation (${vesselLeakLinkedRunCalculation.calculationElapsedTime}ms)`);
+    }
+  });
+});

package/tests/linked-runners/vessel-leak-linked-run/test-vl-158.test.ts

@@ -0,0 +1,200 @@
+import { VesselLeakLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLeakScenarioCalculation } from "../../../src/calculations/utilities";
+import { Material, MaterialComponent, Weather, Substrate, DischargeParameters, FlammableParameters, DispersionParameters, ExplosionParameters, ExplosionOutputConfig, ExplosionConfinedVolume, FlammableOutputConfig, DispersionOutputConfig } from "../../../src/entities";
+import { ResultCode, AtmosphericStabilityClass, SpecialConcentration, WindProfileFlag, MixtureModelling } 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("VesselLeakLinkedRunCalculation - VLR_158", () => {
+  it("should run the calculation and validate regression outputs", async () => {
+    // Create material with a mixture of propane, butane, and pentane
+    const material = new Material({
+      name: "PROPANE+N-BUTANE+N-PENTANE", 
+      components: [
+        new MaterialComponent({ name: "PROPANE", moleFraction: 0.1 }),
+        new MaterialComponent({ name: "N-BUTANE", moleFraction: 0.3 }),
+        new MaterialComponent({ name: "N-PENTANE", moleFraction: 0.6 })
+      ], 
+      componentCount: 3
+    });
+
+    // Create a load mass inventory vessel for leak scenario calculation using the material
+    const loadMassInventoryVesselForLeakScenarioCalculation = new LoadMassInventoryVesselForLeakScenarioCalculation(
+      material,
+      1e4,
+      6e5,
+      250,
+      0.08,
+      1.0,
+      0.0
+    );
+
+    // Run the calculation
+    console.log('Running load_mass_inventory_vessel_for_leak_scenario_calculation...');
+    const loadResultCode = await loadMassInventoryVesselForLeakScenarioCalculation.run();
+
+    // Print any messages
+    if (loadMassInventoryVesselForLeakScenarioCalculation.messages.length > 0) {
+      console.log('Messages:');
+      loadMassInventoryVesselForLeakScenarioCalculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(loadResultCode).toBe(ResultCode.SUCCESS);
+    
+    if (loadResultCode === ResultCode.SUCCESS) {
+      console.log(`SUCCESS: load_mass_inventory_vessel_for_leak_scenario_calculation (${loadMassInventoryVesselForLeakScenarioCalculation.calculationElapsedTime}ms)`);
+    }
+
+    // Define the weather conditions
+    const weather = new Weather({ 
+      windSpeed: 5.0, 
+      stabilityClass: AtmosphericStabilityClass.STABILITY_B, 
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE 
+    });
+
+    // Define the substrate
+    const substrate = new Substrate();
+
+    // Define the dispersion parameters
+    const dispersionParameters = [
+      new DispersionParameters({ averagingTime: 18.75 }), 
+      new DispersionParameters({ averagingTime: 18.75 })
+    ];
+
+    // Define the dispersion output configuration
+    const dispersionOutputConfigsFlammable = [
+      new DispersionOutputConfig({ 
+        specialConcentration: SpecialConcentration.LFL_FRACTION, 
+        elevation: 0.0 
+      })
+    ];
+    
+    const dispersionOutputConfigsToxic = [
+      new DispersionOutputConfig({ 
+        specialConcentration: SpecialConcentration.NOT_DEFINED, 
+        concentration: 5e-5, 
+        elevation: 0.0 
+      })
+    ];
+
+    // Define the flammable parameters
+    const flammableParameters = new FlammableParameters();
+
+    // Define the flammable output configuration
+    const flammableOutputConfigs = [new FlammableOutputConfig()];
+
+    // Define the explosion parameters
+    const explosionParameters = new ExplosionParameters();
+
+    // Define the explosion output configuration
+    const explosionOutputConfigs = [new ExplosionOutputConfig()];
+
+    // Define the explosion confined volumes
+    const explosionConfinedVolumes = [new ExplosionConfinedVolume()];
+
+    // Set mixture modeling to MC_MULTIPLE_AEROSOL
+    const vessel = loadMassInventoryVesselForLeakScenarioCalculation.vessel!;
+    vessel.state!.mixtureModelling = MixtureModelling.MC_MULTIPLE_AEROSOL;
+
+    // Create the vessel leak linked run calculation
+    const vesselLeakLinkedRunCalculation = new VesselLeakLinkedRunCalculation(
+      vessel,
+      loadMassInventoryVesselForLeakScenarioCalculation.leak!,
+      new DischargeParameters(),
+      substrate,
+      weather,
+      dispersionParameters,
+      dispersionParameters.length,
+      0.0,
+      flammableParameters,
+      explosionParameters,
+      dispersionOutputConfigsFlammable,
+      dispersionOutputConfigsFlammable.length,
+      dispersionOutputConfigsToxic,
+      dispersionOutputConfigsToxic.length,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length,
+      explosionOutputConfigs,
+      explosionOutputConfigs.length,
+      explosionConfinedVolumes,
+      explosionConfinedVolumes.length
+    );
+
+    // Run the calculation
+    console.log('Running vessel_leak_linked_run_calculation...');
+    const resultCode = await vesselLeakLinkedRunCalculation.run();
+
+    // Print any messages
+    if (vesselLeakLinkedRunCalculation.messages.length > 0) {
+      console.log('Messages:');
+      vesselLeakLinkedRunCalculation.messages.forEach((msg) => console.log(msg));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    if (resultCode === ResultCode.SUCCESS) {
+      // Check if the results match expected values within tolerance
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.dischargeRecord!.massFlow! - 79.92636564283663) / 79.92636564283663
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.jetFireFlameResult!.flameLength! - 77.05440102800145) / 77.05440102800145
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.poolFireFlameResult!.flameDiameter! - 41.782142639160156) / 41.782142639160156
+      ).toBeLessThan(1e-3);
+      
+      expect(vesselLeakLinkedRunCalculation.flamConcContourPoints!.length).toBe(601);
+      
+      expect(vesselLeakLinkedRunCalculation.toxicConcContourPoints!.length).toBe(693);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.areaFootprintFlamConc![0] - 11080.56953438209) / 11080.56953438209
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.areaFootprintToxicConc![0] - 445160.15045601147) / 445160.15045601147
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.areaContourJet![0] - 61978.79874189871) / 61978.79874189871
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.areaContourPool![0] - 14778.202000753792) / 14778.202000753792
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].explodedMass! - 680.3354816239089) / 680.3354816239089
+      ).toBeLessThan(1e-3);
+      
+      expect(
+        Math.abs(vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].maximumDistance! - 552.0412952025639) / 552.0412952025639
+      ).toBeLessThan(1e-3);
+
+      // Log key results
+      console.log(`Mass flow = ${vesselLeakLinkedRunCalculation.dischargeRecord!.massFlow}`);
+      console.log(`Flame length = ${vesselLeakLinkedRunCalculation.jetFireFlameResult!.flameLength}`);
+      console.log(`Flame diameter = ${vesselLeakLinkedRunCalculation.poolFireFlameResult!.flameDiameter}`);
+      console.log(`Length of the dispersion flammable contour array = ${vesselLeakLinkedRunCalculation.flamConcContourPoints!.length}`);
+      console.log(`Length of the dispersion toxic contour array = ${vesselLeakLinkedRunCalculation.toxicConcContourPoints!.length}`);
+      console.log(`Area of the flammable cloud = ${vesselLeakLinkedRunCalculation.areaFootprintFlamConc![0]}`);
+      console.log(`Area of the toxic cloud = ${vesselLeakLinkedRunCalculation.areaFootprintToxicConc![0]}`);
+      console.log(`Area of the jet fire = ${vesselLeakLinkedRunCalculation.areaContourJet![0]}`);
+      console.log(`Area of the pool = ${vesselLeakLinkedRunCalculation.areaContourPool![0]}`);
+      console.log(`Flammable mass = ${vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].explodedMass}`);
+      console.log(`Explosion maximum distance = ${vesselLeakLinkedRunCalculation.explosionOverpressureResults![0].maximumDistance}`);
+      
+      console.log(`SUCCESS: vessel_leak_linked_run_calculation (${vesselLeakLinkedRunCalculation.calculationElapsedTime}ms)`);
+    }
+  });
+});

package/tests/linked-runners/vessel-leak-linked-run/test-vl-159.test.ts

@@ -0,0 +1,158 @@
+import { VesselLeakLinkedRunCalculation } from "../../../src/calculations/linkedRunners";
+import { LoadMassInventoryVesselForLeakScenarioCalculation } from "../../../src/calculations/utilities";
+import { 
+  Material, MaterialComponent, Weather, Substrate, DischargeParameters,
+  FlammableParameters, DispersionParameters, ExplosionParameters,
+  ExplosionOutputConfig, ExplosionConfinedVolume, FlammableOutputConfig, 
+  DispersionOutputConfig 
+} from "../../../src/entities";
+import { 
+  ResultCode, AtmosphericStabilityClass, SpecialConcentration,
+  WindProfileFlag, MixtureModelling 
+} 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("VesselLeakLinkedRunCalculation - VLR_159", () => {
+  it("should run the calculation and validate regression outputs", async () => {
+    const material = new Material({
+      name: "H2S+N-BUTANE",
+      components: [
+        new MaterialComponent({ name: "HYDROGEN SULFIDE", moleFraction: 0.02 }),
+        new MaterialComponent({ name: "N-BUTANE", moleFraction: 0.98 })
+      ],
+      componentCount: 2
+    });
+
+    const loadCalc = new LoadMassInventoryVesselForLeakScenarioCalculation(
+      material,
+      1e4,     // mass
+      6e5,     // pressure
+      250,     // temperature
+      0.08,    // hole size
+      1.0,     // release elevation
+      0.0      // release angle
+    );
+
+    console.log("Running load_mass_inventory_vessel_for_leak_scenario_calculation...");
+    const loadResult = await loadCalc.run();
+
+    if (loadCalc.messages.length > 0) {
+      console.log("Messages:");
+      loadCalc.messages.forEach(msg => console.log(msg));
+    }
+
+    expect(loadResult).toBe(ResultCode.SUCCESS);
+
+    if (loadResult === ResultCode.SUCCESS) {
+      console.log(`SUCCESS: load_mass_inventory_vessel_for_leak_scenario_calculation (${loadCalc.calculationElapsedTime}ms)`);
+    }
+
+    const weather = new Weather({
+      windSpeed: 5.0,
+      stabilityClass: AtmosphericStabilityClass.STABILITY_B,
+      windProfileFlag: WindProfileFlag.LOGARITHMIC_PROFILE
+    });
+
+    const substrate = new Substrate();
+
+    const dispersionParams = [
+      new DispersionParameters({ averagingTime: 18.75 }),
+      new DispersionParameters({ averagingTime: 18.75 })
+    ];
+
+    const flamOutputConfigs = [
+      new DispersionOutputConfig({
+        specialConcentration: SpecialConcentration.LFL_FRACTION,
+        elevation: 0.0
+      })
+    ];
+
+    const toxicOutputConfigs = [
+      new DispersionOutputConfig({
+        specialConcentration: SpecialConcentration.NOT_DEFINED,
+        concentration: 5e-5,
+        elevation: 0.0
+      })
+    ];
+
+    const flammableParams = new FlammableParameters();
+    const flammableOutputConfigs = [new FlammableOutputConfig()];
+    const explosionParams = new ExplosionParameters();
+    const explosionOutputConfigs = [new ExplosionOutputConfig()];
+    const confinedVolumes = [new ExplosionConfinedVolume()];
+
+    const vessel = loadCalc.vessel!;
+    vessel.state!.mixtureModelling = MixtureModelling.MC_MULTIPLE_AEROSOL;
+
+    const vlrCalc = new VesselLeakLinkedRunCalculation(
+      vessel,
+      loadCalc.leak!,
+      new DischargeParameters(),
+      substrate,
+      weather,
+      dispersionParams,
+      dispersionParams.length,
+      0.0,
+      flammableParams,
+      explosionParams,
+      flamOutputConfigs,
+      flamOutputConfigs.length,
+      toxicOutputConfigs,
+      toxicOutputConfigs.length,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length,
+      explosionOutputConfigs,
+      explosionOutputConfigs.length,
+      confinedVolumes,
+      confinedVolumes.length
+    );
+
+    console.log("Running vessel_leak_linked_run_calculation...");
+    const result = await vlrCalc.run();
+
+    if (vlrCalc.messages.length > 0) {
+      console.log("Messages:");
+      vlrCalc.messages.forEach(msg => console.log(msg));
+    }
+
+    expect(result).toBe(ResultCode.SUCCESS);
+
+    if (result === ResultCode.SUCCESS) {
+      const relErr = (actual: number, expected: number) => Math.abs(actual - expected) / expected;
+
+      expect(relErr(vlrCalc.dischargeRecord!.massFlow!, 78.2703129718767)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.jetFireFlameResult!.flameLength!, 79.83450740611565)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.poolFireFlameResult!.flameDiameter!, 40.45197677612305)).toBeLessThan(1e-3);
+      expect(vlrCalc.flamConcContourPoints!.length).toBe(593);
+      expect(vlrCalc.toxicConcContourPoints!.length).toBe(695);
+      expect(relErr(vlrCalc.areaFootprintFlamConc![0], 11956.182247202978)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.areaFootprintToxicConc![0], 508942.11044945125)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.areaContourJet![0], 59421.0918161459)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.areaContourPool![0], 89742.0801748534)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.explosionOverpressureResults![0].explodedMass!, 599.1546378493579)).toBeLessThan(1e-3);
+      expect(relErr(vlrCalc.explosionOverpressureResults![0].maximumDistance!, 536.4452979306577)).toBeLessThan(1e-3);
+
+      // Logs
+      console.log(`Mass flow = ${vlrCalc.dischargeRecord!.massFlow}`);
+      console.log(`Flame length = ${vlrCalc.jetFireFlameResult!.flameLength}`);
+      console.log(`Flame diameter = ${vlrCalc.poolFireFlameResult!.flameDiameter}`);
+      console.log(`Flammable contour points = ${vlrCalc.flamConcContourPoints!.length}`);
+      console.log(`Toxic contour points = ${vlrCalc.toxicConcContourPoints!.length}`);
+      console.log(`Area flammable cloud = ${vlrCalc.areaFootprintFlamConc![0]}`);
+      console.log(`Area toxic cloud = ${vlrCalc.areaFootprintToxicConc![0]}`);
+      console.log(`Area jet fire = ${vlrCalc.areaContourJet![0]}`);
+      console.log(`Area pool fire = ${vlrCalc.areaContourPool![0]}`);
+      console.log(`Exploded mass = ${vlrCalc.explosionOverpressureResults![0].explodedMass}`);
+      console.log(`Explosion max distance = ${vlrCalc.explosionOverpressureResults![0].maximumDistance}`);
+      console.log(`SUCCESS: vessel_leak_linked_run_calculation (${vlrCalc.calculationElapsedTime}ms)`);
+    }
+  });
+});