Energy demand profile: improve prediction accuracy for heating loadpoints

api/feature.go

@@ -4,19 +4,21 @@ type Feature int
 
 //go:generate go tool enumer -type Feature -text
 const (
-	_                  Feature = iota
-	CoarseCurrent              // charger
-	IntegratedDevice           // charger - always connected - no vehicle, no charging sessions
-	SwitchDevice               // charger - no current control - heat pumps or switch sockets
-	Heating                    // charger - heating device - soc ist temperature (°C)
-	Continuous                 // charger - heating device where disabled means "normal operation"
-	Average                    // tariff
-	Cacheable                  // tariff
-	Offline                    // vehicle
-	Retryable                  // vehicle
-	Streaming                  // vehicle
-	WelcomeCharge              // vehicle
-	ClimaterDisabled           // vehicle - ignore climater state for charge control
-	AutodetectDisabled         // vehicle - do not try to identify vehicle by status
-	WakeUpDisabled             // vehicle - do not send wake-up calls
+	_                           Feature = iota
+	CoarseCurrent                       // charger
+	IntegratedDevice                    // charger - always connected - no vehicle, no charging sessions
+	SwitchDevice                        // charger - no current control - heat pumps or switch sockets
+	Heating                             // charger - heating device - soc ist temperature (°C)
+	PredictorProfileSameWeekday         // charger - demand forecast: same weekday last week (warm water)
+	PredictorProfileTemperature         // charger - demand forecast: daily avg scaled by outdoor temp (room heating)
+	Continuous                          // charger - heating device where disabled means "normal operation"
+	Average                             // tariff
+	Cacheable                           // tariff
+	Offline                             // vehicle
+	Retryable                           // vehicle
+	Streaming                           // vehicle
+	WelcomeCharge                       // vehicle
+	ClimaterDisabled                    // vehicle - ignore climater state for charge control
+	AutodetectDisabled                  // vehicle - do not try to identify vehicle by status
+	WakeUpDisabled                      // vehicle - do not send wake-up calls
 )

assets/js/types/evcc.ts

