chore: remove dedicated timeseries type (#22692)

Author: andig

core/site_tariffs.go

@@ -19,7 +19,7 @@ type solarDetails struct {
 	Today            dailyDetails `json:"today,omitempty"`            // tomorrow
 	Tomorrow         dailyDetails `json:"tomorrow,omitempty"`         // tomorrow
 	DayAfterTomorrow dailyDetails `json:"dayAfterTomorrow,omitempty"` // day after tomorrow
-	Timeseries       timeseries   `json:"timeseries,omitempty"`       // timeseries of forecasted energy
+	Timeseries       []tsEntry    `json:"timeseries,omitempty"`       // timeseries of forecasted energy
 }
 
 type dailyDetails struct {
@@ -113,27 +113,27 @@ func (site *Site) publishTariffs(greenShareHome float64, greenShareLoadpoints fl
 	}
 
 	// calculate adjusted solar forecast
-	if solar := timestampSeries(tariff.Forecast(site.GetTariff(api.TariffUsageSolar))); len(solar) > 0 {
+	if solar := tariff.Forecast(site.GetTariff(api.TariffUsageSolar)); len(solar) > 0 {
 		fc.Solar = lo.ToPtr(site.solarDetails(solar))
 	}
 
 	site.publish(keys.Forecast, fc)
 }
 
-func (site *Site) solarDetails(solar timeseries) solarDetails {
+func (site *Site) solarDetails(solar api.Rates) solarDetails {
 	res := solarDetails{
-		Timeseries: solar,
+		Timeseries: solarTimeseries(solar),
 	}
 
-	last := solar[len(solar)-1].Timestamp
+	last := solar[len(solar)-1].Start
 
-	bod := beginningOfDay(time.Now())
+	bod := now.BeginningOfDay()
 	eod := bod.AddDate(0, 0, 1)
 	eot := eod.AddDate(0, 0, 1)
 
-	remainingToday := solar.energy(time.Now(), eod)
-	tomorrow := solar.energy(eod, eot)
-	dayAfterTomorrow := solar.energy(eot, eot.AddDate(0, 0, 1))
+	remainingToday := solarEnergy(solar, time.Now(), eod)
+	tomorrow := solarEnergy(solar, eod, eot)
+	dayAfterTomorrow := solarEnergy(solar, eot, eot.AddDate(0, 0, 1))
 
 	res.Today = dailyDetails{
 		Yield:    remainingToday,
@@ -149,7 +149,7 @@ func (site *Site) solarDetails(solar timeseries) solarDetails {
 	}
 
 	// accumulate forecasted energy since last update
-	site.fcstEnergy.AddEnergy(solar.energy(site.fcstEnergy.updated, time.Now()) / 1e3)
+	site.fcstEnergy.AddEnergy(solarEnergy(solar, site.fcstEnergy.updated, time.Now()) / 1e3)
 	settings.SetFloat(keys.SolarAccForecast, site.fcstEnergy.Accumulated)
 
 	produced := lo.SumBy(slices.Collect(maps.Values(site.pvEnergy)), func(v *meterEnergy) float64 {
@@ -173,7 +173,3 @@ func (site *Site) isDynamicTariff(usage api.TariffUsage) bool {
 	tariff := site.GetTariff(usage)
 	return tariff != nil && tariff.Type() != api.TariffTypePriceStatic
 }
-
-func beginningOfDay(t time.Time) time.Time {
-	return now.With(t).BeginningOfDay()
-}

core/solar.go

@@ -0,0 +1,77 @@
+package core
+
+import (
+	"slices"
+	"time"
+
+	"github.com/evcc-io/evcc/api"
+	"github.com/samber/lo"
+)
+
+type tsEntry struct {
+	Timestamp time.Time `json:"ts"`
+	Value     float64   `json:"val"`
+}
+
+func solarTimeseries(rr api.Rates) []tsEntry {
+	return lo.Map(rr, func(r api.Rate, _ int) tsEntry {
+		return tsEntry{Timestamp: r.Start, Value: r.Value}
+	})
+}
+
+func search(rr api.Rates, ts time.Time) (int, bool) {
+	return slices.BinarySearchFunc(rr, ts, func(v api.Rate, ts time.Time) int {
+		return v.Start.Compare(ts)
+	})
+}
+
+// interpolate returns the interpolated value where ts is between two entries and i is the index of the rate after ts
+func interpolate(rr api.Rates, i int, ts time.Time) float64 {
+	rp := &rr[i-1]
+	r := &rr[i]
+	return rp.Value + float64(ts.Sub(rp.Start))*(r.Value-rp.Value)/float64(r.Start.Sub(rp.Start))
+}
+
+// solarEnergy calculates the energy consumption between from and to,
+// assuming the rates containing the power at given timestamp.
+// Result is in Wh
+func solarEnergy(rr api.Rates, from, to time.Time) float64 {
+	var energy float64
+
+	idx, ok := search(rr, from)
+	if !ok {
+		switch {
+		case idx >= len(rr):
+			// from is just before or after last entry
+			return 0
+		case idx == 0:
+			// from is before first entry
+			// do nothing- we ignore anything before the first entry
+		default:
+			// from is between two entries
+			r := &rr[idx]
+			vp := interpolate(rr, idx, from)
+
+			// to is before same entry as from
+			if r.Start.After(to) {
+				return (vp + interpolate(rr, idx, to)) / 2 * to.Sub(from).Hours()
+			}
+
+			energy += (vp + r.Value) / 2 * r.Start.Sub(from).Hours()
+		}
+	}
+
+	for ; idx < len(rr)-1; idx++ {
+		r := &rr[idx]
+		rn := &rr[idx+1]
+
+		if rn.Start.After(to) {
+			energy += (r.Value + interpolate(rr, idx+1, to)) / 2 * to.Sub(r.Start).Hours()
+			break
+		}
+
+		energy += (r.Value + rn.Value) / 2 * rn.Start.Sub(r.Start).Hours()
+	}
+
+	return energy
+}

core/timeseries_test.go renamed to core/solar_test.go

@@ -5,34 +5,36 @@ import (
 	"time"
 
 	"github.com/benbjohnson/clock"
+	"github.com/evcc-io/evcc/api"
 	"github.com/jinzhu/now"
 	"github.com/stretchr/testify/suite"
 )
 
-func TestTimeseries(t *testing.T) {
-	suite.Run(t, new(timeseriesTestSuite))
+func TestSolarRates(t *testing.T) {
+	suite.Run(t, new(solarTestSuite))
 }
 
-type timeseriesTestSuite struct {
+type solarTestSuite struct {
 	suite.Suite
 	clock *clock.Mock
-	rr    timeseries
+	rr    api.Rates
 }
 
-func (t *timeseriesTestSuite) rate(start int, val float64) tsval {
-	return tsval{
-		Timestamp: t.clock.Now().Add(time.Duration(start) * time.Hour),
-		Value:     val,
+func (t *solarTestSuite) rate(start int, val float64) api.Rate {
+	return api.Rate{
+		Start: t.clock.Now().Add(time.Duration(start) * time.Hour),
+		End:   t.clock.Now().Add(time.Duration(start+1) * time.Hour),
+		Value: val,
 	}
 }
 
-func (t *timeseriesTestSuite) SetupSuite() {
+func (t *solarTestSuite) SetupSuite() {
 	t.clock = clock.NewMock()
 	t.clock.Set(now.BeginningOfDay())
-	t.rr = timeseries{t.rate(0, 0), t.rate(1, 1), t.rate(2, 2), t.rate(3, 3), t.rate(4, 4)}
+	t.rr = api.Rates{t.rate(0, 0), t.rate(1, 1), t.rate(2, 2), t.rate(3, 3), t.rate(4, 4)}
 }
 
-func (t *timeseriesTestSuite) TestIndex() {
+func (t *solarTestSuite) TestIndex() {
 	for i, tc := range []struct {
 		ts  float64
 		idx int
@@ -45,30 +47,13 @@ func (t *timeseriesTestSuite) TestIndex() {
 		{99, len(t.rr), false},
 	} {
 		ts := t.clock.Now().Add(time.Duration(float64(time.Hour) * tc.ts))
-		res, ok := t.rr.search(ts)
+		res, ok := search(t.rr, ts)
 		t.Equal(tc.idx, res, "%d. idx %+v", i+1, tc)
 		t.Equal(tc.ok, ok, "%d. ok %+v", i+1, tc)
 	}
 }
 
-func (t *timeseriesTestSuite) TestValue() {
-	for i, tc := range []struct {
-		ts, val float64
-	}{
-		{-1, 0},
-		{0, 0},
-		{0.5, 0.5},
-		{1, 1},
-		{4, 4},
-		{99, 0},
-	} {
-		ts := t.clock.Now().Add(time.Duration(float64(time.Hour) * tc.ts))
-		res := t.rr.value(ts)
-		t.Equal(tc.val, res, "%d. %+v", i+1, tc)
-	}
-}
-
-func (t *timeseriesTestSuite) TestEnergy() {
+func (t *solarTestSuite) TestEnergy() {
 	for i, tc := range []struct {
 		from, to float64
 		expected float64
@@ -90,14 +75,14 @@ func (t *timeseriesTestSuite) TestEnergy() {
 		from := t.clock.Now().Add(time.Duration(float64(time.Hour) * tc.from))
 		to := t.clock.Now().Add(time.Duration(float64(time.Hour) * tc.to))
 
-		res := t.rr.energy(from, to)
+		res := solarEnergy(t.rr, from, to)
 		t.Equal(tc.expected, res, "%d. %+v", i+1, tc)
 	}
 }
 
-func (t *timeseriesTestSuite) TestShort() {
+func (t *solarTestSuite) TestShort() {
 	t.clock.Set(now.BeginningOfDay())
-	rr := timeseries{t.rate(0, 0), t.rate(1, 1)}
+	rr := api.Rates{t.rate(0, 0), t.rate(1, 1)}
 
 	for i, tc := range []struct {
 		from, to, energy, value float64
@@ -114,7 +99,6 @@ func (t *timeseriesTestSuite) TestShort() {
 		from := t.clock.Now().Add(time.Duration(float64(time.Hour) * tc.from))
 		to := t.clock.Now().Add(time.Duration(float64(time.Hour) * tc.to))
 
-		t.Equal(tc.energy, rr.energy(from, to), "%d. energy %+v", i+1, tc)
-		t.Equal(tc.value, rr.value(to), "%d. value %+v", i+1, tc)
+		t.Equal(tc.energy, solarEnergy(rr, from, to), "%d. energy %+v", i+1, tc)
 	}
 }