node-red-contrib-power-saver 5.0.0-beta.2 → 5.0.0-beta.4

package/docs/changelog/README.md

@@ -7,6 +7,15 @@ sidebarDepth: 1
 
 List the most significant changes.
 
+## 5.0.0.beta.4
+
+ - Fix bug on recovery time when recoveryMaxMinutes is not set
+
+## 5.0.0.beta.3
+
+ - Implement minute support in Heat Capacitor
+ - Fix bug so recoveryPercentage is used properly
+
 ## 5.0.0.beta.2
 
  - Fix bug in Min minutes off

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-power-saver",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0-beta.4",
   "description": "A module for Node-RED that you can use to turn on and off a switch based on power prices",
   "main": "index.js",
   "scripts": {

package/src/strategy-best-save-functions.js

@@ -45,7 +45,8 @@ function isOnOffSequencesOk(
         reachedMinOff = true;
       }
       const minRounded = Math.max(Math.round(offCount * recoveryPercentage / 100), 1)
-      minOnAfterOff = Math.min(minRounded, recoveryMaxMinutes ?? minRounded)
+      const recMaxMin = recoveryMaxMinutes === "" ? null : recoveryMaxMinutes;
+      minOnAfterOff = Math.min(minRounded, recMaxMin ?? minRounded)
       if(i === onOff.length - 1) {
         // If last minute, consider min reached
         reachedMinOn = true;
@@ -59,6 +60,8 @@ function isOnOffSequencesOk(
       if (onCount >= minOnAfterOff) {
         reachedMaxOff = false;
         reachedMinOn = true;
+      } else {
+        reachedMinOn = false;
       }
       offCount = 0;
       reachedMinOff = null;

package/src/strategy-heat-capacitor-functions.js

@@ -2,22 +2,51 @@
 const { DateTime } = require("luxon");
 const { roundPrice, getDiffToNextOn } = require("./utils");
 
-function calculateOpportunities(prices, pattern, amount) {
-  //creating a price vector with minute granularity
-  const tempPrice = Array(prices.length * 60).fill(0);
-  for (let i = 0; i < prices.length; i++) {
-    tempPrice.fill(prices[i], i * 60, (i + 1) * 60);
-    //debugger;
+function buildMinutePriceVector(priceData) {
+  if (!priceData || priceData.length === 0) {
+    return { minutePrices: [], startDate: null };
   }
 
+  const sorted = [...priceData].sort(
+    (a, b) => DateTime.fromISO(a.start).toMillis() - DateTime.fromISO(b.start).toMillis()
+  );
+
+  const minutePrices = [];
+  let previousIntervalMinutes = 60;
+
+  for (let i = 0; i < sorted.length; i++) {
+    const currentStart = DateTime.fromISO(sorted[i].start);
+    let intervalMinutes = previousIntervalMinutes;
+
+    if (sorted[i + 1]) {
+      intervalMinutes = DateTime.fromISO(sorted[i + 1].start).diff(currentStart, "minutes").minutes;
+    } else if (sorted[i].end) {
+      intervalMinutes = DateTime.fromISO(sorted[i].end).diff(currentStart, "minutes").minutes;
+    }
+
+    intervalMinutes = Math.max(1, Math.round(intervalMinutes));
+    previousIntervalMinutes = intervalMinutes;
+
+    for (let m = 0; m < intervalMinutes; m++) {
+      minutePrices.push(sorted[i].value);
+    }
+  }
+
+  return { minutePrices, startDate: DateTime.fromISO(sorted[0].start) };
+}
+
+function calculateOpportunities(pricesPerMinute, pattern, amount) {
+  const tempPrice = pricesPerMinute;
+
   //Calculate weighted pattern
   const weight = amount / pattern.reduce((a, b) => a + b, 0); //last calculates the sum of all numbers in the pattern
   const weightedPattern = pattern.map((x) => x * weight);
 
   //Calculating procurement opportunities. Sliding the pattern over the price vector to find the price for procuring
   //at time t
-  const dot = (a, b) => a.map((x, i) => a[i] * b[i]).reduce((m, n) => m + n);
-  const procurementOpportunities = Array(prices.length * 60 - pattern.length + 1);
+  const dot = (a, b) => a.map((x, i) => a[i] * b[i]).reduce((m, n) => m + n, 0);
+  const procurementLength = Math.max(tempPrice.length - pattern.length + 1, 0);
+  const procurementOpportunities = Array(procurementLength);
   for (let i = 0; i < procurementOpportunities.length; i++) {
     procurementOpportunities[i] = dot(weightedPattern, tempPrice.slice(i, i + pattern.length));
   }
@@ -232,8 +261,7 @@ function runBuySellAlgorithm(
   maxTempAdjustment,
   minSavings
 ) {
-  const prices = [...priceData.map((pd) => pd.value)];
-  const startDate = DateTime.fromISO(priceData[0].start);
+  const { minutePrices, startDate } = buildMinutePriceVector(priceData);
 
   //pattern for how much power is procured/sold when.
   //This has, for now, just a flat acquisition/divestment profile
@@ -243,8 +271,8 @@ function runBuySellAlgorithm(
   const sellPattern = Array(sellDuration).fill(1);
 
   //Calculate what it will cost to procure/sell 1 kWh as a function of time
-  const buyPrices = calculateOpportunities(prices, buyPattern, 1);
-  const sellPrices = calculateOpportunities(prices, sellPattern, 1);
+  const buyPrices = calculateOpportunities(minutePrices, buyPattern, 1);
+  const sellPrices = calculateOpportunities(minutePrices, sellPattern, 1);
 
   //Find dates for when to procure/sell
   const buySell = findBestBuySellPattern(buyPrices, buyPattern.length, sellPrices, sellPattern.length);

package/src/strategy-heat-capacitor.js

@@ -80,10 +80,14 @@ module.exports = function (RED) {
       if (msg.payload.hasOwnProperty("priceData")) {
         if (node.hasOwnProperty("priceData")) {
           node.priceData = mergePriceData(node.priceData, msg.payload.priceData);
-          if (node.priceData.length > 72) node.priceData = node.priceData.slice(-72);
         } else {
           node.priceData = msg.payload.priceData;
         }
+        if (node.priceData.length) {
+          const latestStart = DateTime.fromISO(node.priceData[node.priceData.length - 1].start);
+          const cutoff = latestStart.minus({ hours: 72 });
+          node.priceData = node.priceData.filter((entry) => DateTime.fromISO(entry.start) >= cutoff);
+        }
       }
 
       if (node.hasOwnProperty("priceData")) {
@@ -136,21 +140,16 @@ module.exports = function (RED) {
 };
 
 function mergePriceData(priceDataA, priceDataB) {
-  const tempDict = {};
-  priceDataA.forEach((e) => {
-    tempDict[e.start] = e.value;
-  });
-  priceDataB.forEach((e) => {
-    tempDict[e.start] = e.value;
+  const mergedEntries = new Map();
+  priceDataA.concat(priceDataB).forEach((entry) => {
+    if (!entry?.start) {
+      return;
+    }
+    const existing = mergedEntries.get(entry.start);
+    mergedEntries.set(entry.start, Object.assign({}, existing, entry));
   });
 
-  const keys = Object.keys(tempDict);
-  keys.sort();
-
-  const res = Array(keys.length);
-  for (let i = 0; i < res.length; i++) {
-    res[i] = { value: tempDict[keys[i]], start: keys[i] };
-  }
-
-  return res;
+  return Array.from(mergedEntries.values()).sort(
+    (a, b) => DateTime.fromISO(a.start).toMillis() - DateTime.fromISO(b.start).toMillis()
+  );
 }