@@ -575,6 +575,10 @@ export interface Loadpoint {
   chargerFeatureCoarseCurrent: boolean;
   /** Charger is a heating device where disabled means normal operation. */
   chargerFeatureContinuous: boolean;
+  /** Heating device demand forecast uses daily average profile scaled by outdoor temperature. */
+  chargerFeaturePredictorProfileTemperature: boolean;
+  /** Heating device demand forecast uses same-weekday average over past 4 weeks. */
+  chargerFeaturePredictorProfileSameWeekday: boolean;
   /** Charger is a heating device. SoC values represent temperature in degrees. */
   chargerFeatureHeating: boolean;
   /** Charger is an always-connected device without vehicles and charging sessions, like a heat pump. */

core/loadpoint_load_predictor.go

@@ -0,0 +1,39 @@
+package core
+
+import (
+	"time"
+
+	"github.com/evcc-io/evcc/api"
+)
+
+// demandProfile returns the heating demand profile of a heating loadpoint and whether
+// it needs to be scaled by the outdoor temperature forecast. Returns nil when unavailable.
+func (lp *Loadpoint) demandProfile(from time.Time) (*[96]float64, bool) {
+	if lp.chargeEnergy == nil || !lp.chargerHasFeature(api.Heating) {
+		return nil, false
+	}
+
+	var profile *[96]float64
+	var err error
+
+	// daily avg scaled by outdoor temp
+	temp := lp.chargerHasFeature(api.PredictorProfileTemperature)
+
+	switch {
+	case temp:
+		profile, err = lp.chargeEnergy.EnergyProfile(from)
+
+	case lp.chargerHasFeature(api.PredictorProfileSameWeekday):
+		profile, err = lp.chargeEnergy.EnergyProfileWeekday(time.Now().Weekday())
+
+	default:
+		return nil, false
+	}
+
+	if err != nil {
+		lp.log.DEBUG.Printf("demand profile: %v", err)
+		return nil, false
+	}
+
+	return profile, temp
+}

core/metrics/collector.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/evcc-io/evcc/server/db"
 	"github.com/evcc-io/evcc/tariff"
+	"github.com/jinzhu/now"
 )
 
 const (
@@ -173,7 +174,13 @@ func (c *Collector) SetSocTemp(value float64, isTemp bool) error {
 }
 
 func (c *Collector) EnergyProfile(from time.Time) (*[96]float64, error) {
-	return energyProfile(c.entity, from)
+	return energyProfileFiltered(c.entity, from, nil)
+}
+
+func (c *Collector) EnergyProfileWeekday(weekday time.Weekday) (*[96]float64, error) {
+	wd := int(weekday)
+	from := now.BeginningOfDay().AddDate(0, 0, -28)
+	return energyProfileFiltered(c.entity, from, &wd)
 }
 
 // LastSlotEnergy returns the energy in kWh of the most recently completed

core/metrics/db_profile.go

@@ -10,21 +10,30 @@ import (
 
 var ErrIncomplete = errors.New("meter profile incomplete")
 
-// energyProfile returns a 15min average meter profile in Wh. The profile
-// is sorted by timestamp starting at 00:00. It is guaranteed to contain 96 15min values.
-func energyProfile(entity entity, from time.Time) (*[96]float64, error) {
-	db, err := db.Instance.DB()
+// energyProfileFiltered queries the 96-slot profile, optionally restricted to a
+// single weekday (strftime %w, 0=Sunday).
+func energyProfileFiltered(entity entity, from time.Time, weekday *int) (*[96]float64, error) {
+	database, err := db.Instance.DB()
 	if err != nil {
 		return nil, err
 	}
 
+	args := []any{entity.Id, from.Unix()}
+
+	var weekdayFilter string
+	if weekday != nil {
+		// CAST is required, strftime returns TEXT which never compares equal to an integer
+		weekdayFilter = ` AND CAST(strftime('%w', ts, 'unixepoch', 'localtime') AS INTEGER) = ?`
+		args = append(args, *weekday)
+	}
+
 	// COALESCE guards against legacy rows with NULL energy
-	rows, err := db.Query(`SELECT min(ts) AS ts, COALESCE(avg(energy), 0) AS energy
+	rows, err := database.Query(`SELECT min(ts) AS ts, COALESCE(avg(energy), 0) AS energy
 		FROM meters
-		WHERE meter = ? AND ts >= ? AND COALESCE(recovered, 0) = 0
-		GROUP BY strftime("%H:%M", ts, 'unixepoch', 'localtime')
-		ORDER BY strftime("%H:%M", ts, 'unixepoch', 'localtime') ASC`,
-		entity.Id, from.Unix(),
+		WHERE meter = ? AND ts >= ? AND COALESCE(recovered, 0) = 0`+weekdayFilter+`
+		GROUP BY strftime('%H:%M', ts, 'unixepoch', 'localtime')
+		ORDER BY strftime('%H:%M', ts, 'unixepoch', 'localtime') ASC`,
+		args...,
 	)
 	if err != nil {
 		return nil, err

core/metrics/db_profile_test.go

@@ -0,0 +1,44 @@
+package metrics
+
+import (
+	"testing"
+	"time"
+
+	"github.com/evcc-io/evcc/server/db"
+	"github.com/evcc-io/evcc/tariff"
+	"github.com/jinzhu/now"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEnergyProfileWeekday(t *testing.T) {
+	require.NoError(t, db.NewInstance("sqlite", ":memory:"))
+	require.NoError(t, SetupSchema())
+
+	e := entity{Id: 2, Name: "pv1", Group: PV}
+	require.NoError(t, db.Instance.Create(&e).Error)
+
+	// 4 weeks of full days, today's weekday carries a distinct energy value
+	today := time.Now().Weekday()
+	for day := -28; day < 0; day++ {
+		base := now.BeginningOfDay().AddDate(0, 0, day)
+
+		energy := 1.0
+		if base.Weekday() == today {
+			energy = 2.0
+		}
+
+		for slot := range 96 {
+			ts := base.Add(time.Duration(slot) * tariff.SlotDuration)
+			require.NoError(t, persist(e, ts, energy, 0, nil, false))
+		}
+	}
+
+	weekday := int(today)
+	res, err := energyProfileFiltered(e, now.BeginningOfDay().AddDate(0, 0, -28), &weekday)
+	require.NoError(t, err)
+
+	// only same-weekday slots must be averaged
+	for i, v := range res {
+		require.Equal(t, 2.0, v, "slot %d", i)
+	}
+}

core/metrics/db_test.go

@@ -249,7 +249,7 @@ func TestUpdateProfile(t *testing.T) {
 	{
 		from := clock.Now().Local().AddDate(0, 0, -2).Add(12 * time.Hour) // 12:00 of day 0
 
-		prof, err := energyProfile(entity, from)
+		prof, err := energyProfileFiltered(entity, from, nil)
 		require.NoError(t, err)
 
 		var expected [96]float64
@@ -267,7 +267,7 @@ func TestUpdateProfile(t *testing.T) {
 	{
 		from := clock.Now().Local().AddDate(0, 0, -3).Add(12 * time.Hour) // 12:00 of day -1
 
-		prof, err := energyProfile(entity, from)
+		prof, err := energyProfileFiltered(entity, from, nil)
 		require.NoError(t, err)
 
 		var expected [96]float64