node-red-contrib-power-saver 1.0.9 → 2.0.0

package/CHANGELOG.md

@@ -2,8 +2,15 @@
 
 List the most significant changes, starting in version 1.0.9.
 
+## 2.0.0
+
+* New and better algorithm to calculates savings, resulting in a better schedule.
+* Removed possibility to configure maximum hours to save per day, as this does not really make much sense.
+* Round savings to 4 decimals.
+* Set last savings hour to null when 0.
+
 ## 1.0.9
 
-* Fix bug in saving last hour of the day
+* Fix bug in saving last hour of the day.
 
 

package/mostSavedStrategy.js

@@ -1,24 +1,13 @@
-const {
-  sortedIndex,
-  getDiffToNextOn,
-  isOnOffSequencesOk,
-  fillArray,
-} = require("./utils");
+"use strict";
+
+const { isOnOffSequencesOk, fillArray } = require("./utils");
 /**
  * Turn off the hours where you save most compared to the next hour on.
  *
- * Algorithm:
- * 1. For each hour, find out how much is saved if turned off.
- *    Compare price with the net hour that is on.
- * 2. Turn off the hour that saves the most.
- * 3. Validate. Keep if valid. If not, turn off the next best. And so on.
- *    When validating, include hours from day before, but do not fail on day before.
- * 4. If something was turned off, repeat from 1.
- *
  * @param {*} values Array of prices
- * @param {*} maxOffCount Max number of hours that can be saved in total
  * @param {*} maxOffInARow Max number of hours that can be saved in a row
  * @param {*} minOnAfterMaxOffInARow Min number of hours that must be on after maxOffInARow is saved
+ * @param {*} minSaving Minimum amount that must be saved in order to turn off
  * @param {*} lastValueDayBefore Value of the last hour the day before
  * @param {*} lastCountDayBefore Number of lastValueDayBefore in a row
  * @returns Array with same number of values as in values array, where true is on, false is off
@@ -26,44 +15,69 @@ const {
 module.exports = {
   calculate: function (
     values,
-    maxOffCount,
     maxOffInARow,
     minOnAfterMaxOffInARow,
     minSaving,
     lastValueDayBefore = undefined,
-    lastCountDayBefore = 0,
-    firstValueNextDay
+    lastCountDayBefore = 0
   ) {
     const dayBefore = fillArray(lastValueDayBefore, lastCountDayBefore);
-    let foundImprovement;
-    const onOff = values.map((v) => true); // Start with all on
-    if (maxOffCount <= 0) {
-      return onOff;
+    const last = values.length - 1;
+
+    // Create matrix with saving per hour
+    const savingPerHour = [];
+    for (let hour = 0; hour < last; hour++) {
+      const row = [];
+      for (let count = 1; count <= maxOffInARow; count++) {
+        const on = hour + count;
+        const saving = values[hour] - values[on >= last ? last : on];
+        row.push(saving);
+      }
+      savingPerHour.push(row);
     }
-    do {
-      foundImprovement = false;
-      const diffToNextOn = getDiffToNextOn(values, onOff, firstValueNextDay);
-      const sorted = sortedIndex(diffToNextOn).filter(
-        (v) => onOff[v] && diffToNextOn[v] >= minSaving
-      );
-      let tryToTurnOffIndex = 0;
-      while (tryToTurnOffIndex < sorted.length && !foundImprovement) {
-        onOff[sorted[tryToTurnOffIndex]] = false;
+
+    // Create list with summary saving per sequence
+    let savingsList = [];
+    for (let hour = 0; hour < last; hour++) {
+      for (let count = 1; count <= maxOffInARow; count++) {
+        let saving = 0;
+        for (let offset = 0; offset < count && hour + offset < last; offset++) {
+          saving += savingPerHour[hour + offset][count - offset - 1];
+        }
         if (
-          isOnOffSequencesOk(
-            [...dayBefore, ...onOff],
-            maxOffInARow,
-            minOnAfterMaxOffInARow
-          )
+          saving > minSaving * count &&
+          values[hour] > values[hour + count] + minSaving
         ) {
-          foundImprovement = true;
-        } else {
-          onOff[sorted[tryToTurnOffIndex]] = true;
-          tryToTurnOffIndex++;
+          savingsList.push({ hour, count, saving });
         }
       }
-    } while (foundImprovement && onOff.filter((v) => !v).length < maxOffCount);
+    }
+
+    savingsList.sort((a, b) => b.saving - a.saving);
+    let onOff = values.map((v) => true); // Start with all on
 
+    // Find the best possible sequences
+    while (savingsList.length > 0) {
+      const { hour, count } = savingsList[0];
+      const onOffCopy = [...onOff];
+      for (let c = 0; c < count; c++) {
+        onOff[hour + c] = false;
+      }
+      if (
+        isOnOffSequencesOk(
+          [...dayBefore, ...onOff],
+          maxOffInARow,
+          minOnAfterMaxOffInARow
+        )
+      ) {
+        savingsList = savingsList.filter(
+          (s) => s.hour < hour || s.hour >= hour + count
+        );
+      } else {
+        onOff = [...onOffCopy];
+        savingsList.splice(0, 1);
+      }
+    }
     return onOff;
   },
 };

package/mostSavedStrategy_v2.js

@@ -0,0 +1,68 @@
+const {
+  sortedIndex,
+  getDiffToNextOn,
+  isOnOffSequencesOk,
+  fillArray,
+} = require("./utils");
+/**
+ * Turn off the hours where you save most compared to the next hour on.
+ *
+ * Algorithm:
+ * 1. For each hour, find out how much is saved if turned off.
+ *    Compare price with the net hour that is on.
+ * 2. Turn off the hour that saves the most.
+ * 3. Validate. Keep if valid. If not, turn off the next best. And so on.
+ *    When validating, include hours from day before, but do not fail on day before.
+ * 4. If something was turned off, repeat from 1.
+ *
+ * @param {*} values Array of prices
+ * @param {*} maxOffInARow Max number of hours that can be saved in a row
+ * @param {*} minOnAfterMaxOffInARow Min number of hours that must be on after maxOffInARow is saved
+ * @param {*} minSaving Minimum amount that must be saved in order to turn off
+ * @param {*} lastValueDayBefore Value of the last hour the day before
+ * @param {*} lastCountDayBefore Number of lastValueDayBefore in a row
+ * @returns Array with same number of values as in values array, where true is on, false is off
+ */
+module.exports = {
+  calculate: function (
+    values,
+    maxOffInARow,
+    minOnAfterMaxOffInARow,
+    minSaving,
+    lastValueDayBefore = undefined,
+    lastCountDayBefore = 0
+  ) {
+    const dayBefore = fillArray(lastValueDayBefore, lastCountDayBefore);
+    let foundImprovement;
+    const onOff = values.map((v) => true); // Start with all on
+    do {
+      foundImprovement = false;
+      const diffToNextOn = getDiffToNextOn(
+        values,
+        onOff,
+        values[values.length - 1]
+      );
+      const sorted = sortedIndex(diffToNextOn).filter(
+        (v) => onOff[v] && diffToNextOn[v] >= minSaving
+      );
+      let tryToTurnOffIndex = 0;
+      while (tryToTurnOffIndex < sorted.length && !foundImprovement) {
+        onOff[sorted[tryToTurnOffIndex]] = false;
+        if (
+          isOnOffSequencesOk(
+            [...dayBefore, ...onOff],
+            maxOffInARow,
+            minOnAfterMaxOffInARow
+          )
+        ) {
+          foundImprovement = true;
+        } else {
+          onOff[sorted[tryToTurnOffIndex]] = true;
+          tryToTurnOffIndex++;
+        }
+      }
+    } while (foundImprovement);
+
+    return onOff;
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-power-saver",
-  "version": "1.0.9",
+  "version": "2.0.0",
   "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/power-saver.html

@@ -4,11 +4,6 @@
     color: "#a6bbcf",
     defaults: {
       name: { value: "Power Saver" },
-      maxHoursToSavePerDay: {
-        value: 12,
-        required: true,
-        validate: RED.validators.number(),
-      },
       maxHoursToSaveInSequence: {
         value: 3,
         required: true,
@@ -47,10 +42,6 @@
       <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
       <input type="text" id="node-input-name" placeholder="Name">
   </div>
-  <div class="form-row">
-      <label for="node-input-maxHoursToSavePerDay"><i class="fa fa-align-justify"></i> Max per day</label>
-      <input type="text" id="node-input-maxHoursToSavePerDay" placeholder="Max hours to save in a day">
-  </div>
   <div class="form-row">
       <label for="node-input-maxHoursToSaveInSequence"><i class="fa fa-arrows-h"></i> Max per sequence</label>
       <input type="text" id="node-input-maxHoursToSaveInSequence" placeholder="Max hours to save in sequence">
@@ -80,9 +71,6 @@
 
 
   <div>
-      <p>
-          <strong>Max per day</strong> is the maximum number of hours that can be saved (turned off) during a day.
-      </p>
       <p>
           <strong>Max per sequence</strong> is the maximum number of hours that can be saved (turned off) in a sequence.
       </p>

package/power-saver.js

@@ -1,5 +1,11 @@
 const { DateTime } = require("luxon");
-const { convertMsg, countAtEnd, makeSchedule, getSavings } = require("./utils");
+const {
+  convertMsg,
+  countAtEnd,
+  makeSchedule,
+  getSavings,
+  extractPlanForDate,
+} = require("./utils");
 const mostSavedStrategy = require("./mostSavedStrategy");
 
 let schedulingTimeout = null;
@@ -10,7 +16,6 @@ module.exports = function (RED) {
     const node = this;
 
     // Save config in node
-    this.maxHoursToSavePerDay = config.maxHoursToSavePerDay;
     this.maxHoursToSaveInSequence = config.maxHoursToSaveInSequence;
     this.minHoursOnAfterMaxSequenceSaved =
       config.minHoursOnAfterMaxSequenceSaved;
@@ -33,56 +38,34 @@ module.exports = function (RED) {
         return;
       }
 
-      const today = input.today;
-      const tomorrow = input.tomorrow;
-      const source = input.source;
+      const priceData = [...input.today, ...input.tomorrow];
 
       clearTimeout(schedulingTimeout);
 
-      // Set dates
-      const todaysDate = DateTime.fromISO(today[0].start.substr(0, 10));
-      const yesterdayDate = todaysDate.plus({ days: -1 });
-      const tomorrowDate = todaysDate.plus({ days: 1 });
+      const dates = [
+        ...new Set(priceData.map((v) => DateTime.fromISO(v.start).toISODate())),
+      ];
 
-      // Load data from yesterday
-      const dataYesterday = loadDayData(node, yesterdayDate);
+      // Load data from day before
+      const dateDayBefore = DateTime.fromISO(dates[0]).plus({ days: -1 });
+      const dataDayBefore = loadDayData(node, dateDayBefore);
 
       // Make plan
-      const valuesToday = today.map((d) => d.value);
-      const valuesTomorrow = tomorrow.map((d) => d.value);
-      const startTimesToday = today.map((d) => d.start);
-      const startTimesTomorrow = tomorrow.map((d) => d.start);
-
-      const planToday = makePlan(
-        node,
-        valuesToday,
-        startTimesToday,
-        dataYesterday.onOff,
-        valuesTomorrow[0]
-      );
-      const planTomorrow = makePlan(
-        node,
-        valuesTomorrow,
-        startTimesTomorrow,
-        planToday.onOff
-      );
+      const values = priceData.map((d) => d.value);
+      const startTimes = priceData.map((d) => d.start);
+      const plan = makePlan(node, values, startTimes, dataDayBefore.onOff);
 
       // Save schedule
-      saveDayData(node, todaysDate, planToday);
-      saveDayData(node, tomorrowDate, planTomorrow);
-
-      // Combine data for today and tomorrow
-      const schedule = [...planToday.schedule, ...planTomorrow.schedule];
-      const hours = [...planToday.hours, ...planTomorrow.hours];
+      dates.forEach((d) => saveDayData(node, d, extractPlanForDate(plan, d)));
 
       // Prepare output
       let output1 = null;
       let output2 = null;
       let output3 = {
         payload: {
-          schedule,
-          hours,
-          source,
+          schedule: plan.schedule,
+          hours: plan.hours,
+          source: input.source,
         },
       };
 
@@ -90,7 +73,7 @@ module.exports = function (RED) {
       const time = msg.payload.time
         ? DateTime.fromISO(msg.payload.time)
         : DateTime.now();
-      const pastSchedule = schedule.filter(
+      const pastSchedule = plan.schedule.filter(
         (entry) => DateTime.fromISO(entry.time) <= time
       );
       const outputCurrent = node.sendCurrentValueWhenRescheduling;
@@ -102,13 +85,13 @@ module.exports = function (RED) {
       }
 
       // Delete old data
-      deleteSavedScheduleBefore(node, yesterdayDate);
+      deleteSavedScheduleBefore(node, dateDayBefore);
 
       // Send output
       node.send([output1, output2, output3]);
 
       // Run schedule
-      schedulingTimeout = runSchedule(node, schedule, time);
+      schedulingTimeout = runSchedule(node, plan.schedule, time);
     });
   }
 
@@ -131,8 +114,7 @@ function loadDayData(node, date) {
 }
 
 function saveDayData(node, date, plan) {
-  const key = date.toISO();
-  node.context().set(key, plan);
+  node.context().set(date, plan);
 }
 
 function deleteSavedScheduleBefore(node, day) {
@@ -151,13 +133,11 @@ function makePlan(node, values, startTimes, onOffBefore, firstValueNextDay) {
     strategy === "mostSaved"
       ? mostSavedStrategy.calculate(
           values,
-          node.maxHoursToSavePerDay,
           node.maxHoursToSaveInSequence,
           node.minHoursOnAfterMaxSequenceSaved,
           node.minSaving,
           lastValueDayBefore,
-          lastCountDayBefore,
-          firstValueNextDay
+          lastCountDayBefore
         )
       : [];
 

package/test/data/result.js

@@ -0,0 +1,163 @@
+module.exports = {
+  schedule: [
+    {
+      time: "2021-06-20T01:50:00.000+02:00",
+      value: true,
+    },
+    {
+      time: "2021-06-20T01:50:00.030+02:00",
+      value: false,
+    },
+    {
+      time: "2021-06-20T01:50:00.050+02:00",
+      value: true,
+    },
+    {
+      time: "2021-06-20T01:50:00.060+02:00",
+      value: false,
+    },
+    {
+      time: "2021-06-20T01:50:00.080+02:00",
+      value: true,
+    },
+    {
+      time: "2021-06-20T01:50:00.090+02:00",
+      value: false,
+    },
+    {
+      time: "2021-06-20T01:50:00.120+02:00",
+      value: true,
+    },
+    {
+      time: "2021-06-20T01:50:00.150+02:00",
+      value: false,
+    },
+    {
+      time: "2021-06-20T01:50:00.180+02:00",
+      value: true,
+    },
+  ],
+  hours: [
+    {
+      price: 0.3,
+      onOff: true,
+      start: "2021-06-20T01:50:00.000+02:00",
+      saving: null,
+    },
+    {
+      price: 0.4,
+      onOff: true,
+      start: "2021-06-20T01:50:00.010+02:00",
+      saving: null,
+    },
+    {
+      price: 0.8,
+      onOff: true,
+      start: "2021-06-20T01:50:00.020+02:00",
+      saving: null,
+    },
+    {
+      price: 0.9,
+      onOff: false,
+      start: "2021-06-20T01:50:00.030+02:00",
+      saving: 0.3,
+    },
+    {
+      price: 0.7,
+      onOff: false,
+      start: "2021-06-20T01:50:00.040+02:00",
+      saving: 0.1,
+    },
+    {
+      price: 0.6,
+      onOff: true,
+      start: "2021-06-20T01:50:00.050+02:00",
+      saving: null,
+    },
+    {
+      price: 0.5,
+      onOff: false,
+      start: "2021-06-20T01:50:00.060+02:00",
+      saving: 0.3,
+    },
+    {
+      price: 0.75,
+      onOff: false,
+      start: "2021-06-20T01:50:00.070+02:00",
+      saving: 0.55,
+    },
+    {
+      price: 0.2,
+      onOff: true,
+      start: "2021-06-20T01:50:00.080+02:00",
+      saving: null,
+    },
+    {
+      price: 0.85,
+      onOff: false,
+      start: "2021-06-20T01:50:00.090+02:00",
+      saving: 0.05,
+    },
+    {
+      price: 1.5,
+      onOff: false,
+      start: "2021-06-20T01:50:00.100+02:00",
+      saving: 0.7,
+    },
+    {
+      price: 1.4,
+      onOff: false,
+      start: "2021-06-20T01:50:00.110+02:00",
+      saving: 0.6,
+    },
+    {
+      price: 0.8,
+      onOff: true,
+      start: "2021-06-20T01:50:00.120+02:00",
+      saving: null,
+    },
+    {
+      price: 0.9,
+      onOff: true,
+      start: "2021-06-20T01:50:00.130+02:00",
+      saving: null,
+    },
+    {
+      price: 0.7,
+      onOff: true,
+      start: "2021-06-20T01:50:00.140+02:00",
+      saving: null,
+    },
+    {
+      price: 0.6,
+      onOff: false,
+      start: "2021-06-20T01:50:00.150+02:00",
+      saving: 0.4,
+    },
+    {
+      price: 0.5,
+      onOff: false,
+      start: "2021-06-20T01:50:00.160+02:00",
+      saving: 0.3,
+    },
+    {
+      price: 0.75,
+      onOff: false,
+      start: "2021-06-20T01:50:00.170+02:00",
+      saving: 0.55,
+    },
+    {
+      price: 0.2,
+      onOff: true,
+      start: "2021-06-20T01:50:00.180+02:00",
+      saving: null,
+    },
+    {
+      price: 0.85,
+      onOff: true,
+      start: "2021-06-20T01:50:00.190+02:00",
+      saving: null,
+    },
+  ],
+  source: "Other",
+};