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

package/tests/radiation-at-ponts/testCase70.test.ts

@@ -0,0 +1,179 @@
+import { VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { RadiationAtPointsCalculation } from "../../src/calculations/radiation";
+import { State, Material, MaterialComponent, Vessel, Leak, DischargeParameters, Weather, Substrate, FlammableParameters, FlammableOutputConfig, Transect, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, 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("RadiationAtPointsCalculation Integration - Test Case 70", () => {
+  test("should produce correct radiation results for N-BUTANE", async () => {
+    const materialName = 'N-BUTANE';
+    const stateTemperature = 220.0;
+    const statePressure = 1.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.5;
+    const liquidFillFraction = 0.5;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.HIGH;
+    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 vesselStateCalc = new VesselStateCalculation(material, state);
+    console.log("Running vessel_state_calculation...");
+    let resultCode = await vesselStateCalc.run();
+
+    // Check if there are any messages
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the vessel state calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_state_calculation (${vesselStateCalc.calculationElapsedTime}ms)`);
+
+    // Create a vessel to use in the leak calculation using the previously defined entities
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition(),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFraction,
+    });
+
+    // Create a leak to use in the vessel leak calculation
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Create discharge parameters for the vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+
+    // Create a vessel leak calculation using the vessel, leak, and discharge parameters
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+    console.log("Running vessel_leak_calculation...");
+    resultCode = await vesselLeakCalc.run();
+
+    // Check if there are any messages
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the vessel leak calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: vessel_leak_calculation (${vesselLeakCalc.calculationElapsedTime}ms)`);
+
+    // Instantiate the data required by the jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+      windProfileFlag: windProfileFlag
+    });
+    const substrate = new Substrate();
+    const flammableParams = new FlammableParameters({ timeOfInterest });
+
+    // Create a jet fire calculation using the required input data
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+    console.log("Running jet_fire_calculation...");
+    resultCode = await jetFireCalc.run();
+
+    // Check if there are any messages
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the jet fire calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    console.log(`SUCCESS: jet_fire_calculation (${jetFireCalc.calculationElapsedTime}ms)`);
+
+    // Create flammable output configurations
+    const flammableOutputConfigs = [
+      { x: 30.0, y: 0.0, z: 2.0 },
+      { x: 30.0, y: 0.0, z: 4.0 },
+      { x: 30.0, y: 0.0, z: 5.0 },
+    ].map(({ x, y, z }) => {
+      return new FlammableOutputConfig({
+        position: new LocalPosition({ x, y, z }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition(),
+          transectEndPoint: new LocalPosition(),
+        }),
+        radiationResolution: radiationResolution,
+      });
+    });
+
+    // Create a radiation at points calculation using the flame result, flame records, weather, flammable parameters, and flammable output configurations
+    const radiationAtPointsCalc = new RadiationAtPointsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    // Run the radiation at points calculation
+    console.log("Running radiation_at_points_calculation...");
+    resultCode = await radiationAtPointsCalc.run();
+
+    // Check if there are any messages
+    if (radiationAtPointsCalc.messages.length > 0) {
+      console.log("Messages:");
+      radiationAtPointsCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the radiation at points calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    const radiationResult = radiationAtPointsCalc.radiation![0];
+    const expectedRadiation = 243947.48369382767;
+    const radiationTolerance = 1e-3;
+    expect(Math.abs((radiationResult - expectedRadiation) / expectedRadiation)).toBeLessThan(radiationTolerance);
+
+    const flameLength = radiationAtPointsCalc.flameResult.flameLength!;
+    const expectedFlameLength = 138.4978616734956;
+    expect(Math.abs((flameLength - expectedFlameLength) / expectedFlameLength)).toBeLessThan(radiationTolerance);
+
+    console.log(`SUCCESS: radiation_at_points_calculation (${radiationAtPointsCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/radiation-at-ponts/testCase71.test.ts

@@ -0,0 +1,150 @@
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { RadiationAtPointsCalculation } from "../../src/calculations/radiation";
+import { VesselLeakCalculation, VesselStateCalculation } from "../../src/calculations/discharge";
+import { State, Material, MaterialComponent, Vessel, Leak, DischargeParameters, Weather, Substrate, FlammableParameters, FlammableOutputConfig, Transect, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, 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("RadiationAtPointsCalculation Integration - Test Case 71", () => {
+  test("should produce correct radiation results for PROPANE", async () => {
+    const materialName = "PROPANE";
+    const stateTemperature = 290.0;
+    const statePressure = 5.0e5;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.3;
+    const liquidFillFraction = 0.4;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.LOW;
+    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 vesselStateCalc = new VesselStateCalculation(material, state);
+    let resultCode = await vesselStateCalc.run();
+
+    // Validate the result of the vessel state calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    if (vesselStateCalc.messages.length > 0) {
+      vesselStateCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Create a vessel for leak calculation
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition(),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFraction,
+    });
+
+    // Create a leak for vessel leak calculation
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Create discharge parameters
+    const dischargeParams = new DischargeParameters();
+
+    // Create a vessel leak calculation
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+    resultCode = await vesselLeakCalc.run();
+
+    // Validate the result of the vessel leak calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    if (vesselLeakCalc.messages.length > 0) {
+      vesselLeakCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Instantiate the data required for jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+      windProfileFlag: windProfileFlag,
+    });
+    const substrate = new Substrate();
+    const flammableParams = new FlammableParameters({ timeOfInterest: timeOfInterest });
+
+    // Create a jet fire calculation
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+    resultCode = await jetFireCalc.run();
+
+    // Validate the result of the jet fire calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+    if (jetFireCalc.messages.length > 0) {
+      jetFireCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Create flammable output configurations
+    const flammableOutputConfigs = [
+      { x: 0.0, y: 60.0, z: 2.0 },
+      { x: 0.0, y: -60.0, z: 3.0 },
+      { x: 0.0, y: 60.0, z: 6.0 },
+    ].map(({ x, y, z }) => {
+      return new FlammableOutputConfig({
+        position: new LocalPosition({ x, y, z }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition(),
+          transectEndPoint: new LocalPosition(),
+        }),
+        radiationResolution: radiationResolution,
+      });
+    });
+
+    // Create a radiation at points calculation
+    const radiationAtPointsCalc = new RadiationAtPointsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+    resultCode = await radiationAtPointsCalc.run();
+
+    // Validate the result of the radiation at points calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Check for regression values in radiation at points
+    expect(Math.abs((radiationAtPointsCalc.radiation![0] - 1371.8130321119306) / 1371.8130321119306)).toBeLessThan(1e-3);
+    expect(Math.abs((radiationAtPointsCalc.flameResult.flameLength! - 31.712372512867706) / 31.712372512867706)).toBeLessThan(1e-3);
+
+    console.log(`SUCCESS: radiation_at_points_calculation (${radiationAtPointsCalc.calculationElapsedTime}ms)`);
+  });
+});

package/tests/radiation-at-ponts/testCase72.test.ts

@@ -0,0 +1,166 @@
+import { VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { RadiationAtPointsCalculation } from "../../src/calculations/radiation";
+import { State, Material, MaterialComponent, Vessel, Leak, DischargeParameters, Weather, Substrate, FlammableParameters, FlammableOutputConfig, Transect, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, Resolution, ResultCode, 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("RadiationAtPointsCalculation Integration - Test Case 72", () => {
+  test("should produce correct radiation results for ETHANE_METHANE_HYDROGEN", async () => {
+    const materialName = "ETHANE_METHANE_HYDROGEN";
+    const stateTemperature = 360.0;
+    const statePressure = 3.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.3;
+    const liquidFillFraction = 0.4;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.EXTREME;
+    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: "ETHANE", moleFraction: 0.5 }),
+        new MaterialComponent({ name: "METHANE", moleFraction: 0.3 }),
+        new MaterialComponent({ name: "HYDROGEN", moleFraction: 0.2 }),
+      ],
+      componentCount: 3,
+    });
+
+    // Create a vessel state calculation using the material and state
+    const vesselStateCalc = new VesselStateCalculation(material, state);
+    let resultCode = await vesselStateCalc.run();
+
+    // Check if there are any messages
+    if (vesselStateCalc.messages.length > 0) {
+      vesselStateCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the vessel state calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create a vessel to use in the leak calculation using the previously defined entities
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition(),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFraction,
+    });
+
+    // Create a leak to use in the vessel leak calculation
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Create discharge parameters for the vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+
+    // Create a vessel leak calculation using the vessel, leak, and discharge parameters
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+    resultCode = await vesselLeakCalc.run();
+
+    // Check if there are any messages
+    if (vesselLeakCalc.messages.length > 0) {
+      vesselLeakCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the vessel leak calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Instantiate the data required by the jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+      windProfileFlag: windProfileFlag
+    });
+    const substrate = new Substrate();
+    const flammableParams = new FlammableParameters({ timeOfInterest });
+
+    // Create a jet fire calculation using the required input data
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+    resultCode = await jetFireCalc.run();
+
+    // Check if there are any messages
+    if (jetFireCalc.messages.length > 0) {
+      jetFireCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the jet fire calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create flammable output configurations
+    const flammableOutputConfigs = [
+      { x: 10.0, y: 0.0, z: 2.0 },
+      { x: 50.0, y: 0.0, z: 2.0 },
+      { x: 100.0, y: 0.0, z: 2.0 },
+    ].map(({ x, y, z }) => {
+      return new FlammableOutputConfig({
+        position: new LocalPosition({ x, y, z }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition(),
+          transectEndPoint: new LocalPosition(),
+        }),
+        radiationResolution: radiationResolution,
+      });
+    });
+
+    // Create a radiation at points calculation using the flame result, flame records, weather, flammable parameters, and flammable output configurations
+    const radiationAtPointsCalc = new RadiationAtPointsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    // Run the radiation at points calculation
+    resultCode = await radiationAtPointsCalc.run();
+
+    // Check if there are any messages
+    if (radiationAtPointsCalc.messages.length > 0) {
+      radiationAtPointsCalc.messages.forEach((message) => console.log(message));
+    }
+
+    // Validate the result of the radiation at points calculation
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Validate radiation values
+    expect(Math.abs((radiationAtPointsCalc.radiation![0] - 13665.167199336202) / 13665.167199336202)).toBeLessThan(1e-3);
+    expect(Math.abs((radiationAtPointsCalc.flameResult.flameLength! - 52.44271020259119) / 52.44271020259119)).toBeLessThan(1e-3);
+  });
+});

package/tests/radiation-at-ponts/testCase73.test.ts

@@ -0,0 +1,169 @@
+import { VesselStateCalculation, VesselLeakCalculation } from "../../src/calculations/discharge";
+import { JetFireCalculation } from "../../src/calculations/jetFire";
+import { RadiationAtPointsCalculation } from "../../src/calculations/radiation";
+import { State, Material, MaterialComponent, Vessel, Leak, DischargeParameters, Weather, Substrate, FlammableParameters, FlammableOutputConfig, Transect, LocalPosition } from "../../src/entities";
+import { AtmosphericStabilityClass, ResultCode, Resolution, 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("RadiationAtPointsCalculation Integration - Test Case 73", () => {
+  test("should produce correct radiation results for N-BUTANE", async () => {
+    const materialName = "N-BUTANE";
+    const stateTemperature = 360.0;
+    const statePressure = 3.0e6;
+    const vesselShape = VesselShape.VESSEL_SPHERE;
+    const vesselDiameter = 3.0;
+    const leakHoleDiameter = 0.1;
+    const timeVaryingOption = TimeVaryingOption.INITIAL_RATE;
+    const leakHoleHeightFraction = 0.3;
+    const liquidFillFraction = 0.4;
+    const windSpeed = 2.0;
+    const stabilityClass = AtmosphericStabilityClass.STABILITY_F;
+    const timeOfInterest = 2600.0;
+    const radiationResolution = Resolution.EXTREME;
+    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 vesselStateCalc = new VesselStateCalculation(material, state);
+    console.log("Running vessel_state_calculation...");
+    let resultCode = await vesselStateCalc.run();
+
+    // Check if there are any messages
+    if (vesselStateCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselStateCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create a vessel to use in the leak calculation using the previously defined entities
+    const vessel = new Vessel({
+      state: vesselStateCalc.outputState,
+      material: vesselStateCalc.material,
+      vesselConditions: vesselStateCalc.vesselConditions,
+      location: new LocalPosition(),
+      diameter: vesselDiameter,
+      shape: vesselShape,
+      liquidFillFractionByVolume: liquidFillFraction,
+    });
+
+    // Create a leak to use in the vessel leak calculation
+    const leak = new Leak({
+      holeDiameter: leakHoleDiameter,
+      holeHeightFraction: leakHoleHeightFraction,
+      timeVaryingOption: timeVaryingOption,
+    });
+
+    // Create discharge parameters for the vessel leak calculation
+    const dischargeParams = new DischargeParameters();
+
+    // Create a vessel leak calculation using the vessel, leak, and discharge parameters
+    const vesselLeakCalc = new VesselLeakCalculation(vessel, leak, dischargeParams);
+    console.log("Running vessel_leak_calculation...");
+    resultCode = await vesselLeakCalc.run();
+
+    // Check if there are any messages
+    if (vesselLeakCalc.messages.length > 0) {
+      console.log("Messages:");
+      vesselLeakCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Instantiate the data required by the jet fire calculation
+    const weather = new Weather({
+      windSpeed: windSpeed,
+      stabilityClass: stabilityClass,
+      windProfileFlag: windProfileFlag,
+    });
+
+    const substrate = new Substrate();
+    const flammableParams = new FlammableParameters({ timeOfInterest });
+
+    // Create a jet fire calculation using the required input data
+    const jetFireCalc = new JetFireCalculation(
+      vesselLeakCalc.exitMaterial!,
+      vesselLeakCalc.dischargeRecords!,
+      vesselLeakCalc.dischargeRecords!.length,
+      vesselLeakCalc.dischargeResult!,
+      weather,
+      substrate,
+      flammableParams
+    );
+    console.log("Running jet_fire_calculation...");
+    resultCode = await jetFireCalc.run();
+
+    // Check if there are any messages
+    if (jetFireCalc.messages.length > 0) {
+      console.log("Messages:");
+      jetFireCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Create flammable output configurations
+    const flammableOutputConfigs = [
+      { x: 5.0, y: 0.0, z: 0.0 },
+      { x: 20.0, y: 0.0, z: 0.0 },
+      { x: 20.0, y: 0.0, z: 1.0 },
+      { x: 20.0, y: 5.0, z: 1.0 },
+    ].map(({ x, y, z }) => {
+      return new FlammableOutputConfig({
+        position: new LocalPosition({ x, y, z }),
+        transect: new Transect({
+          transectStartPoint: new LocalPosition(),
+          transectEndPoint: new LocalPosition(),
+        }),
+        radiationResolution: radiationResolution,
+      });
+    });
+
+    // Create a radiation at points calculation using the flame result, flame records, weather, flammable parameters, and flammable output configurations
+    const radiationAtPointsCalc = new RadiationAtPointsCalculation(
+      jetFireCalc.flameResult!,
+      jetFireCalc.flameRecords!,
+      jetFireCalc.flameRecords!.length,
+      weather,
+      jetFireCalc.flammableParameters,
+      flammableOutputConfigs,
+      flammableOutputConfigs.length
+    );
+
+    // Run the radiation at points calculation
+    console.log("Running radiation_at_points_calculation...");
+    resultCode = await radiationAtPointsCalc.run();
+
+    // Check if there are any messages
+    if (radiationAtPointsCalc.messages.length > 0) {
+      console.log("Messages:");
+      radiationAtPointsCalc.messages.forEach((message) => console.log(message));
+    }
+
+    expect(resultCode).toBe(ResultCode.SUCCESS);
+
+    // Validate the radiation result
+    expect(radiationAtPointsCalc.radiation![0]).toBeCloseTo(350000.0, 3);
+    expect(radiationAtPointsCalc.flameResult.flameLength).toBeCloseTo(140.8483651650435, 3);
+
+    console.log(`SUCCESS: radiation_at_points_calculation (${radiationAtPointsCalc.calculationElapsedTime}ms)`);
+  });
+});