heatingpro-efficiency-package 1.0.8 → 1.0.9

package/index.js

@@ -1,133 +1,109 @@
 const {
   hasPropertiesAndNotDash,
   toFloatWithDot,
-  convertHeatToKwh,
+  convertHeatToGj,
 } = require("./utils/index.js");
 
+// Convert a heat-meter reading (in its column unit) to GJ.
+// Unknown / missing unit falls back to GJ to preserve legacy behaviour
+// for boilers configured before per-column units existed.
+const heatValueToGj = (value, fieldName, fieldUnits) => {
+  const unit = fieldUnits[fieldName];
+  if (!unit) return value; // legacy: assume already GJ
+  try {
+    return convertHeatToGj(value, unit);
+  } catch (_) {
+    return value;
+  }
+};
+
 const computeEfficiency = (
   row,
   prevRow,
   monthlyEffectivityConstant,
   fieldUnits = {}
 ) => {
-  // Helper function to convert MWh to GJ if needed
-  const convertValue = (value, fieldName) => {
-    if (fieldUnits[fieldName] === "mwh") {
-      return value * 3.6; // Convert MWh to GJ
-    }
-    return value;
-  };
-
-  let sumOfDiffs = 0;
+  let sumOfDiffsGj = 0;
   let hasNegativeDiff = false;
-  let totalPreviousHeat = 0;
-
-  for (let i = 1; i <= 8; i++) {
-    const voKey = `VO${i}`;
-
-    if (hasPropertiesAndNotDash(row, prevRow, voKey)) {
-      const currentVal = toFloatWithDot(row[voKey]);
-      const prevVal = toFloatWithDot(prevRow[voKey]);
-
-      // Convert values if they are in MWh
-      const convertedCurrentVal = convertValue(currentVal, voKey);
-      const convertedPrevVal = convertValue(prevVal, voKey);
-
-      const diff = convertedCurrentVal - convertedPrevVal;
-
-      if (!isNaN(diff)) {
-        if (diff < 0) {
-          hasNegativeDiff = true;
-        }
-        totalPreviousHeat += convertedPrevVal;
-        sumOfDiffs += diff;
-      }
-    }
-  }
-
-  if (hasPropertiesAndNotDash(row, prevRow, "MT TUV")) {
-    const currentVal = toFloatWithDot(row["MT TUV"]);
-    const prevVal = toFloatWithDot(prevRow["MT TUV"]);
-
-    // Convert values if they are in MWh
-    const convertedCurrentVal = convertValue(currentVal, "MT TUV");
-    const convertedPrevVal = convertValue(prevVal, "MT TUV");
-
-    const diff = convertedCurrentVal - convertedPrevVal;
-
-    if (!isNaN(diff)) {
-      if (diff < 0) {
-        hasNegativeDiff = true;
-      }
-      totalPreviousHeat += convertedPrevVal;
-      sumOfDiffs += diff;
-    }
-  }
+  let totalPreviousHeatGj = 0;
+
+  const accumulateHeat = (key) => {
+    if (!hasPropertiesAndNotDash(row, prevRow, key)) return;
+    const currentGj = heatValueToGj(toFloatWithDot(row[key]), key, fieldUnits);
+    const prevGj = heatValueToGj(toFloatWithDot(prevRow[key]), key, fieldUnits);
+    const diff = currentGj - prevGj;
+    if (isNaN(diff)) return;
+    if (diff < 0) hasNegativeDiff = true;
+    totalPreviousHeatGj += prevGj;
+    sumOfDiffsGj += diff;
+  };
 
-  // Detect heat meter reset: negative difference that's significant (> 50% of previous total)
-  // This indicates the meter was reset (current reading < previous reading by a large margin)
-  const isHeatMeterReset = hasNegativeDiff && totalPreviousHeat > 0 && sumOfDiffs < 0 && Math.abs(sumOfDiffs) > totalPreviousHeat * 0.5;
+  for (let i = 1; i <= 8; i++) accumulateHeat(`VO${i}`);
+  accumulateHeat("MT TUV");
 
-  const gasDiff = toFloatWithDot(row["Plyn"]) - toFloatWithDot(prevRow["Plyn"]);
+  // Heat-meter reset: large aggregate negative diff (>50% of prev total).
+  const isHeatMeterReset =
+    hasNegativeDiff &&
+    totalPreviousHeatGj > 0 &&
+    sumOfDiffsGj < 0 &&
+    Math.abs(sumOfDiffsGj) > totalPreviousHeatGj * 0.5;
 
-  // Handle gas meter reset: if current reading is significantly less than previous,
-  // it's likely a meter reset. A reset is detected when current < previous AND 
-  // the difference is large (> 50% of previous value)
+  const gasDiff =
+    toFloatWithDot(row["Plyn"]) - toFloatWithDot(prevRow["Plyn"]);
   const prevGasValue = toFloatWithDot(prevRow["Plyn"]);
-  const isGasMeterReset = gasDiff < 0 && prevGasValue > 0 && Math.abs(gasDiff) > prevGasValue * 0.5;
-
-  // Convert heat to kWh based on input units (always GJ now since we converted above)
-  const voDiffInKwh = convertHeatToKwh(sumOfDiffs, "GJ");
-  const gasDiffInKwh = gasDiff * 9.855; // 1 m³ gas = 9.855 kWh (Method 2)
+  const isGasMeterReset =
+    gasDiff < 0 &&
+    prevGasValue > 0 &&
+    Math.abs(gasDiff) > prevGasValue * 0.5;
+
+  // Heat in kWh (1 GJ = 1000/3.6 kWh).
+  const heatDiffInKwh = sumOfDiffsGj * (1000 / 3.6);
+
+  // Gas in kWh. monthlyEffectivityConstant is the natural-gas calorific value
+  // for that month in kWh/m³ (typical ~10.8–11.0). If the gas meter is already
+  // configured in kWh, use the raw kWh diff and ignore the constant for unit
+  // purposes — but the constant must still be a valid positive number so we
+  // refuse to compute on missing data, matching prior behaviour.
+  const gasUnit = String(fieldUnits["Plyn"] || "m3").toLowerCase();
+  const gasDiffInKwh = gasUnit === "kwh" ? gasDiff : gasDiff * monthlyEffectivityConstant;
 
   let efficiency;
 
-  // Handle different scenarios for efficiency calculation
   if (isGasMeterReset || isHeatMeterReset) {
-    // Meter reset detected - cannot calculate efficiency reliably
     efficiency = "-";
   } else if (gasDiff <= 0) {
-    // Negative or zero gas consumption - invalid
     if (gasDiff < 0) {
-      // Negative gas difference indicates meter reset or data error
       efficiency = "-";
-    } else if (sumOfDiffs === 0) {
-      // No consumption at all - no meaningful efficiency
+    } else if (sumOfDiffsGj === 0) {
       efficiency = "-";
     } else {
-      // Heat produced without gas consumption - invalid scenario
       efficiency = "-";
     }
-  } else if (sumOfDiffs <= 0) {
-    // Negative or zero heat production
-    if (sumOfDiffs < 0) {
-      // Negative heat difference indicates meter reset or data error
+  } else if (sumOfDiffsGj <= 0) {
+    if (sumOfDiffsGj < 0) {
       efficiency = "-";
     } else {
-      // Gas consumed but no heat produced - 0% efficiency
       efficiency = "0.0000";
     }
-  } else if (monthlyEffectivityConstant <= 0 || isNaN(monthlyEffectivityConstant)) {
-    // Invalid effectivity constant
+  } else if (
+    monthlyEffectivityConstant <= 0 ||
+    isNaN(monthlyEffectivityConstant)
+  ) {
     efficiency = "-";
   } else {
-    // Normal calculation: efficiency = (heat output / (gas input * constant))
-    // Returns decimal value (e.g., 0.88 for 88%) - will be multiplied by 100 in display code
-    const calculatedEfficiency = voDiffInKwh / (gasDiffInKwh * monthlyEffectivityConstant);
-    
-    // Validate result: efficiency should be reasonable
-    // Check for NaN, Infinity, or negative values
-    // Note: Upper bound removed as efficiency can vary based on effectivityConstant value
-    if (isNaN(calculatedEfficiency) || !isFinite(calculatedEfficiency) || calculatedEfficiency < 0) {
+    const calculatedEfficiency = heatDiffInKwh / gasDiffInKwh;
+    if (
+      isNaN(calculatedEfficiency) ||
+      !isFinite(calculatedEfficiency) ||
+      calculatedEfficiency < 0
+    ) {
       efficiency = "-";
     } else {
       efficiency = Number(calculatedEfficiency).toFixed(4);
     }
   }
 
-  // Return heat units value (always in GJ for display)
-  // Make sure we don't return NaN
-  const heatUnitsValue = isNaN(sumOfDiffs) ? 0 : sumOfDiffs;
+  const heatUnitsValue = isNaN(sumOfDiffsGj) ? 0 : sumOfDiffsGj;
 
   return {
     ...row,
@@ -136,29 +112,13 @@ const computeEfficiency = (
   };
 };
 
-/**
- * Checks if heat meters are being written off (have valid readings and differences)
- * @param {Array} valuesData - Array of row data objects
- * @param {Object} fieldUnits - Mapping of field names to their units
- * @returns {boolean} - True if meters exist and are being written off, false otherwise
- */
 const areMetersBeingWrittenOff = (valuesData, fieldUnits = {}) => {
   if (!valuesData || valuesData.length < 2) {
     return false;
   }
 
-  // Helper function to convert MWh to GJ if needed
-  const convertValue = (value, fieldName) => {
-    if (fieldUnits[fieldName] === "mwh") {
-      return value * 3.6; // Convert MWh to GJ
-    }
-    return value;
-  };
-
-  // First, check if meters exist (have non-dash values in any row)
   let metersExist = false;
   for (const row of valuesData) {
-    // Check VO1-VO8 meters
     for (let j = 1; j <= 8; j++) {
       const voKey = `VO${j}`;
       if (
@@ -172,7 +132,6 @@ const areMetersBeingWrittenOff = (valuesData, fieldUnits = {}) => {
         break;
       }
     }
-    // Check MT TUV meter
     if (
       row.hasOwnProperty("MT TUV") &&
       row["MT TUV"] !== "-" &&
@@ -185,60 +144,31 @@ const areMetersBeingWrittenOff = (valuesData, fieldUnits = {}) => {
     if (metersExist) break;
   }
 
-  // If meters don't exist, return false
   if (!metersExist) {
     return false;
   }
 
-  // Check if there are any valid meter readings with differences across rows
   for (let i = 1; i < valuesData.length; i++) {
     const row = valuesData[i];
     const prevRow = valuesData[i - 1];
     let sumOfDiffs = 0;
 
-    // Check VO1-VO8 meters
-    for (let j = 1; j <= 8; j++) {
-      const voKey = `VO${j}`;
-
-      if (hasPropertiesAndNotDash(row, prevRow, voKey)) {
-        const currentVal = toFloatWithDot(row[voKey]);
-        const prevVal = toFloatWithDot(prevRow[voKey]);
-
-        // Convert values if they are in MWh
-        const convertedCurrentVal = convertValue(currentVal, voKey);
-        const convertedPrevVal = convertValue(prevVal, voKey);
-
-        const diff = convertedCurrentVal - convertedPrevVal;
-
-        if (!isNaN(diff) && diff !== 0) {
-          sumOfDiffs += Math.abs(diff);
-        }
-      }
-    }
+    const tally = (key) => {
+      if (!hasPropertiesAndNotDash(row, prevRow, key)) return;
+      const cur = heatValueToGj(toFloatWithDot(row[key]), key, fieldUnits);
+      const prev = heatValueToGj(toFloatWithDot(prevRow[key]), key, fieldUnits);
+      const diff = cur - prev;
+      if (!isNaN(diff) && diff !== 0) sumOfDiffs += Math.abs(diff);
+    };
 
-    // Check MT TUV meter
-    if (hasPropertiesAndNotDash(row, prevRow, "MT TUV")) {
-      const currentVal = toFloatWithDot(row["MT TUV"]);
-      const prevVal = toFloatWithDot(prevRow["MT TUV"]);
-
-      // Convert values if they are in MWh
-      const convertedCurrentVal = convertValue(currentVal, "MT TUV");
-      const convertedPrevVal = convertValue(prevVal, "MT TUV");
-
-      const diff = convertedCurrentVal - convertedPrevVal;
-
-      if (!isNaN(diff) && diff !== 0) {
-        sumOfDiffs += Math.abs(diff);
-      }
-    }
+    for (let j = 1; j <= 8; j++) tally(`VO${j}`);
+    tally("MT TUV");
 
-    // If we found any non-zero difference, meters are being written off
     if (sumOfDiffs > 0) {
       return true;
     }
   }
 
-  // Meters exist but no differences found (not being written off yet)
   return false;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heatingpro-efficiency-package",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Utility functions for MonitoringPro efficiency calculations with flexible unit support (GJ, kWh, MWh)",
   "main": "index.js",
   "scripts": {

package/utils/index.js

@@ -11,21 +11,48 @@ const hasPropertiesAndNotDash = (a, b, key) =>
   a[key] !== "-" &&
   b[key] !== "-";
 
-const convertHeatToKwh = (value, fromUnit) => {
-  const unit = fromUnit.toLowerCase();
+// Heat-energy conversion factors → GJ.
+// Source values are exact where physically exact (e.g. 1 MWh = 3.6 GJ);
+// kcal uses 1 cal = 4.184 J (thermochemical) for consistency with EU practice.
+const HEAT_TO_GJ = {
+  kj: 1e-6,
+  mj: 1e-3,
+  gj: 1,
+  kwh: 3.6e-3,
+  mwh: 3.6,
+  gwh: 3600,
+  kcal: 4.184e-6,
+  mcal: 4.184e-3,
+  gcal: 4.184,
+};
 
-  switch (unit) {
-    case "gj":
-      return value * 277.778; // 1 GJ = 277.778 kWh
-    case "kwh":
-      return value; // Already in kWh
-    case "mwh":
-      return value * 1000; // 1 MWh = 1000 kWh
-    default:
-      throw new Error(
-        `Unsupported heat unit: ${fromUnit}. Supported units: GJ, kWh, MWh`
-      );
+const convertHeatToGj = (value, fromUnit) => {
+  const unit = String(fromUnit || "gj").toLowerCase();
+  const factor = HEAT_TO_GJ[unit];
+  if (factor === undefined) {
+    throw new Error(
+      `Unsupported heat unit: ${fromUnit}. Supported: ${Object.keys(HEAT_TO_GJ)
+        .map((u) => u.toUpperCase())
+        .join(", ")}`
+    );
   }
+  return value * factor;
+};
+
+const convertHeatToKwh = (value, fromUnit) => {
+  const unit = String(fromUnit || "").toLowerCase();
+  // Short-circuit exact-unit cases to avoid float round-trip.
+  if (unit === "kwh") return value;
+  if (unit === "mwh") return value * 1000;
+  if (unit === "gwh") return value * 1_000_000;
+  // 1 GJ ≡ 1000 / 3.6 kWh ≈ 277.7778. Route through GJ for everything else.
+  return convertHeatToGj(value, fromUnit) * (1000 / 3.6);
 };
 
-module.exports = { toFloatWithDot, hasPropertiesAndNotDash, convertHeatToKwh };
+module.exports = {
+  toFloatWithDot,
+  hasPropertiesAndNotDash,
+  convertHeatToGj,
+  convertHeatToKwh,
+  HEAT_TO_GJ,
+};