@energiok/node-red-contrib-pricecontrol-thermal 1.2.1 → 1.2.3

package/DASHBOARD-TEMPLATE-3-MODES.md

@@ -282,7 +282,7 @@ export default {
 2. **Boost** (Green) - Pre-heat when prices are significantly cheap AND there's an upcoming peak
 3. **Coast** (Red) - Turn off when prices are significantly expensive
 
-**Thresholds that control behavior:**
-- `minCoastSaving`: Only coast if price is 10+ øre/kWh above average
-- `minBoostSaving`: Only boost if price is 10+ øre/kWh below average
-- This prevents mode switching for trivial price differences!
+**Thresholds that control behavior:**
+- `minSavingsPercent`: Minimum price variation before coast/boost activates
+- `minModeDuration`: Minimum minutes per mode to prevent short cycling
+- `numPriceGroups`: 3-5 price clusters (more groups = narrower boost/coast)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@energiok/node-red-contrib-pricecontrol-thermal",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "private": false,
   "publishConfig": {
     "access": "restricted"

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

@@ -249,6 +249,141 @@ function classifyPricesWithCkmeans(prices, minVariationPercent = 2, numGroups =
   };
 }
 
+// ============================================================================
+// Per-Day Clustering Functions
+// ============================================================================
+
+/**
+ * Group price data by local calendar day
+ * @param {Array} validPrices - Array of {time, value} price data (UTC timestamps)
+ * @param {string} outputTimezone - IANA timezone for day boundaries (e.g., "Europe/Oslo")
+ * @returns {Map<string, Array<{originalIndex: number, time: string, value: number}>>}
+ */
+function groupPricesByLocalDay(validPrices, outputTimezone) {
+  const dayGroups = new Map();
+
+  for (let i = 0; i < validPrices.length; i++) {
+    const utcTime = DateTime.fromISO(validPrices[i].time, { zone: "UTC" });
+    const localTime = utcTime.setZone(outputTimezone);
+    const dayKey = localTime.toISODate(); // "YYYY-MM-DD"
+
+    if (!dayGroups.has(dayKey)) {
+      dayGroups.set(dayKey, []);
+    }
+    dayGroups.get(dayKey).push({
+      originalIndex: i,
+      time: validPrices[i].time,
+      value: validPrices[i].value,
+    });
+  }
+
+  return dayGroups;
+}
+
+/**
+ * Merge partial days (too few intervals) with adjacent full days
+ * @param {Array} sortedDays - Array of [dayKey, prices] tuples sorted by date
+ * @param {number} minIntervals - Minimum intervals to be considered a full day
+ * @returns {Array} Merged array of [dayKey, prices] tuples
+ */
+function mergePartialDays(sortedDays, minIntervals) {
+  if (sortedDays.length <= 1) return sortedDays;
+
+  const result = [];
+  let pendingMerge = null;
+
+  for (let i = 0; i < sortedDays.length; i++) {
+    const [dayKey, prices] = sortedDays[i];
+
+    if (pendingMerge) {
+      // Merge pending partial day with current day
+      const mergedKey = `${pendingMerge[0]}+${dayKey}`;
+      const mergedPrices = [...pendingMerge[1], ...prices];
+
+      if (mergedPrices.length >= minIntervals) {
+        result.push([mergedKey, mergedPrices]);
+        pendingMerge = null;
+      } else {
+        // Still too small, keep as pending
+        pendingMerge = [mergedKey, mergedPrices];
+      }
+    } else if (prices.length < minIntervals) {
+      // This day is too small, mark for merging
+      if (i === sortedDays.length - 1 && result.length > 0) {
+        // Last day, merge with previous
+        const prev = result.pop();
+        result.push([`${prev[0]}+${dayKey}`, [...prev[1], ...prices]]);
+      } else {
+        // Not last day, merge with next
+        pendingMerge = [dayKey, prices];
+      }
+    } else {
+      result.push([dayKey, prices]);
+    }
+  }
+
+  // Handle any remaining pending merge
+  if (pendingMerge) {
+    if (result.length > 0) {
+      const prev = result.pop();
+      result.push([`${prev[0]}+${pendingMerge[0]}`, [...prev[1], ...pendingMerge[1]]]);
+    } else {
+      result.push(pendingMerge);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Perform clustering for each day separately
+ * @param {Array} validPrices - Array of {time, value} price data
+ * @param {string} outputTimezone - Timezone for day boundaries
+ * @param {number} variationThreshold - Minimum variation % for clustering
+ * @param {number} numGroups - Number of price groups (3-5)
+ * @param {number} minIntervalsPerDay - Minimum intervals to cluster a day separately (default 8)
+ * @returns {object} { assignments: number[], dailyClustering: Array }
+ */
+function classifyPricesPerDay(validPrices, outputTimezone, variationThreshold, numGroups, minIntervalsPerDay = 8) {
+  const dayGroups = groupPricesByLocalDay(validPrices, outputTimezone);
+  const assignments = new Array(validPrices.length).fill(Math.floor(numGroups / 2)); // Default: normal
+  const dailyClustering = [];
+
+  // Convert to array and sort by date
+  const sortedDays = [...dayGroups.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+
+  // Merge small partial days with adjacent days
+  const mergedDays = mergePartialDays(sortedDays, minIntervalsPerDay);
+
+  for (const [dayKey, dayPrices] of mergedDays) {
+    const priceValues = dayPrices.map((p) => p.value);
+
+    // Cluster this day's prices
+    const clustering = classifyPricesWithCkmeans(priceValues, variationThreshold, numGroups);
+
+    // Map assignments back to original indices
+    for (let i = 0; i < dayPrices.length; i++) {
+      assignments[dayPrices[i].originalIndex] = clustering.assignments[i];
+    }
+
+    // Record per-day tuning info
+    const avgPrice = priceValues.reduce((a, b) => a + b, 0) / priceValues.length;
+    dailyClustering.push({
+      date: dayKey,
+      breaks: clustering.breaks,
+      clusterMeans: clustering.clusterMeans,
+      cheapThreshold: clustering.breaks[0] ?? avgPrice * 0.95,
+      expensiveThreshold: clustering.breaks[clustering.breaks.length - 1] ?? avgPrice * 1.05,
+      priceCount: dayPrices.length,
+      avgPrice,
+      minPrice: Math.min(...priceValues),
+      maxPrice: Math.max(...priceValues),
+    });
+  }
+
+  return { assignments, dailyClustering };
+}
+
 // ============================================================================
 // Thermal Calculations
 // ============================================================================
@@ -294,50 +429,49 @@ function calculateCoastTime(indoorTemp, outdoorTemp, comfortMin, heatLossCoeffic
 }
 
 /**
- * Identify price peaks (top X% of prices)
- * @param {Array} prices - Array of price objects with {time, value}
- * @param {number} topPercentage - Percentage threshold for peaks (default 20)
- * @returns {Array<boolean>} Boolean array marking peak periods
+ * Calculate how long boosted heat will be retained before dropping to comfort minimum
+ * @param {number} outdoorTemp - Outdoor temperature (°C)
+ * @param {number} comfortMax - Maximum comfort temperature after boost (°C)
+ * @param {number} comfortMin - Minimum comfort temperature (°C)
+ * @param {number} heatLossCoefficient - Building heat loss rate
+ * @returns {number} Retention time in minutes
  */
-function findPeaks(prices, topPercentage = 20) {
-  if (!prices || prices.length === 0) {
-    return [];
+function calculateBoostRetention(outdoorTemp, comfortMax, comfortMin, heatLossCoefficient) {
+  // Boost duration should INCREASE in cold weather (building needs more heat)
+  // and DECREASE in mild weather (risk of overheating)
+  //
+  // Logic: In cold weather, we want to store more thermal energy during cheap hours
+  // because we'll need it. In mild weather, limit boost to avoid overshooting comfort.
+  //
+  // Base: 2 hours at 10°C (mild), scaling up to 6 hours at -20°C (very cold)
+  const baseBoostMinutes = 120; // 2 hours minimum
+  const maxBoostMinutes = 360; // 6 hours maximum
+
+  // Reference temperatures for scaling
+  const mildTemp = 10; // At this temp or above, use base boost
+  const coldTemp = -20; // At this temp or below, use max boost
+
+  if (outdoorTemp >= mildTemp) {
+    return baseBoostMinutes;
   }
 
-  const sorted = [...prices].sort((a, b) => b.value - a.value);
-  const thresholdIndex = Math.floor((prices.length * topPercentage) / 100);
-  const threshold = sorted[thresholdIndex]?.value ?? Infinity;
-
-  return prices.map((p) => p.value >= threshold);
-}
-
-/**
- * Identify price troughs (bottom X% of prices)
- * @param {Array} prices - Array of price objects with {time, value}
- * @param {number} bottomPercentage - Percentage threshold for troughs (default 20)
- * @returns {Array<boolean>} Boolean array marking trough periods
- */
-function findTroughs(prices, bottomPercentage = 20) {
-  if (!prices || prices.length === 0) {
-    return [];
+  if (outdoorTemp <= coldTemp) {
+    return maxBoostMinutes;
   }
 
-  const sorted = [...prices].sort((a, b) => a.value - b.value);
-  const thresholdIndex = Math.floor((prices.length * bottomPercentage) / 100);
-  const threshold = sorted[thresholdIndex]?.value ?? -Infinity;
+  // Linear interpolation between mild and cold
+  const tempRange = mildTemp - coldTemp; // 30 degrees
+  const tempBelow = mildTemp - outdoorTemp; // How far below mild
+  const boostRange = maxBoostMinutes - baseBoostMinutes; // 240 minutes
 
-  return prices.map((p) => p.value <= threshold);
+  return baseBoostMinutes + (boostRange * tempBelow) / tempRange;
 }
 
 /**
- * Calculate how long boosted heat will be retained before dropping to comfort minimum
- * @param {number} outdoorTemp - Outdoor temperature (°C)
- * @param {number} comfortMax - Maximum comfort temperature after boost (°C)
- * @param {number} comfortMin - Minimum comfort temperature (°C)
- * @param {number} heatLossCoefficient - Building heat loss rate
- * @returns {number} Retention time in minutes
+ * Legacy calculation - kept for reference but no longer used
+ * Calculates heat retention based on thermal loss (inverse of what we want)
  */
-function calculateBoostRetention(outdoorTemp, comfortMax, comfortMin, heatLossCoefficient) {
+function calculateBoostRetentionLegacy(outdoorTemp, comfortMax, comfortMin, heatLossCoefficient) {
   const tempBuffer = comfortMax - comfortMin;
   const tempDelta = comfortMax - outdoorTemp;
   const heatLossRate = tempDelta * heatLossCoefficient;
@@ -347,52 +481,9 @@ function calculateBoostRetention(outdoorTemp, comfortMax, comfortMin, heatLossCo
   return (tempBuffer / heatLossRate) * 60; // Convert hours to minutes
 }
 
-// ============================================================================
-// Price Analysis
-// ============================================================================
-
-/**
- * Find contiguous windows of expensive prices (above threshold)
- * @param {Array} prices - Array of price values
- * @param {number} avgPrice - Average price
- * @param {number} minSavingsThreshold - Minimum savings to consider (absolute value)
- * @returns {Array} Array of {start, end, totalSavings, peakPrice} windows sorted by peak price
- */
-function findExpensiveWindows(prices, avgPrice, minSavingsThreshold = 0) {
-  const windows = [];
-  let i = 0;
-
-  // Threshold for considering a price "expensive"
-  const expensiveThreshold = avgPrice + minSavingsThreshold;
-
-  while (i < prices.length) {
-    if (prices[i] > expensiveThreshold) {
-      const start = i;
-      let totalSavings = 0;
-      let peakPrice = prices[i];
-
-      while (i < prices.length && prices[i] > expensiveThreshold) {
-        totalSavings += prices[i] - avgPrice;
-        peakPrice = Math.max(peakPrice, prices[i]);
-        i++;
-      }
-
-      windows.push({
-        start,
-        end: i - 1,
-        length: i - start,
-        totalSavings,
-        peakPrice,
-        avgSavingsPerHour: totalSavings / (i - start),
-      });
-    } else {
-      i++;
-    }
-  }
-
-  // Sort windows by peak price (highest first) - prioritize biggest peaks
-  return windows.sort((a, b) => b.peakPrice - a.peakPrice);
-}
+// Remove the legacy function from export but keep for backwards compat if called directly
+// eslint-disable-next-line no-unused-vars
+const _legacyBoostRetention = calculateBoostRetentionLegacy;
 
 // ============================================================================
 // Schedule Generation
@@ -454,6 +545,7 @@ function createSchedule(prices, outdoorTemp, config) {
     numPriceGroups = 3, // Number of price clusters (3-5). More groups = narrower boost/coast bands
     extremeWeatherThreshold = -15, // Disable coasting below this outdoor temp
     outputTimezone = "Europe/Oslo", // Timezone for schedule output (IANA timezone name)
+    clusterPerDay = true, // Cluster prices per day (true) or globally across all days (false)
   } = validatedConfig;
 
   const n = validPrices.length;
@@ -486,13 +578,56 @@ function createSchedule(prices, outdoorTemp, config) {
   // Use Ckmeans clustering to find natural price breaks
   // Use effectiveVariationThreshold as minimum variation - if prices don't vary
   // by at least this much, treat everything as normal (no boost/coast)
-  const clustering = classifyPricesWithCkmeans(priceValues, effectiveVariationThreshold, effectiveNumGroups);
-  const { assignments, breaks, clusterMeans } = clustering;
+  let assignments;
+  let breaks;
+  let clusterMeans;
+  let dailyClusteringInfo = null;
+
+  // Minimum intervals per day for separate clustering (at least 2 hours of data)
+  const minIntervalsPerDay = Math.ceil(120 / intervalMinutes);
+
+  if (clusterPerDay && n >= minIntervalsPerDay) {
+    // Per-day clustering: each day's prices evaluated relative to that day
+    const perDayResult = classifyPricesPerDay(
+      validPrices,
+      outputTimezone,
+      effectiveVariationThreshold,
+      effectiveNumGroups,
+      minIntervalsPerDay
+    );
+
+    assignments = perDayResult.assignments;
+    dailyClusteringInfo = perDayResult.dailyClustering;
+
+    // Use first day's clustering info for breaks/clusterMeans (for backward compatibility)
+    // but calculate aggregate thresholds for coast extension logic
+    if (dailyClusteringInfo.length > 0) {
+      breaks = dailyClusteringInfo[0].breaks;
+      clusterMeans = dailyClusteringInfo[0].clusterMeans;
+    } else {
+      breaks = [];
+      clusterMeans = [];
+    }
+  } else {
+    // Global clustering: all prices across all days clustered together (original behavior)
+    const clustering = classifyPricesWithCkmeans(priceValues, effectiveVariationThreshold, effectiveNumGroups);
+    assignments = clustering.assignments;
+    breaks = clustering.breaks;
+    clusterMeans = clustering.clusterMeans;
+  }
 
   // First break = threshold between cheapest (boost) and next group
   // Last break = threshold between second-most-expensive and most expensive (coast)
-  const cheapThreshold = breaks[0] ?? avgPrice * 0.95;
-  const expensiveThreshold = breaks[breaks.length - 1] ?? avgPrice * 1.05;
+  // For per-day clustering, use aggregate thresholds across all days
+  let cheapThreshold, expensiveThreshold;
+  if (dailyClusteringInfo && dailyClusteringInfo.length > 0) {
+    // Use the most conservative thresholds across all days for coast extension
+    cheapThreshold = Math.min(...dailyClusteringInfo.map((d) => d.cheapThreshold));
+    expensiveThreshold = Math.max(...dailyClusteringInfo.map((d) => d.expensiveThreshold));
+  } else {
+    cheapThreshold = breaks[0] ?? avgPrice * 0.95;
+    expensiveThreshold = breaks[breaks.length - 1] ?? avgPrice * 1.05;
+  }
 
   // Calculate minimum savings threshold (for tuning info)
   const minSavingsThreshold = avgPrice * (effectiveMinSavingsPercent / 100);
@@ -593,17 +728,30 @@ function createSchedule(prices, outdoorTemp, config) {
       minModeDuration,
       outputTimezone,
       // Ckmeans clustering info
-      clustering: {
-        numGroups: effectiveNumGroups,
-        cheapThreshold,
-        expensiveThreshold,
-        breaks,
-        clusterMeans,
-        method: "ckmeans",
-        rawBoostCount: assignments.filter((a) => a === 0).length,
-        rawNormalCount: assignments.filter((a) => a !== 0 && a !== lastGroup).length,
-        rawCoastCount: assignments.filter((a) => a === lastGroup).length,
-      },
+      clusterPerDay,
+      clustering: dailyClusteringInfo
+        ? {
+            method: "ckmeans-per-day",
+            numGroups: effectiveNumGroups,
+            numDays: dailyClusteringInfo.length,
+            aggregateCheapThreshold: cheapThreshold,
+            aggregateExpensiveThreshold: expensiveThreshold,
+            dailyClustering: dailyClusteringInfo,
+            rawBoostCount: assignments.filter((a) => a === 0).length,
+            rawNormalCount: assignments.filter((a) => a !== 0 && a !== lastGroup).length,
+            rawCoastCount: assignments.filter((a) => a === lastGroup).length,
+          }
+        : {
+            numGroups: effectiveNumGroups,
+            cheapThreshold,
+            expensiveThreshold,
+            breaks,
+            clusterMeans,
+            method: "ckmeans",
+            rawBoostCount: assignments.filter((a) => a === 0).length,
+            rawNormalCount: assignments.filter((a) => a !== 0 && a !== lastGroup).length,
+            rawCoastCount: assignments.filter((a) => a === lastGroup).length,
+          },
       // Final mode counts after thermal constraints and min duration enforcement
       finalModeCount: modeCount,
       validationIssues: validatedConfig.validationIssues,
@@ -926,64 +1074,6 @@ function alignToHourlyBoundaries(modes, prices, intervalMinutes, outputTimezone)
   return result;
 }
 
-/**
- * Enforce maximum coast duration based on outdoor temperature
- * Splits long coast periods into coast + normal to prevent excessive temperature drop
- * @param {Array<string>} modes - Array of mode strings
- * @param {number} intervalMinutes - Minutes per interval
- * @param {number} maxCoastMinutes - Maximum safe coast time based on outdoor temp
- * @returns {Array<string>} Adjusted modes with coast duration limited
- */
-function enforceMaxCoastDuration(modes, intervalMinutes, maxCoastMinutes) {
-  if (modes.length === 0 || maxCoastMinutes <= 0) return modes;
-
-  const maxCoastIntervals = Math.ceil(maxCoastMinutes / intervalMinutes);
-  const result = [...modes];
-
-  // Find all coast runs
-  let i = 0;
-  while (i < result.length) {
-    if (result[i] === "coast") {
-      // Found start of coast run
-      let coastLength = 1;
-      while (i + coastLength < result.length && result[i + coastLength] === "coast") {
-        coastLength++;
-      }
-
-      // If coast run exceeds maximum, split it
-      if (coastLength > maxCoastIntervals) {
-        // Keep first maxCoastIntervals as coast, convert rest to normal
-        for (let j = i + maxCoastIntervals; j < i + coastLength; j++) {
-          result[j] = "normal";
-        }
-      }
-
-      i += coastLength;
-    } else {
-      i++;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Find the next peak within a certain number of intervals
- * @param {Array<boolean>} peaks - Boolean array marking peaks
- * @param {number} currentIndex - Current position
- * @param {number} lookAheadIntervals - How many intervals to look ahead
- * @returns {number} Index of next peak, or -1 if none found
- */
-function findNextPeak(peaks, currentIndex, lookAheadIntervals) {
-  const maxIndex = Math.min(currentIndex + lookAheadIntervals, peaks.length);
-  for (let i = currentIndex + 1; i < maxIndex; i++) {
-    if (peaks[i]) {
-      return i;
-    }
-  }
-  return -1;
-}
-
 /**
  * Get current mode from schedule
  *
@@ -1039,17 +1129,16 @@ function getCurrentMode(schedule, currentTime) {
 module.exports = {
   calculateCoastTime,
   calculateBoostRetention,
-  findPeaks,
-  findTroughs,
-  findExpensiveWindows,
   createSchedule,
   getCurrentMode,
   enforceMinimumDurations,
-  enforceMaxCoastDuration,
   extendCoastToRunway,
   applyRightAlignedWindows,
   alignToHourlyBoundaries,
   validateConfig,
   ckmeans,
   classifyPricesWithCkmeans,
+  groupPricesByLocalDay,
+  mergePartialDays,
+  classifyPricesPerDay,
 };

package/src/strategy-smart-thermal.js

@@ -101,6 +101,7 @@ module.exports = function (RED) {
       outputTimezone: config.outputTimezone || "Europe/Oslo",
       extremeWeatherThreshold: toFiniteNumber(config.extremeWeatherThreshold, -15),
       sendSchedule: config.sendSchedule !== false,
+      clusterPerDay: config.clusterPerDay !== false, // Default true: cluster prices per day
     };
     saveOriginalConfig(node, originalConfig);
 
@@ -132,6 +133,7 @@ module.exports = function (RED) {
             msg.payload?.extremeWeatherThreshold,
             storedConfig.extremeWeatherThreshold
           ),
+          clusterPerDay: msg.payload?.clusterPerDay ?? storedConfig.clusterPerDay,
         };
 
         // Extract price data (supports multiple formats)