heatingpro-efficiency-package 1.0.8

package/README.md

@@ -0,0 +1,86 @@
+# MonitoringPro Utils
+
+Utility functions for MonitoringPro efficiency calculations with flexible unit support.
+
+## Installation
+
+```bash
+npm install heatingpro-efficiency
+```
+
+## Usage
+
+```javascript
+const { computeEfficiency, areMetersBeingWrittenOff } = require('heatingpro-efficiency');
+
+// Compute efficiency for data in GJ (default)
+const result1 = computeEfficiency(row, prevRow, monthlyEffectivityConstant);
+
+// Compute efficiency with field units mapping
+const result2 = computeEfficiency(row, prevRow, monthlyEffectivityConstant, fieldUnits);
+
+// Check if meters are being written off
+const metersActive = areMetersBeingWrittenOff(valuesData, fieldUnits);
+```
+
+## Functions
+
+### `computeEfficiency(row, prevRow, monthlyEffectivityConstant, fieldUnits)`
+
+Computes efficiency based on heat meter readings and gas consumption.
+
+**Parameters:**
+- `row` - Current row data object
+- `prevRow` - Previous row data object  
+- `monthlyEffectivityConstant` - Monthly effectivity constant value
+- `fieldUnits` (optional) - Object mapping field names to their units (e.g., `{ "VO1": "mwh" }`)
+
+**Returns:** Object with `ucinnost` (efficiency) and `heatUnits` values
+
+### `areMetersBeingWrittenOff(valuesData, fieldUnits)`
+
+Checks if heat meters (VO1-VO8, MT TUV) exist and are being written off.
+
+**Parameters:**
+- `valuesData` - Array of row data objects
+- `fieldUnits` (optional) - Object mapping field names to their units
+
+**Returns:** `true` if meters exist and are being written off, `false` otherwise
+
+## Supported Heat Units
+
+- **GJ** (Gigajoules) - Default unit, converts using 1 GJ = 277.778 kWh
+- **kWh** (Kilowatt-hours) - No conversion needed
+- **MWh** (Megawatt-hours) - Converts using 1 MWh = 1000 kWh
+
+## Version History
+
+- **1.0.8** - Fixed efficiency calculation bug:
+  - Removed incorrect `* 10` multiplier that caused efficiency values to be 10x too high
+  - Added meter reset detection for gas and heat meters
+  - Improved validation for negative differences and edge cases
+  - Added comprehensive test suite
+- **1.0.7** - Added `areMetersBeingWrittenOff` function to check if heat meters exist and are being written off
+- **1.0.6** - Previous version
+- **1.0.5** - Added flexible unit support for heat calculations
+
+## Testing
+
+Run tests with:
+```bash
+npm test
+```
+
+Run tests in watch mode:
+```bash
+npm run test:watch
+```
+
+Generate coverage report:
+```bash
+npm run test:coverage
+```
+
+## License
+
+ISC 

package/index.js

@@ -0,0 +1,245 @@
+const {
+  hasPropertiesAndNotDash,
+  toFloatWithDot,
+  convertHeatToKwh,
+} = require("./utils/index.js");
+
+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 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;
+    }
+  }
+
+  // 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;
+
+  const gasDiff = toFloatWithDot(row["Plyn"]) - toFloatWithDot(prevRow["Plyn"]);
+
+  // 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 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)
+
+  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
+      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
+      efficiency = "-";
+    } else {
+      // Gas consumed but no heat produced - 0% efficiency
+      efficiency = "0.0000";
+    }
+  } else if (monthlyEffectivityConstant <= 0 || isNaN(monthlyEffectivityConstant)) {
+    // Invalid effectivity constant
+    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) {
+      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;
+
+  return {
+    ...row,
+    ucinnost: efficiency,
+    heatUnits: heatUnitsValue,
+  };
+};
+
+/**
+ * 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 (
+        row.hasOwnProperty(voKey) &&
+        row[voKey] !== "-" &&
+        row[voKey] !== null &&
+        row[voKey] !== undefined &&
+        row[voKey] !== ""
+      ) {
+        metersExist = true;
+        break;
+      }
+    }
+    // Check MT TUV meter
+    if (
+      row.hasOwnProperty("MT TUV") &&
+      row["MT TUV"] !== "-" &&
+      row["MT TUV"] !== null &&
+      row["MT TUV"] !== undefined &&
+      row["MT TUV"] !== ""
+    ) {
+      metersExist = true;
+    }
+    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);
+        }
+      }
+    }
+
+    // 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);
+      }
+    }
+
+    // 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;
+};
+
+module.exports = { computeEfficiency, areMetersBeingWrittenOff };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "heatingpro-efficiency-package",
+  "version": "1.0.8",
+  "description": "Utility functions for MonitoringPro efficiency calculations with flexible unit support (GJ, kWh, MWh)",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "monitoring",
+    "efficiency",
+    "energy",
+    "utilities",
+    "gj",
+    "kwh",
+    "mwh",
+    "gas",
+    "heat"
+  ],
+  "author": "",
+  "license": "ISC",
+  "files": [
+    "index.js",
+    "utils/",
+    "README.md"
+  ],
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

package/utils/index.js

@@ -0,0 +1,31 @@
+const toFloatWithDot = (value) => {
+  if (typeof value === "string") {
+    value = value.replace(",", ".");
+  }
+  return parseFloat(value);
+};
+
+const hasPropertiesAndNotDash = (a, b, key) =>
+  a.hasOwnProperty(key) &&
+  b.hasOwnProperty(key) &&
+  a[key] !== "-" &&
+  b[key] !== "-";
+
+const convertHeatToKwh = (value, fromUnit) => {
+  const unit = fromUnit.toLowerCase();
+
+  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`
+      );
+  }
+};
+
+module.exports = { toFloatWithDot, hasPropertiesAndNotDash, convertHeatToKwh };