signalk-usage 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-usage",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Track electrical and tank usage",
   "main": "plugin/index.js",
   "keywords": [

package/plugin/lib/tankageEngine.js

@@ -2,20 +2,28 @@
  * TankageEngine - Calculates tank usage (consumption and additions)
  * 
  * Filtering approach:
- * - Time filter: Only process changes >= 2 minutes apart (filters rapid sensor noise)
+ * - Time filter: Only process changes >= X minutes apart (filters rapid sensor noise)
  * - Addition requirements: 
- *   - Small tanks: >= 1 gallon increase over >= 5 minutes
- *   - Large tanks: >= 5 gallon increase over >= 5 minutes
+ *   - Small tanks: >= X gallon increase over >= X minutes
+ *   - Large tanks: >= X gallon increase over >= X minutes
  * - Consumption: No quantity threshold, just time filter
  */
 
-const MIN_TIME_BETWEEN_POINTS_MS = 2 * 60 * 1000;
-const ADDITION_MIN_DURATION_MS = 5 * 60 * 1000;
-const SMALL_TANK_ADDITION_GAL = 1.0;
-const LARGE_TANK_ADDITION_GAL = 5.0;
+const MIN_TIME_BETWEEN_POINTS_MS = 2 * 60 * 1000;  // 2 minutes
 const M3_TO_GAL = 264.172;
 const GAL_TO_M3 = 0.00378541;
 
+// Consumption calculation - different smoothing for short vs long periods
+const SHORT_PERIOD_THRESHOLD_MS = 24 * 60 * 60 * 1000; // X hours
+const SHORT_PERIOD_SMOOTHING_PERCENT = 0.25; // X% for periods ≤ X hours
+const LONG_PERIOD_SMOOTHING_PERCENT = 0.06; // X% for periods > X hours
+
+// Addition calculation - light smoothing to preserve refills
+const ADDITION_SMOOTHING_MS = 1 * 60 * 60 * 1000; // X hour (fixed)
+const SMALL_TANK_ADDITION_GAL = 1.0;
+const LARGE_TANK_ADDITION_GAL = 5.0;
+const ADDITION_MIN_DURATION_MS = 5 * 60 * 1000; // X minutes
+
 function TankageEngine(app, influxClient, options) {
   this.app = app;
   this.influxClient = influxClient;
@@ -139,19 +147,90 @@ TankageEngine.prototype.calculateUsageForPeriod = async function(item, period) {
 TankageEngine.prototype.processDataPoints = function(dataPoints, item) {
   const { path } = item;
   
+  // Determine addition threshold based on tank size
   const isLargeTank = item.largeTank || false;
   const additionThresholdGal = isLargeTank ? LARGE_TANK_ADDITION_GAL : SMALL_TANK_ADDITION_GAL;
   const additionThresholdM3 = additionThresholdGal * GAL_TO_M3;
   
-  this.app.debug(`TankageEngine: ${path} - Processing ${dataPoints.length} points, Tank type: ${isLargeTank ? 'large' : 'small'} (${additionThresholdGal} gal threshold)`);
+  // Calculate consumption smoothing window based on data range
+  const dataRangeMs = dataPoints[dataPoints.length - 1].timestamp - dataPoints[0].timestamp;
+  const smoothingPercent = dataRangeMs <= SHORT_PERIOD_THRESHOLD_MS 
+    ? SHORT_PERIOD_SMOOTHING_PERCENT 
+    : LONG_PERIOD_SMOOTHING_PERCENT;
+  const consumptionSmoothingMs = dataRangeMs * smoothingPercent;
+  
+  this.app.debug(`TankageEngine: ${path} - Processing ${dataPoints.length} points, Tank type: ${isLargeTank ? 'large' : 'small'}, Consumption smoothing: ${(consumptionSmoothingMs / 3600000).toFixed(1)} hours (${(smoothingPercent * 100).toFixed(0)}% of ${(dataRangeMs / 3600000).toFixed(1)} hour range)`);
+  
+  // CONSUMPTION CALCULATION - Dual smoothing (X% for ≤Xh, X% for >Xh) to filter dips
+  const consumptionSmoothed = [];
+  for (let i = 0; i < dataPoints.length; i++) {
+    const currentPoint = dataPoints[i];
+    const windowStart = currentPoint.timestamp - consumptionSmoothingMs;
+    
+    const windowPoints = [];
+    for (let j = 0; j <= i; j++) {
+      if (dataPoints[j].timestamp >= windowStart) {
+        windowPoints.push(dataPoints[j]);
+      }
+    }
+    
+    const avgValue = windowPoints.reduce((sum, p) => sum + p.value, 0) / windowPoints.length;
+    consumptionSmoothed.push({
+      timestamp: currentPoint.timestamp,
+      value: avgValue
+    });
+  }
   
+  // Calculate consumption from heavily smoothed data
   let totalConsumed = 0;
+  let lastConsumptionPoint = consumptionSmoothed[0];
+  
+  for (let i = 1; i < consumptionSmoothed.length; i++) {
+    const prevPoint = lastConsumptionPoint;
+    const currPoint = consumptionSmoothed[i];
+    const timeDiffMs = currPoint.timestamp - prevPoint.timestamp;
+    
+    if (timeDiffMs < MIN_TIME_BETWEEN_POINTS_MS) {
+      continue;
+    }
+    
+    const changeM3 = currPoint.value - prevPoint.value;
+    
+    // Only count decreases
+    if (changeM3 < 0) {
+      totalConsumed += Math.abs(changeM3);
+    }
+    
+    lastConsumptionPoint = currPoint;
+  }
+  
+  // ADDITION CALCULATION - Light smoothing (X hour) to preserve refills
+  const additionSmoothed = [];
+  for (let i = 0; i < dataPoints.length; i++) {
+    const currentPoint = dataPoints[i];
+    const windowStart = currentPoint.timestamp - ADDITION_SMOOTHING_MS;
+    
+    const windowPoints = [];
+    for (let j = 0; j <= i; j++) {
+      if (dataPoints[j].timestamp >= windowStart) {
+        windowPoints.push(dataPoints[j]);
+      }
+    }
+    
+    const avgValue = windowPoints.reduce((sum, p) => sum + p.value, 0) / windowPoints.length;
+    additionSmoothed.push({
+      timestamp: currentPoint.timestamp,
+      value: avgValue
+    });
+  }
+  
+  // Calculate additions from lightly smoothed data
   let totalAdded = 0;
-  let lastTrackedPoint = dataPoints[0];
+  let lastAdditionPoint = additionSmoothed[0];
   
-  for (let i = 1; i < dataPoints.length; i++) {
-    const prevPoint = lastTrackedPoint;
-    const currPoint = dataPoints[i];
+  for (let i = 1; i < additionSmoothed.length; i++) {
+    const prevPoint = lastAdditionPoint;
+    const currPoint = additionSmoothed[i];
     const timeDiffMs = currPoint.timestamp - prevPoint.timestamp;
     
     if (timeDiffMs < MIN_TIME_BETWEEN_POINTS_MS) {
@@ -160,6 +239,7 @@ TankageEngine.prototype.processDataPoints = function(dataPoints, item) {
     
     const changeM3 = currPoint.value - prevPoint.value;
     
+    // Only count increases that meet thresholds
     if (changeM3 > 0) {
       const meetsQuantity = changeM3 >= additionThresholdM3;
       const meetsDuration = timeDiffMs >= ADDITION_MIN_DURATION_MS;
@@ -167,15 +247,12 @@ TankageEngine.prototype.processDataPoints = function(dataPoints, item) {
       if (meetsQuantity && meetsDuration) {
         totalAdded += changeM3;
       }
-      
-    } else if (changeM3 < 0) {
-      totalConsumed += Math.abs(changeM3);
     }
     
-    lastTrackedPoint = currPoint;
+    lastAdditionPoint = currPoint;
   }
   
-  this.app.debug(`TankageEngine: ${path} - Consumed: ${(totalConsumed * M3_TO_GAL).toFixed(2)} gal, Added: ${(totalAdded * M3_TO_GAL).toFixed(2)} gal`);
+  this.app.debug(`TankageEngine: ${path} - Consumed: ${(totalConsumed * M3_TO_GAL).toFixed(2)} gal (Xhr smooth), Added: ${(totalAdded * M3_TO_GAL).toFixed(2)} gal (Xhr smooth)`);
   
   return {
     consumed: totalConsumed,
@@ -191,13 +268,80 @@ TankageEngine.prototype.calculateTankageFromData = function(dataPoints, isLargeT
   const additionThresholdGal = isLargeTank ? LARGE_TANK_ADDITION_GAL : SMALL_TANK_ADDITION_GAL;
   const additionThresholdM3 = additionThresholdGal * GAL_TO_M3;
   
+  // Calculate consumption smoothing window based on data range
+  const dataRangeMs = dataPoints[dataPoints.length - 1].timestamp - dataPoints[0].timestamp;
+  const smoothingPercent = dataRangeMs <= SHORT_PERIOD_THRESHOLD_MS 
+    ? SHORT_PERIOD_SMOOTHING_PERCENT 
+    : LONG_PERIOD_SMOOTHING_PERCENT;
+  const consumptionSmoothingMs = dataRangeMs * smoothingPercent;
+  
+  // CONSUMPTION - Dual smoothing (X% for ≤Xh, X% for >Xh)
+  const consumptionSmoothed = [];
+  for (let i = 0; i < dataPoints.length; i++) {
+    const currentPoint = dataPoints[i];
+    const windowStart = currentPoint.timestamp - consumptionSmoothingMs;
+    
+    const windowPoints = [];
+    for (let j = 0; j <= i; j++) {
+      if (dataPoints[j].timestamp >= windowStart) {
+        windowPoints.push(dataPoints[j]);
+      }
+    }
+    
+    const avgValue = windowPoints.reduce((sum, p) => sum + p.value, 0) / windowPoints.length;
+    consumptionSmoothed.push({
+      timestamp: currentPoint.timestamp,
+      value: avgValue
+    });
+  }
+  
   let totalConsumed = 0;
+  let lastConsumptionPoint = consumptionSmoothed[0];
+  
+  for (let i = 1; i < consumptionSmoothed.length; i++) {
+    const prevPoint = lastConsumptionPoint;
+    const currPoint = consumptionSmoothed[i];
+    const timeDiffMs = currPoint.timestamp - prevPoint.timestamp;
+    
+    if (timeDiffMs < MIN_TIME_BETWEEN_POINTS_MS) {
+      continue;
+    }
+    
+    const changeM3 = currPoint.value - prevPoint.value;
+    
+    if (changeM3 < 0) {
+      totalConsumed += Math.abs(changeM3);
+    }
+    
+    lastConsumptionPoint = currPoint;
+  }
+  
+  // ADDITION - Light smoothing (X hour)
+  const additionSmoothed = [];
+  for (let i = 0; i < dataPoints.length; i++) {
+    const currentPoint = dataPoints[i];
+    const windowStart = currentPoint.timestamp - ADDITION_SMOOTHING_MS;
+    
+    const windowPoints = [];
+    for (let j = 0; j <= i; j++) {
+      if (dataPoints[j].timestamp >= windowStart) {
+        windowPoints.push(dataPoints[j]);
+      }
+    }
+    
+    const avgValue = windowPoints.reduce((sum, p) => sum + p.value, 0) / windowPoints.length;
+    additionSmoothed.push({
+      timestamp: currentPoint.timestamp,
+      value: avgValue
+    });
+  }
+  
   let totalAdded = 0;
-  let lastTrackedPoint = dataPoints[0];
+  let lastAdditionPoint = additionSmoothed[0];
   
-  for (let i = 1; i < dataPoints.length; i++) {
-    const prevPoint = lastTrackedPoint;
-    const currPoint = dataPoints[i];
+  for (let i = 1; i < additionSmoothed.length; i++) {
+    const prevPoint = lastAdditionPoint;
+    const currPoint = additionSmoothed[i];
     const timeDiffMs = currPoint.timestamp - prevPoint.timestamp;
     
     if (timeDiffMs < MIN_TIME_BETWEEN_POINTS_MS) {
@@ -207,14 +351,15 @@ TankageEngine.prototype.calculateTankageFromData = function(dataPoints, isLargeT
     const changeM3 = currPoint.value - prevPoint.value;
     
     if (changeM3 > 0) {
-      if (changeM3 >= additionThresholdM3 && timeDiffMs >= ADDITION_MIN_DURATION_MS) {
+      const meetsQuantity = changeM3 >= additionThresholdM3;
+      const meetsDuration = timeDiffMs >= ADDITION_MIN_DURATION_MS;
+      
+      if (meetsQuantity && meetsDuration) {
         totalAdded += changeM3;
       }
-    } else if (changeM3 < 0) {
-      totalConsumed += Math.abs(changeM3);
     }
     
-    lastTrackedPoint = currPoint;
+    lastAdditionPoint = currPoint;
   }
   
   return {