@energiok/node-red-contrib-pricecontrol-thermal 1.2.0 → 1.2.2

package/test/strategy-smart-thermal-functions.test.js

@@ -1,15 +1,15 @@
 const { expect } = require("chai");
 const {
   calculateCoastTime,
-  findPeaks,
-  findTroughs,
   createSchedule,
   getCurrentMode,
   enforceMinimumDurations,
-  findExpensiveWindows,
   validateConfig,
   ckmeans,
   classifyPricesWithCkmeans,
+  groupPricesByLocalDay,
+  mergePartialDays,
+  classifyPricesPerDay,
 } = require("../src/strategy-smart-thermal-functions.js");
 const { DateTime } = require("luxon");
 
@@ -71,61 +71,6 @@ describe("strategy-smart-thermal-functions", function () {
     });
   });
 
-  describe("findPeaks", function () {
-    it("should identify top 20% as peaks", function () {
-      const prices = [
-        { time: "2026-01-15T00:00:00+01:00", value: 0.5 },
-        { time: "2026-01-15T01:00:00+01:00", value: 0.6 },
-        { time: "2026-01-15T02:00:00+01:00", value: 0.8 },
-        { time: "2026-01-15T03:00:00+01:00", value: 1.2 }, // peak
-        { time: "2026-01-15T04:00:00+01:00", value: 1.5 }, // peak
-      ];
-      const peaks = findPeaks(prices, 20);
-      expect(peaks).to.deep.equal([false, false, false, true, true]);
-    });
-
-    it("should handle empty array", function () {
-      const peaks = findPeaks([], 20);
-      expect(peaks).to.deep.equal([]);
-    });
-
-    it("should handle single price", function () {
-      const prices = [{ time: "2026-01-15T00:00:00+01:00", value: 1.0 }];
-      const peaks = findPeaks(prices, 20);
-      expect(peaks).to.deep.equal([true]);
-    });
-
-    it("should handle different threshold", function () {
-      const prices = [
-        { time: "2026-01-15T00:00:00+01:00", value: 0.5 },
-        { time: "2026-01-15T01:00:00+01:00", value: 0.8 }, // peak
-        { time: "2026-01-15T02:00:00+01:00", value: 1.0 }, // peak
-        { time: "2026-01-15T03:00:00+01:00", value: 1.2 }, // peak
-      ];
-      const peaks = findPeaks(prices, 50); // Top 50% (includes threshold value)
-      expect(peaks).to.deep.equal([false, true, true, true]);
-    });
-  });
-
-  describe("findTroughs", function () {
-    it("should identify bottom 20% as troughs", function () {
-      const prices = [
-        { time: "2026-01-15T00:00:00+01:00", value: 0.3 }, // trough
-        { time: "2026-01-15T01:00:00+01:00", value: 0.4 }, // trough
-        { time: "2026-01-15T02:00:00+01:00", value: 0.8 },
-        { time: "2026-01-15T03:00:00+01:00", value: 1.0 },
-        { time: "2026-01-15T04:00:00+01:00", value: 1.2 },
-      ];
-      const troughs = findTroughs(prices, 20);
-      expect(troughs).to.deep.equal([true, true, false, false, false]);
-    });
-
-    it("should handle empty array", function () {
-      const troughs = findTroughs([], 20);
-      expect(troughs).to.deep.equal([]);
-    });
-  });
-
   describe("createSchedule", function () {
     it("should create schedule with boost and coast periods", function () {
       const prices = [
@@ -327,14 +272,9 @@ describe("strategy-smart-thermal-functions", function () {
       }
 
       const config = {
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
         heatLossCoefficient: 0.05,
-        peakThreshold: 20,
-        intervalMinutes: 15,
-        minCoastMinutes: 60, // Require 1 hour minimum
-        minBoostMinutes: 60,
+        minModeDuration: 60, // Require 1 hour minimum
+        minSavingsPercent: 5,
       };
 
       const schedule = createSchedule(prices, 5, config);
@@ -403,35 +343,6 @@ describe("strategy-smart-thermal-functions", function () {
     });
   });
 
-  describe("findExpensiveWindows", function () {
-    it("should find expensive windows above average", function () {
-      const prices = [0.5, 0.6, 1.2, 1.5, 0.7, 0.4];
-      const avgPrice = 0.82;
-      const windows = findExpensiveWindows(prices, avgPrice, 0);
-      expect(windows.length).to.equal(1);
-      expect(windows[0].start).to.equal(2);
-      expect(windows[0].end).to.equal(3);
-      expect(windows[0].peakPrice).to.equal(1.5);
-    });
-
-    it("should respect minimum savings threshold", function () {
-      const prices = [0.5, 0.6, 0.85, 0.9, 0.7, 0.4]; // prices close to avg
-      const avgPrice = 0.65;
-      const threshold = 0.3; // High threshold
-      const windows = findExpensiveWindows(prices, avgPrice, threshold);
-      // Only 0.9 exceeds avgPrice + 0.3 = 0.95? No, 0.9 < 0.95
-      expect(windows.length).to.equal(0);
-    });
-
-    it("should sort windows by peak price (highest first)", function () {
-      const prices = [0.5, 1.0, 0.5, 0.5, 1.5, 0.5]; // Two separate peaks
-      const avgPrice = 0.75;
-      const windows = findExpensiveWindows(prices, avgPrice, 0);
-      expect(windows.length).to.equal(2);
-      expect(windows[0].peakPrice).to.be.greaterThan(windows[1].peakPrice);
-    });
-  });
-
   describe("createSchedule with negative prices", function () {
     it("should handle negative prices", function () {
       const prices = [
@@ -859,6 +770,7 @@ describe("strategy-smart-thermal-functions", function () {
         heatLossCoefficient: 0.05,
         minModeDuration: 15,
         minSavingsPercent: 0, // Allow any clustering
+        clusterPerDay: false, // Use global clustering for this test
       };
 
       const schedule = createSchedule(prices, 5, config);
@@ -871,4 +783,256 @@ describe("strategy-smart-thermal-functions", function () {
       expect(schedule[0].tuning.clustering.method).to.equal("ckmeans");
     });
   });
+
+  describe("Per-day clustering", function () {
+    describe("groupPricesByLocalDay", function () {
+      it("should group prices by local calendar day", function () {
+        const prices = [
+          { time: "2026-01-15T23:00:00Z", value: 100 }, // 00:00 Oslo = Jan 16
+          { time: "2026-01-16T00:00:00Z", value: 110 }, // 01:00 Oslo = Jan 16
+          { time: "2026-01-16T10:00:00Z", value: 120 }, // 11:00 Oslo = Jan 16
+          { time: "2026-01-16T23:00:00Z", value: 130 }, // 00:00 Oslo = Jan 17
+          { time: "2026-01-17T05:00:00Z", value: 140 }, // 06:00 Oslo = Jan 17
+        ];
+
+        const groups = groupPricesByLocalDay(prices, "Europe/Oslo");
+
+        expect(groups.size).to.equal(2);
+        expect(groups.get("2026-01-16")).to.have.length(3);
+        expect(groups.get("2026-01-17")).to.have.length(2);
+      });
+
+      it("should preserve original indices", function () {
+        const prices = [
+          { time: "2026-01-15T23:00:00Z", value: 100 },
+          { time: "2026-01-16T05:00:00Z", value: 110 },
+        ];
+
+        const groups = groupPricesByLocalDay(prices, "Europe/Oslo");
+        const day16 = groups.get("2026-01-16");
+
+        expect(day16[0].originalIndex).to.equal(0);
+        expect(day16[1].originalIndex).to.equal(1);
+      });
+    });
+
+    describe("mergePartialDays", function () {
+      it("should not merge days with enough intervals", function () {
+        const sortedDays = [
+          ["2026-01-15", [{ originalIndex: 0 }, { originalIndex: 1 }, { originalIndex: 2 }, { originalIndex: 3 }]],
+          ["2026-01-16", [{ originalIndex: 4 }, { originalIndex: 5 }, { originalIndex: 6 }, { originalIndex: 7 }]],
+        ];
+
+        const result = mergePartialDays(sortedDays, 4);
+
+        expect(result).to.have.length(2);
+        expect(result[0][0]).to.equal("2026-01-15");
+        expect(result[1][0]).to.equal("2026-01-16");
+      });
+
+      it("should merge small first day with next day", function () {
+        const sortedDays = [
+          ["2026-01-15", [{ originalIndex: 0 }, { originalIndex: 1 }]], // Too small
+          ["2026-01-16", [{ originalIndex: 2 }, { originalIndex: 3 }, { originalIndex: 4 }, { originalIndex: 5 }]],
+        ];
+
+        const result = mergePartialDays(sortedDays, 4);
+
+        expect(result).to.have.length(1);
+        expect(result[0][0]).to.equal("2026-01-15+2026-01-16");
+        expect(result[0][1]).to.have.length(6);
+      });
+
+      it("should merge small last day with previous day", function () {
+        const sortedDays = [
+          ["2026-01-15", [{ originalIndex: 0 }, { originalIndex: 1 }, { originalIndex: 2 }, { originalIndex: 3 }]],
+          ["2026-01-16", [{ originalIndex: 4 }, { originalIndex: 5 }]], // Too small
+        ];
+
+        const result = mergePartialDays(sortedDays, 4);
+
+        expect(result).to.have.length(1);
+        expect(result[0][0]).to.equal("2026-01-15+2026-01-16");
+        expect(result[0][1]).to.have.length(6);
+      });
+    });
+
+    describe("classifyPricesPerDay", function () {
+      it("should cluster each day independently", function () {
+        // Day 1: Low prices (50-100), Day 2: High prices (150-200)
+        const prices = [
+          // Day 1 (Oslo time) - all low prices
+          { time: "2026-01-15T23:00:00Z", value: 50 },  // Jan 16 00:00 Oslo
+          { time: "2026-01-16T02:00:00Z", value: 60 },  // Jan 16 03:00 Oslo
+          { time: "2026-01-16T05:00:00Z", value: 70 },  // Jan 16 06:00 Oslo
+          { time: "2026-01-16T08:00:00Z", value: 80 },  // Jan 16 09:00 Oslo
+          { time: "2026-01-16T11:00:00Z", value: 90 },  // Jan 16 12:00 Oslo
+          { time: "2026-01-16T14:00:00Z", value: 100 }, // Jan 16 15:00 Oslo
+          { time: "2026-01-16T17:00:00Z", value: 90 },  // Jan 16 18:00 Oslo
+          { time: "2026-01-16T20:00:00Z", value: 80 },  // Jan 16 21:00 Oslo
+          // Day 2 (Oslo time) - all high prices
+          { time: "2026-01-16T23:00:00Z", value: 150 }, // Jan 17 00:00 Oslo
+          { time: "2026-01-17T02:00:00Z", value: 160 }, // Jan 17 03:00 Oslo
+          { time: "2026-01-17T05:00:00Z", value: 170 }, // Jan 17 06:00 Oslo
+          { time: "2026-01-17T08:00:00Z", value: 180 }, // Jan 17 09:00 Oslo
+          { time: "2026-01-17T11:00:00Z", value: 190 }, // Jan 17 12:00 Oslo
+          { time: "2026-01-17T14:00:00Z", value: 200 }, // Jan 17 15:00 Oslo
+          { time: "2026-01-17T17:00:00Z", value: 190 }, // Jan 17 18:00 Oslo
+          { time: "2026-01-17T20:00:00Z", value: 180 }, // Jan 17 21:00 Oslo
+        ];
+
+        const result = classifyPricesPerDay(prices, "Europe/Oslo", 5, 3, 4);
+
+        expect(result.assignments).to.have.length(16);
+        expect(result.dailyClustering).to.have.length(2);
+
+        // Each day should have its own clustering
+        expect(result.dailyClustering[0].date).to.equal("2026-01-16");
+        expect(result.dailyClustering[1].date).to.equal("2026-01-17");
+
+        // Day 1: 50 should be cheapest (boost=0), 100 should be expensive (coast=2)
+        expect(result.assignments[0]).to.equal(0); // 50 = boost
+        expect(result.assignments[5]).to.equal(2); // 100 = coast
+
+        // Day 2: 150 should be cheapest (boost=0), 200 should be expensive (coast=2)
+        expect(result.assignments[8]).to.equal(0);  // 150 = boost (for day 2!)
+        expect(result.assignments[13]).to.equal(2); // 200 = coast
+      });
+
+      it("should include per-day stats in dailyClustering", function () {
+        const prices = [
+          { time: "2026-01-15T23:00:00Z", value: 50 },
+          { time: "2026-01-16T02:00:00Z", value: 60 },
+          { time: "2026-01-16T05:00:00Z", value: 70 },
+          { time: "2026-01-16T08:00:00Z", value: 80 },
+          { time: "2026-01-16T11:00:00Z", value: 90 },
+          { time: "2026-01-16T14:00:00Z", value: 100 },
+          { time: "2026-01-16T17:00:00Z", value: 90 },
+          { time: "2026-01-16T20:00:00Z", value: 80 },
+        ];
+
+        const result = classifyPricesPerDay(prices, "Europe/Oslo", 0, 3, 4);
+
+        expect(result.dailyClustering[0]).to.have.property("avgPrice");
+        expect(result.dailyClustering[0]).to.have.property("minPrice");
+        expect(result.dailyClustering[0]).to.have.property("maxPrice");
+        expect(result.dailyClustering[0]).to.have.property("breaks");
+        expect(result.dailyClustering[0]).to.have.property("clusterMeans");
+        expect(result.dailyClustering[0].minPrice).to.equal(50);
+        expect(result.dailyClustering[0].maxPrice).to.equal(100);
+      });
+    });
+
+    describe("createSchedule with clusterPerDay", function () {
+      it("should use per-day clustering by default", function () {
+        // Day 1: prices 50-100, Day 2: prices 150-200
+        const prices = [
+          { time: "2026-01-15T23:00:00Z", value: 50 },
+          { time: "2026-01-16T02:00:00Z", value: 75 },
+          { time: "2026-01-16T05:00:00Z", value: 100 },
+          { time: "2026-01-16T08:00:00Z", value: 75 },
+          { time: "2026-01-16T11:00:00Z", value: 50 },
+          { time: "2026-01-16T14:00:00Z", value: 75 },
+          { time: "2026-01-16T17:00:00Z", value: 100 },
+          { time: "2026-01-16T20:00:00Z", value: 75 },
+          { time: "2026-01-16T23:00:00Z", value: 150 },
+          { time: "2026-01-17T02:00:00Z", value: 175 },
+          { time: "2026-01-17T05:00:00Z", value: 200 },
+          { time: "2026-01-17T08:00:00Z", value: 175 },
+          { time: "2026-01-17T11:00:00Z", value: 150 },
+          { time: "2026-01-17T14:00:00Z", value: 175 },
+          { time: "2026-01-17T17:00:00Z", value: 200 },
+          { time: "2026-01-17T20:00:00Z", value: 175 },
+        ];
+
+        const config = {
+          heatLossCoefficient: 0.05,
+          minModeDuration: 60,
+          minSavingsPercent: 0,
+          // clusterPerDay defaults to true
+        };
+
+        const schedule = createSchedule(prices, 5, config);
+
+        expect(schedule[0].tuning.clusterPerDay).to.equal(true);
+        expect(schedule[0].tuning.clustering.method).to.equal("ckmeans-per-day");
+        expect(schedule[0].tuning.clustering).to.have.property("dailyClustering");
+        expect(schedule[0].tuning.clustering.dailyClustering).to.have.length(2);
+      });
+
+      it("should use global clustering when clusterPerDay is false", function () {
+        const prices = [
+          { time: "2026-01-15T23:00:00Z", value: 50 },
+          { time: "2026-01-16T02:00:00Z", value: 75 },
+          { time: "2026-01-16T05:00:00Z", value: 100 },
+          { time: "2026-01-16T08:00:00Z", value: 75 },
+          { time: "2026-01-16T11:00:00Z", value: 50 },
+          { time: "2026-01-16T14:00:00Z", value: 75 },
+          { time: "2026-01-16T17:00:00Z", value: 100 },
+          { time: "2026-01-16T20:00:00Z", value: 75 },
+        ];
+
+        const config = {
+          heatLossCoefficient: 0.05,
+          minModeDuration: 60,
+          minSavingsPercent: 0,
+          clusterPerDay: false,
+        };
+
+        const schedule = createSchedule(prices, 5, config);
+
+        expect(schedule[0].tuning.clusterPerDay).to.equal(false);
+        expect(schedule[0].tuning.clustering.method).to.equal("ckmeans");
+        expect(schedule[0].tuning.clustering).to.not.have.property("dailyClustering");
+      });
+
+      it("should find boost/coast on EACH day with per-day clustering", function () {
+        // This is the key test: without per-day clustering, day 1's prices
+        // would all be "normal" compared to day 2's higher prices.
+        // With per-day clustering, each day gets its own boost/coast hours.
+        const prices = [
+          // Day 1: Low price range (50-100)
+          { time: "2026-01-15T23:00:00Z", value: 50 },  // Cheapest on day 1
+          { time: "2026-01-16T02:00:00Z", value: 75 },
+          { time: "2026-01-16T05:00:00Z", value: 100 }, // Most expensive on day 1
+          { time: "2026-01-16T08:00:00Z", value: 75 },
+          { time: "2026-01-16T11:00:00Z", value: 50 },  // Cheapest on day 1
+          { time: "2026-01-16T14:00:00Z", value: 75 },
+          { time: "2026-01-16T17:00:00Z", value: 100 }, // Most expensive on day 1
+          { time: "2026-01-16T20:00:00Z", value: 75 },
+          // Day 2: High price range (150-200)
+          { time: "2026-01-16T23:00:00Z", value: 150 }, // Cheapest on day 2
+          { time: "2026-01-17T02:00:00Z", value: 175 },
+          { time: "2026-01-17T05:00:00Z", value: 200 }, // Most expensive on day 2
+          { time: "2026-01-17T08:00:00Z", value: 175 },
+          { time: "2026-01-17T11:00:00Z", value: 150 }, // Cheapest on day 2
+          { time: "2026-01-17T14:00:00Z", value: 175 },
+          { time: "2026-01-17T17:00:00Z", value: 200 }, // Most expensive on day 2
+          { time: "2026-01-17T20:00:00Z", value: 175 },
+        ];
+
+        const config = {
+          heatLossCoefficient: 0.02, // Well-insulated building (long coast time)
+          minModeDuration: 60,
+          minSavingsPercent: 0,
+          clusterPerDay: true,
+        };
+
+        const schedule = createSchedule(prices, 5, config);
+
+        // Count modes per day
+        const day1Modes = schedule.slice(0, 8).map(s => s.mode);
+        const day2Modes = schedule.slice(8, 16).map(s => s.mode);
+
+        // Day 1 should have some boost (at price 50) and some coast (at price 100)
+        expect(day1Modes).to.include("boost");
+        expect(day1Modes).to.include("coast");
+
+        // Day 2 should ALSO have boost (at price 150) and coast (at price 200)
+        // This is the key difference from global clustering!
+        expect(day2Modes).to.include("boost");
+        expect(day2Modes).to.include("coast");
+      });
+    });
+  });
 });

package/test/strategy-smart-thermal-node.test.js

@@ -24,21 +24,16 @@ describe("ps-strategy-smart-thermal node", function () {
     });
   });
 
-  it("should output current setpoint on output 1", function (done) {
+  it("should output current mode on output 1", function (done) {
     const flow = [
       {
-        id: "n1",
-        type: "ps-strategy-smart-thermal",
-        name: "thermal test",
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
-        heatLossCoefficient: 0.05,
-        peakThreshold: 20,
-        intervalMinutes: 60,
-        sendSchedule: true,
-        wires: [["n2"], ["n3"]],
-      },
+        id: "n1",
+        type: "ps-strategy-smart-thermal",
+        name: "thermal test",
+        heatLossCoefficient: 0.05,
+        sendSchedule: true,
+        wires: [["n2"], ["n3"]],
+      },
       { id: "n2", type: "helper" },
       { id: "n3", type: "helper" },
     ];
@@ -75,18 +70,13 @@ describe("ps-strategy-smart-thermal node", function () {
   it("should output schedule on output 2 when sendSchedule is true", function (done) {
     const flow = [
       {
-        id: "n1",
-        type: "ps-strategy-smart-thermal",
-        name: "thermal test",
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
-        heatLossCoefficient: 0.05,
-        peakThreshold: 20,
-        intervalMinutes: 60,
-        sendSchedule: true,
-        wires: [["n2"], ["n3"]],
-      },
+        id: "n1",
+        type: "ps-strategy-smart-thermal",
+        name: "thermal test",
+        heatLossCoefficient: 0.05,
+        sendSchedule: true,
+        wires: [["n2"], ["n3"]],
+      },
       { id: "n2", type: "helper" },
       { id: "n3", type: "helper" },
     ];
@@ -235,14 +225,11 @@ describe("ps-strategy-smart-thermal node", function () {
   it("should ignore message not for this node", function (done) {
     const flow = [
       {
-        id: "n1",
-        type: "ps-strategy-smart-thermal",
-        name: "thermal test",
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
-        wires: [["n2"], ["n3"]],
-      },
+        id: "n1",
+        type: "ps-strategy-smart-thermal",
+        name: "thermal test",
+        wires: [["n2"], ["n3"]],
+      },
       { id: "n2", type: "helper" },
       { id: "n3", type: "helper" },
     ];
@@ -274,14 +261,11 @@ describe("ps-strategy-smart-thermal node", function () {
   it("should warn when price data is missing", function (done) {
     const flow = [
       {
-        id: "n1",
-        type: "ps-strategy-smart-thermal",
-        name: "thermal test",
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
-        wires: [["n2"], ["n3"]],
-      },
+        id: "n1",
+        type: "ps-strategy-smart-thermal",
+        name: "thermal test",
+        wires: [["n2"], ["n3"]],
+      },
       { id: "n2", type: "helper" },
       { id: "n3", type: "helper" },
     ];
@@ -312,14 +296,11 @@ describe("ps-strategy-smart-thermal node", function () {
   it("should warn when outdoor temperature is missing", function (done) {
     const flow = [
       {
-        id: "n1",
-        type: "ps-strategy-smart-thermal",
-        name: "thermal test",
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
-        wires: [["n2"], ["n3"]],
-      },
+        id: "n1",
+        type: "ps-strategy-smart-thermal",
+        name: "thermal test",
+        wires: [["n2"], ["n3"]],
+      },
       { id: "n2", type: "helper" },
       { id: "n3", type: "helper" },
     ];
@@ -350,15 +331,12 @@ describe("ps-strategy-smart-thermal node", function () {
   it("should allow config override via message", function (done) {
     const flow = [
       {
-        id: "n1",
-        type: "ps-strategy-smart-thermal",
-        name: "thermal test",
-        setpoint: 22,
-        comfortMin: 20,
-        comfortMax: 24,
-        heatLossCoefficient: 0.05,
-        wires: [["n2"], ["n3"]],
-      },
+        id: "n1",
+        type: "ps-strategy-smart-thermal",
+        name: "thermal test",
+        heatLossCoefficient: 0.05,
+        wires: [["n2"], ["n3"]],
+      },
       { id: "n2", type: "helper" },
       { id: "n3", type: "helper" },
     ];