From c81ff4d543d72a3377792ec67936b031c2135cbd Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Mon, 7 Sep 2026 12:31:40 +0200 Subject: [PATCH 1/4] feat(forecast): learn PV and load from qualified site data Signed-off-by: Fredrik Ahlgren --- .changeset/forecast-learning.md | 7 + Makefile | 2 +- go/cmd/ftw-forecast-evaluate/main.go | 320 +++++++ go/cmd/ftw-forecast-evaluate/main_test.go | 202 +++++ go/cmd/ftw/app_link_replan_ack_test.go | 5 + go/cmd/ftw/energy_history_test.go | 63 +- go/cmd/ftw/forecast_curtailment.go | 287 +++++++ go/cmd/ftw/forecast_curtailment_test.go | 222 +++++ go/cmd/ftw/forecast_measurements.go | 180 ++++ go/cmd/ftw/forecast_measurements_test.go | 204 +++++ go/cmd/ftw/forecast_occupancy_test.go | 174 ++++ go/cmd/ftw/forecast_release_evidence.go | 147 ++++ go/cmd/ftw/forecast_release_evidence_test.go | 123 +++ go/cmd/ftw/forecast_rust.go | 346 ++++++++ go/cmd/ftw/forecast_rust_test.go | 404 +++++++++ go/cmd/ftw/forecast_site.go | 303 +++++++ go/cmd/ftw/forecast_site_test.go | 239 ++++++ go/cmd/ftw/forecast_tracking.go | 807 ++++++++++++++++++ go/cmd/ftw/forecast_tracking_test.go | 449 ++++++++++ go/cmd/ftw/main.go | 334 +++++--- go/internal/api/api_ev_replan_ack_test.go | 7 + go/internal/config/config.go | 8 +- .../control/forecast_scenarios_test.go | 183 ++-- go/internal/energyforecast/client.go | 437 ++++++++++ go/internal/energyforecast/client_test.go | 284 ++++++ go/internal/energyforecast/native_test.go | 88 ++ go/internal/energyforecast/types.go | 154 ++++ go/internal/forecast/forecast.go | 129 ++- go/internal/forecast/forecast_solar.go | 108 ++- go/internal/forecast/forecast_solar_test.go | 173 +++- go/internal/forecast/forecast_test.go | 83 +- go/internal/forecast/open_meteo.go | 90 +- go/internal/forecast/open_meteo_test.go | 91 +- go/internal/forecast/reliability_test.go | 62 ++ go/internal/forecasting/contract.go | 307 +++++++ go/internal/forecasting/contract_test.go | 155 ++++ go/internal/forecasting/evaluate.go | 768 +++++++++++++++++ go/internal/forecasting/evaluate_test.go | 244 ++++++ go/internal/forecasting/occupancy_test.go | 32 + go/internal/forecasting/site_daylight_test.go | 175 ++++ go/internal/loadmodel/learning_test.go | 118 +++ go/internal/loadmodel/model.go | 330 +++---- go/internal/loadmodel/model_test.go | 192 ++--- go/internal/loadmodel/persistence_test.go | 2 +- go/internal/loadmodel/reconfigure_test.go | 91 ++ go/internal/loadmodel/service.go | 205 +++-- go/internal/loadmodel/service_test.go | 40 +- go/internal/mpc/energyplan_test.go | 12 +- go/internal/mpc/forecast_snapshot.go | 41 + go/internal/mpc/optimizer_transport.go | 31 +- go/internal/mpc/optimizer_transport_test.go | 53 ++ go/internal/mpc/service.go | 253 +++--- go/internal/mpc/service_test.go | 119 ++- go/internal/ocpp/forecast_power_test.go | 164 ++++ go/internal/ocpp/handlers.go | 38 +- go/internal/ocpp/handlers_v201.go | 33 + go/internal/ocpp/server.go | 2 +- go/internal/pvmodel/model.go | 309 ++++++- go/internal/pvmodel/model_test.go | 4 +- go/internal/pvmodel/robustness_test.go | 198 +++++ go/internal/pvmodel/service.go | 213 +++-- go/internal/pvmodel/service_test.go | 10 +- go/internal/pvmodel/snapshot.go | 107 +++ go/internal/pvmodel/snapshot_test.go | 160 ++++ go/internal/state/forecast_cache.go | 8 + go/internal/state/forecast_issues.go | 571 +++++++++++++ go/internal/state/forecast_issues_test.go | 199 +++++ go/internal/telemetry/forecast.go | 306 +++++++ go/internal/telemetry/forecast_test.go | 173 ++++ optimizer/native/README.md | 37 +- .../bundle/forecast-v1.response.schema.json | 396 +++++++++ .../native/bundle/forecast-v1.schema.json | 456 ++++++++++ .../native/bundle/ftw-solver-darwin-arm64 | Bin 592384 -> 792016 bytes .../native/bundle/ftw-solver-linux-amd64 | Bin 756072 -> 1025672 bytes .../native/bundle/ftw-solver-linux-arm64 | Bin 645424 -> 859240 bytes optimizer/native/bundle/manifest.json | 25 +- optimizer/native/verify.py | 4 +- 77 files changed, 12052 insertions(+), 1244 deletions(-) create mode 100644 .changeset/forecast-learning.md create mode 100644 go/cmd/ftw-forecast-evaluate/main.go create mode 100644 go/cmd/ftw-forecast-evaluate/main_test.go create mode 100644 go/cmd/ftw/forecast_curtailment.go create mode 100644 go/cmd/ftw/forecast_curtailment_test.go create mode 100644 go/cmd/ftw/forecast_measurements.go create mode 100644 go/cmd/ftw/forecast_measurements_test.go create mode 100644 go/cmd/ftw/forecast_occupancy_test.go create mode 100644 go/cmd/ftw/forecast_release_evidence.go create mode 100644 go/cmd/ftw/forecast_release_evidence_test.go create mode 100644 go/cmd/ftw/forecast_rust.go create mode 100644 go/cmd/ftw/forecast_rust_test.go create mode 100644 go/cmd/ftw/forecast_site.go create mode 100644 go/cmd/ftw/forecast_site_test.go create mode 100644 go/cmd/ftw/forecast_tracking.go create mode 100644 go/cmd/ftw/forecast_tracking_test.go create mode 100644 go/internal/energyforecast/client.go create mode 100644 go/internal/energyforecast/client_test.go create mode 100644 go/internal/energyforecast/native_test.go create mode 100644 go/internal/energyforecast/types.go create mode 100644 go/internal/forecast/reliability_test.go create mode 100644 go/internal/forecasting/contract.go create mode 100644 go/internal/forecasting/contract_test.go create mode 100644 go/internal/forecasting/evaluate.go create mode 100644 go/internal/forecasting/evaluate_test.go create mode 100644 go/internal/forecasting/occupancy_test.go create mode 100644 go/internal/forecasting/site_daylight_test.go create mode 100644 go/internal/loadmodel/learning_test.go create mode 100644 go/internal/loadmodel/reconfigure_test.go create mode 100644 go/internal/mpc/forecast_snapshot.go create mode 100644 go/internal/ocpp/forecast_power_test.go create mode 100644 go/internal/pvmodel/robustness_test.go create mode 100644 go/internal/pvmodel/snapshot.go create mode 100644 go/internal/pvmodel/snapshot_test.go create mode 100644 go/internal/state/forecast_cache.go create mode 100644 go/internal/state/forecast_issues.go create mode 100644 go/internal/state/forecast_issues_test.go create mode 100644 go/internal/telemetry/forecast.go create mode 100644 go/internal/telemetry/forecast_test.go create mode 100644 optimizer/native/bundle/forecast-v1.response.schema.json create mode 100644 optimizer/native/bundle/forecast-v1.schema.json diff --git a/.changeset/forecast-learning.md b/.changeset/forecast-learning.md new file mode 100644 index 00000000..b7e4a531 --- /dev/null +++ b/.changeset/forecast-learning.md @@ -0,0 +1,7 @@ +--- +"ftw": minor +--- + +Correct weather interval timing, panel direction and forecast energy. Train household and PV models only on fresh, complete measurements. Keep grid limits separate from household demand and let PV learn its scale without a battery-based guess. + +Run Energyplan 0.2.0 PV and load models locally as forecast candidates, with no required panel geometry. Save issued forecasts and model state for causal comparison, report uncertainty by horizon, and retain the current planner forecast while gathering evidence. Add a read-only forecast evaluation command. No candidate promotion or cloud connection is required. diff --git a/Makefile b/Makefile index 1c8323de..f76ee81d 100644 --- a/Makefile +++ b/Makefile @@ -273,5 +273,5 @@ native-solver-check: native-solver-test: native-solver-check @binary="$$(python3 optimizer/native/verify.py --host-binary)"; \ - if [ -n "$$binary" ]; then cd go && FTW_NATIVE_SOLVER="$$binary" go test -count=1 ./internal/mpc -run '^TestNative'; \ + if [ -n "$$binary" ]; then cd go && FTW_NATIVE_SOLVER="$$binary" FTW_FORECAST_WORKER="$$binary" go test -count=1 ./internal/mpc ./internal/energyforecast ./cmd/ftw -run 'Native|RustForecastHost'; \ else echo "Native execution tests skipped: no bundled worker for this host"; fi diff --git a/go/cmd/ftw-forecast-evaluate/main.go b/go/cmd/ftw-forecast-evaluate/main.go new file mode 100644 index 00000000..657c402a --- /dev/null +++ b/go/cmd/ftw-forecast-evaluate/main.go @@ -0,0 +1,320 @@ +// ftw-forecast-evaluate reads the bounded forecast archive and prints a causal +// JSON score report. It opens state.db read-only and never runs migrations. +package main + +import ( + "context" + "encoding/json" + "errors" + "flag" + "fmt" + "io" + "math" + "os" + "sort" + "time" + + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/state" +) + +const maxEvaluationSamples = state.MaxForecastErrors + +type report struct { + AsOf string `json:"as_of"` + Since string `json:"since"` + IssueCount int `json:"issue_count"` + TruthCount int `json:"truth_count"` + PerLead []forecasting.Metric `json:"per_lead"` + BandCoverage []bandCoverage `json:"band_coverage"` + PairedMetrics []forecasting.PairMetric `json:"paired_metrics"` + CumulativeNetError []forecasting.CumulativeMetric `json:"cumulative_net_errors"` +} + +type bandCoverage struct { + Series string `json:"series"` + Signal string `json:"signal"` + Lead int `json:"lead_bucket"` + EmpiricalSamples int `json:"empirical_samples"` + EmpiricalCoverage80 float64 `json:"empirical_coverage_80"` + ColdStartSamples int `json:"cold_start_samples"` + ProvisionalSamples int `json:"provisional_samples"` + ProvisionalRangeHitRate float64 `json:"provisional_range_hit_rate"` + ProvisionalInputCoverageMean float64 `json:"provisional_input_coverage_mean"` +} + +type pointKey struct { + series, config string + start, end int64 + lead int +} + +type cumulativeKey struct { + series, config string + start, end int64 + lead, hours int +} + +func main() { + if err := run(context.Background(), os.Args[1:], os.Stdout, time.Now()); err != nil { + fmt.Fprintln(os.Stderr, "ftw-forecast-evaluate:", err) + os.Exit(1) + } +} + +func run(ctx context.Context, args []string, output io.Writer, now time.Time) error { + fs := flag.NewFlagSet("ftw-forecast-evaluate", flag.ContinueOnError) + fs.SetOutput(io.Discard) + statePath := fs.String("state", "state.db", "path to state.db") + sinceText := fs.String("since", "", "first issue time, RFC3339 (default: 30 days before until)") + untilText := fs.String("until", "", "last issue and truth time, RFC3339 (default: now)") + if err := fs.Parse(args); err != nil { + return err + } + if fs.NArg() != 0 { + return errors.New("unexpected positional arguments") + } + until, err := parseBound(*untilText, now.UTC()) + if err != nil { + return fmt.Errorf("parse -until: %w", err) + } + sinceDefault := until.Add(-state.ForecastIssueRetention) + since, err := parseBound(*sinceText, sinceDefault) + if err != nil { + return fmt.Errorf("parse -since: %w", err) + } + if !since.Before(until) { + return errors.New("-since must be before -until") + } + if until.Sub(since) > state.ForecastIssueRetention { + return fmt.Errorf("evaluation window exceeds %s retention", state.ForecastIssueRetention) + } + + store, err := state.OpenBackupSource(*statePath) + if err != nil { + return err + } + defer store.Close() + + observations, err := store.LoadForecastObservations(ctx, since.UnixMilli(), until.UnixMilli()) + if err != nil { + return fmt.Errorf("load forecast truth: %w", err) + } + available := observations[:0] + for _, observation := range observations { + if observation.AvailableAtMS <= until.UnixMilli() { + available = append(available, observation) + } + } + observations = available + points := make(map[pointKey]forecasting.ErrorSample) + cumulative := make(map[cumulativeKey]forecasting.CumulativeEnergySample) + issues := 0 + err = store.VisitForecastIssues(ctx, since.UnixMilli(), until.UnixMilli(), func(issue forecasting.Issue) error { + issues++ + for _, sample := range forecasting.Errors([]forecasting.Issue{issue}, observations, until.UnixMilli()) { + key := pointKey{sample.Series, sample.ConfigVersion, sample.StartMS, sample.EndMS, sample.Lead} + if old, ok := points[key]; !ok || laterPoint(sample, old) { + if !ok && len(points) == maxEvaluationSamples { + return errors.New("point evaluation exceeds memory bound") + } + points[key] = sample + } + } + // Build each window within one issue before choosing among origins. This + // preserves the temporal correlation of one issued forecast. + for _, sample := range forecasting.CumulativeNetEnergy([]forecasting.Issue{issue}, observations, until.UnixMilli()) { + key := cumulativeKey{sample.Series, sample.ConfigVersion, sample.StartMS, sample.EndMS, sample.Lead, sample.Hours} + if old, ok := cumulative[key]; !ok || laterCumulative(sample, old) { + if !ok && len(cumulative) == maxEvaluationSamples { + return errors.New("cumulative evaluation exceeds memory bound") + } + cumulative[key] = sample + } + } + return nil + }) + if err != nil { + return fmt.Errorf("visit forecast issues: %w", err) + } + + pointSamples := sortedPoints(points) + cumulativeSamples := sortedCumulative(cumulative) + report := report{ + AsOf: until.UTC().Format(time.RFC3339), + Since: since.UTC().Format(time.RFC3339), + IssueCount: issues, + TruthCount: len(observations), + PerLead: forecasting.Metrics(pointSamples), + BandCoverage: summarizeBands(pointSamples), + PairedMetrics: forecasting.CompareSeries(pointSamples, "champion", "energyplan"), + CumulativeNetError: forecasting.CumulativeMetrics(cumulativeSamples), + } + encoder := json.NewEncoder(output) + encoder.SetIndent("", " ") + return encoder.Encode(report) +} + +func parseBound(text string, fallback time.Time) (time.Time, error) { + if text == "" { + return fallback, nil + } + value, err := time.Parse(time.RFC3339, text) + if err != nil { + return time.Time{}, err + } + return value.UTC(), nil +} + +func laterPoint(a, b forecasting.ErrorSample) bool { + if a.OriginMS != b.OriginMS { + return a.OriginMS > b.OriginMS + } + if a.IssuedAtMS != b.IssuedAtMS { + return a.IssuedAtMS > b.IssuedAtMS + } + return a.IssueID > b.IssueID +} + +func laterCumulative(a, b forecasting.CumulativeEnergySample) bool { + if a.OriginMS != b.OriginMS { + return a.OriginMS > b.OriginMS + } + if a.IssuedAtMS != b.IssuedAtMS { + return a.IssuedAtMS > b.IssuedAtMS + } + return a.IssueID > b.IssueID +} + +func sortedPoints(chosen map[pointKey]forecasting.ErrorSample) []forecasting.ErrorSample { + out := make([]forecasting.ErrorSample, 0, len(chosen)) + for _, sample := range chosen { + out = append(out, sample) + } + sort.Slice(out, func(i, j int) bool { + a, b := out[i], out[j] + if a.StartMS != b.StartMS { + return a.StartMS < b.StartMS + } + if a.Series != b.Series { + return a.Series < b.Series + } + if a.ConfigVersion != b.ConfigVersion { + return a.ConfigVersion < b.ConfigVersion + } + if a.Lead != b.Lead { + return a.Lead < b.Lead + } + return a.IssueID < b.IssueID + }) + return out +} + +func sortedCumulative(chosen map[cumulativeKey]forecasting.CumulativeEnergySample) []forecasting.CumulativeEnergySample { + out := make([]forecasting.CumulativeEnergySample, 0, len(chosen)) + for _, sample := range chosen { + out = append(out, sample) + } + sort.Slice(out, func(i, j int) bool { + a, b := out[i], out[j] + if a.StartMS != b.StartMS { + return a.StartMS < b.StartMS + } + if a.Series != b.Series { + return a.Series < b.Series + } + if a.ConfigVersion != b.ConfigVersion { + return a.ConfigVersion < b.ConfigVersion + } + if a.Hours != b.Hours { + return a.Hours < b.Hours + } + if a.Lead != b.Lead { + return a.Lead < b.Lead + } + return a.IssueID < b.IssueID + }) + return out +} + +func summarizeBands(samples []forecasting.ErrorSample) []bandCoverage { + type key struct { + series, signal string + lead int + } + type acc struct { + bandCoverage + empiricalHit, provisionalHit float64 + } + all := make(map[key]*acc) + for _, sample := range samples { + for _, signal := range []string{"pv", "load", "net"} { + actual, known, band, evidence := bandInputs(sample, signal) + if !known { + continue + } + key := key{sample.Series, signal, sample.Lead} + a := all[key] + if a == nil { + a = &acc{bandCoverage: bandCoverage{Series: sample.Series, Signal: signal, Lead: sample.Lead}} + all[key] = a + } + switch band.Method { + case forecasting.BandMethodEmpirical: + a.EmpiricalSamples++ + if actual >= band.LowW && actual <= band.HighW { + a.empiricalHit++ + } + case forecasting.BandMethodColdStart: + a.ColdStartSamples++ + } + if evidence != nil { + a.ProvisionalSamples++ + a.ProvisionalInputCoverageMean += evidence.Coverage + if actual >= evidence.LowerW && actual <= evidence.UpperW { + a.provisionalHit++ + } + } + } + } + keys := make([]key, 0, len(all)) + for key := range all { + keys = append(keys, key) + } + sort.Slice(keys, func(i, j int) bool { + if keys[i].series != keys[j].series { + return keys[i].series < keys[j].series + } + if keys[i].signal != keys[j].signal { + return keys[i].signal < keys[j].signal + } + return keys[i].lead < keys[j].lead + }) + out := make([]bandCoverage, 0, len(keys)) + for _, key := range keys { + a := all[key] + if a.EmpiricalSamples > 0 { + a.EmpiricalCoverage80 = a.empiricalHit / float64(a.EmpiricalSamples) + } + if a.ProvisionalSamples > 0 { + a.ProvisionalRangeHitRate = a.provisionalHit / float64(a.ProvisionalSamples) + a.ProvisionalInputCoverageMean /= float64(a.ProvisionalSamples) + } + out = append(out, a.bandCoverage) + } + return out +} + +func bandInputs(sample forecasting.ErrorSample, signal string) (float64, bool, forecasting.Band, *forecasting.ModelEstimateEvidence) { + switch signal { + case "pv": + return sample.Prediction.PVW + sample.PVErrorW, sample.PVKnown, sample.Prediction.PVBand, sample.Prediction.ModelPV + case "load": + return sample.Prediction.LoadW + sample.LoadErrorW, sample.LoadKnown, sample.Prediction.LoadBand, sample.Prediction.ModelLoad + case "net": + actual := sample.Prediction.LoadW - sample.Prediction.PVW + sample.LoadErrorW - sample.PVErrorW + return actual, sample.LoadKnown && sample.PVKnown, sample.Prediction.NetBand, nil + default: + return math.NaN(), false, forecasting.Band{}, nil + } +} diff --git a/go/cmd/ftw-forecast-evaluate/main_test.go b/go/cmd/ftw-forecast-evaluate/main_test.go new file mode 100644 index 00000000..18ff13c9 --- /dev/null +++ b/go/cmd/ftw-forecast-evaluate/main_test.go @@ -0,0 +1,202 @@ +package main + +import ( + "bytes" + "context" + "encoding/json" + "math" + "path/filepath" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/state" +) + +const testHourMS = int64(time.Hour / time.Millisecond) + +func openArchive(t *testing.T) (string, *state.Store) { + t.Helper() + path := filepath.Join(t.TempDir(), "state.db") + store, err := state.Open(path) + if err != nil { + t.Fatal(err) + } + if err = store.InitForecastArchive(context.Background()); err != nil { + store.Close() + t.Fatal(err) + } + return path, store +} + +func coldBand() forecasting.Band { + return forecasting.Band{LowW: 0, HighW: 5000, Method: forecasting.BandMethodColdStart} +} + +func forecastPoint(start int64, pv, load float64) forecasting.Point { + return forecasting.Point{ + StartMS: start, EndMS: start + testHourMS, PVW: pv, LoadW: load, + PVKnown: true, LoadKnown: true, PVQuality: "forecast", LoadQuality: "forecast", + PVBand: coldBand(), LoadBand: coldBand(), NetBand: coldBand(), + } +} + +func forecastIssue(id string, origin int64, points []forecasting.Point) forecasting.Issue { + return forecasting.Issue{ + Schema: forecasting.Schema, ID: id, OriginMS: origin, IssuedAtMS: origin, LatestInputMS: origin, + ConfigVersion: "cfg", Series: []forecasting.Series{{Name: "champion", ModelVersion: "v1", Points: points}}, + } +} + +func observation(start, available int64, pv, load float64) forecasting.Observation { + return forecasting.Observation{ + StartMS: start, EndMS: start + testHourMS, AvailableAtMS: available, + PVW: pv, LoadW: load, PVKnown: true, LoadKnown: true, Quality: "complete", ConfigVersion: "cfg", + } +} + +func runReport(t *testing.T, path string, since, until, now time.Time) report { + t.Helper() + var output bytes.Buffer + args := []string{"-state", path, "-since", since.Format(time.RFC3339), "-until", until.Format(time.RFC3339)} + if err := run(context.Background(), args, &output, now); err != nil { + t.Fatal(err) + } + var got report + if err := json.Unmarshal(output.Bytes(), &got); err != nil { + t.Fatal(err) + } + return got +} + +func TestEvaluateEmptyArchive(t *testing.T) { + path, store := openArchive(t) + if err := store.Close(); err != nil { + t.Fatal(err) + } + now := time.Now().UTC().Truncate(time.Second) + got := runReport(t, path, now.Add(-24*time.Hour), now, now) + if got.IssueCount != 0 || got.TruthCount != 0 || len(got.PerLead) != 0 || + len(got.PairedMetrics) != 0 || len(got.CumulativeNetError) != 0 { + t.Fatalf("empty archive report = %+v", got) + } +} + +func TestEvaluateExcludesTruthUnavailableAtAsOfAndRejectsGap(t *testing.T) { + path, store := openArchive(t) + ctx := context.Background() + now := time.Now().UTC().Truncate(time.Hour) + start := now.Add(-6 * time.Hour) + points := []forecasting.Point{ + forecastPoint(start.UnixMilli(), 100, 1000), + forecastPoint(start.Add(time.Hour).UnixMilli(), 100, 1000), + forecastPoint(start.Add(2*time.Hour).UnixMilli(), 100, 1000), + } + issue := forecastIssue("gap", start.Add(-2*time.Hour).UnixMilli(), points) + if err := store.SaveForecastIssue(ctx, issue); err != nil { + t.Fatal(err) + } + if err := store.SaveForecastObservation(ctx, observation(start.UnixMilli(), start.Add(time.Hour).UnixMilli(), 200, 1200)); err != nil { + t.Fatal(err) + } + // The middle hour is missing. The last hour exists but only becomes known + // after this report's as-of time. + futureReceipt := start.Add(4 * time.Hour).UnixMilli() + if err := store.SaveForecastObservation(ctx, observation(start.Add(2*time.Hour).UnixMilli(), futureReceipt, 200, 1200)); err != nil { + t.Fatal(err) + } + if err := store.Close(); err != nil { + t.Fatal(err) + } + + until := start.Add(3 * time.Hour) + got := runReport(t, path, start.Add(-3*time.Hour), until, now) + if got.TruthCount != 1 { + t.Fatalf("truth count=%d, want only the causally available row", got.TruthCount) + } + for _, metric := range got.CumulativeNetError { + if metric.Hours >= 3 { + t.Fatalf("gap or unavailable truth produced a %dh metric: %+v", metric.Hours, metric) + } + } +} + +func TestEvaluateDeduplicatesOriginsAndReportsAllEnergyHorizons(t *testing.T) { + path, store := openArchive(t) + ctx := context.Background() + now := time.Now().UTC().Truncate(time.Hour) + start := now.Add(-25 * time.Hour) + olderPoints := make([]forecasting.Point, 24) + newerPoints := make([]forecasting.Point, 24) + energyplanPoints := make([]forecasting.Point, 24) + for i := 0; i < 24; i++ { + at := start.Add(time.Duration(i) * time.Hour).UnixMilli() + olderPoints[i] = forecastPoint(at, 100, 1000) + newerPoints[i] = forecastPoint(at, 200, 1000) + energyplanPoints[i] = forecastPoint(at, 250, 1200) + if err := store.SaveForecastObservation(ctx, observation(at, at+testHourMS, 300, 1300)); err != nil { + t.Fatal(err) + } + } + older := forecastIssue("older", start.Add(-2*time.Hour-10*time.Minute).UnixMilli(), olderPoints) + older.Series = append(older.Series, forecasting.Series{Name: "energyplan", ModelVersion: "v1", Points: olderPoints}) + newer := forecastIssue("newer", start.Add(-2*time.Hour).UnixMilli(), newerPoints) + newer.Series = append(newer.Series, forecasting.Series{Name: "energyplan", ModelVersion: "v1", Points: energyplanPoints}) + if err := store.SaveForecastIssue(ctx, newer); err != nil { + t.Fatal(err) + } + if err := store.SaveForecastIssue(ctx, older); err != nil { + t.Fatal(err) + } + if err := store.Close(); err != nil { + t.Fatal(err) + } + + until := start.Add(24 * time.Hour) + got := runReport(t, path, start.Add(-3*time.Hour), until, now) + if got.IssueCount != 2 || got.TruthCount != 24 { + t.Fatalf("counts=(%d,%d), want (2,24)", got.IssueCount, got.TruthCount) + } + foundChampionPV := false + for _, metric := range got.PerLead { + if metric.Series == "champion" && metric.Signal == "pv" && metric.Samples > 0 { + foundChampionPV = true + if math.Abs(metric.MAEW-100) > 1e-9 { + t.Fatalf("champion PV MAE=%v, older origin was not removed", metric.MAEW) + } + } + } + if !foundChampionPV { + t.Fatal("missing champion PV metric") + } + horizons := map[int]bool{} + for _, metric := range got.CumulativeNetError { + if metric.Series == "champion" { + horizons[metric.Hours] = true + if metric.Hours == 24 && math.Abs(metric.BiasWh-4800) > 1e-9 { + t.Fatalf("24h bias=%v, want newest-origin 4800Wh", metric.BiasWh) + } + } + } + for _, hours := range []int{1, 3, 6, 12, 24} { + if !horizons[hours] { + t.Fatalf("missing %dh cumulative summary: %+v", hours, got.CumulativeNetError) + } + } + if len(got.PairedMetrics) == 0 { + t.Fatal("matched champion/energyplan targets produced no paired metrics") + } +} + +func TestEvaluateRejectsMoreThanRetentionAndBadRFC3339(t *testing.T) { + var output bytes.Buffer + now := time.Now().UTC().Truncate(time.Second) + if err := run(context.Background(), []string{"-since", "bad"}, &output, now); err == nil { + t.Fatal("bad RFC3339 time was accepted") + } + if err := run(context.Background(), []string{ + "-since", now.Add(-31 * 24 * time.Hour).Format(time.RFC3339), "-until", now.Format(time.RFC3339), + }, &output, now); err == nil { + t.Fatal("window beyond retention was accepted") + } +} diff --git a/go/cmd/ftw/app_link_replan_ack_test.go b/go/cmd/ftw/app_link_replan_ack_test.go index 07bd0c9b..fc80401c 100644 --- a/go/cmd/ftw/app_link_replan_ack_test.go +++ b/go/cmd/ftw/app_link_replan_ack_test.go @@ -23,6 +23,11 @@ func TestAppEVEditsConfirmWhilePlanIsBlocked(t *testing.T) { if err := st.SavePrices([]state.PricePoint{{Zone: "SE4", SlotTsMs: now.UnixMilli(), SlotLenMin: 15, SpotOreKwh: 50, TotalOreKwh: 100}}); err != nil { t.Fatal(err) } + cloud := 0.0 + if err := st.SaveForecasts([]state.ForecastPoint{{SlotTsMs: now.UnixMilli(), SlotLenMin: 15, + CloudCoverPct: &cloud, Source: "test", FetchedAtMs: now.UnixMilli()}}); err != nil { + t.Fatal(err) + } svc := mpc.New(st, nil, "SE4", mpc.Params{Mode: mpc.ModeSelfConsumption, SoCLevels: 11, ActionLevels: 5, CapacityWh: 10000, InitialSoC: .5, SoCMin: .1, SoCMax: .95, MaxChargeW: 3000, MaxDischargeW: 3000, ChargeEfficiency: .95, DischargeEfficiency: .95}) svc.Horizon = time.Hour svc.BaseLoad = 500 diff --git a/go/cmd/ftw/energy_history_test.go b/go/cmd/ftw/energy_history_test.go index d3ee5dca..e480c5b1 100644 --- a/go/cmd/ftw/energy_history_test.go +++ b/go/cmd/ftw/energy_history_test.go @@ -88,29 +88,18 @@ func TestBuildHistoryPointExcludesUnavailableTelemetry(t *testing.T) { tel.RecordDriverSuccess("site-meter") point, available = buildHistoryPoint(tel, &control.State{SiteMeterDriver: "site-meter"}, now.UnixMilli(), time.Minute) - if !available { - t.Fatalf("recovered site meter unavailable: %+v", point) - } - - livePV := tel.Get("live-pv", telemetry.DerPV).SmoothedW - liveBattery := tel.Get("live-battery", telemetry.DerBattery).SmoothedW - if point.PVW != livePV || point.BatW != liveBattery { - t.Errorf("recovered history point includes stale DER telemetry: %+v", point) - } - - var detail struct { - Drivers map[string]map[string]float64 `json:"drivers"` - } - if err := json.Unmarshal([]byte(point.JSON), &detail); err != nil { - t.Fatal(err) - } - if len(detail.Drivers["stale-pv"]) != 0 || - len(detail.Drivers["stale-battery"]) != 0 { - t.Fatalf("history JSON retained stale driver values: %+v", detail.Drivers) + if available { + t.Fatalf("missing PV/battery treated as zero in household history: %+v", point) } - if detail.Drivers["live-pv"]["pv_w"] != livePV || - detail.Drivers["live-battery"]["bat_w"] != liveBattery { - t.Fatalf("history JSON lost live driver values: %+v", detail.Drivers) + // The aggregate becomes known only after every significant flow recovers. + tel.Update("stale-pv", telemetry.DerPV, -800, nil, nil) + tel.RecordDriverSuccess("stale-pv") + tel.Update("stale-battery", telemetry.DerBattery, 250, nil, nil) + tel.RecordDriverSuccess("stale-battery") + point, available = buildHistoryPoint(tel, &control.State{SiteMeterDriver: "site-meter"}, + time.Now().Add(time.Millisecond).UnixMilli(), time.Minute) + if !available || point.LoadW != 1600 || point.PVW != -1100 || point.BatW != 300 { + t.Fatalf("recovered complete raw balance = %+v, available=%v", point, available) } zeroTel := telemetry.NewStore() @@ -118,13 +107,13 @@ func TestBuildHistoryPointExcludesUnavailableTelemetry(t *testing.T) { zeroTel.Update("zero-meter", telemetry.DerMeter, 0, nil, nil) zeroTel.RecordDriverSuccess("zero-meter") zero, zeroAvailable := buildHistoryPoint(zeroTel, - &control.State{SiteMeterDriver: "zero-meter"}, time.Now().UnixMilli(), time.Minute) + &control.State{SiteMeterDriver: "zero-meter"}, time.Now().Add(time.Millisecond).UnixMilli(), time.Minute) if !zeroAvailable || zero.GridW != 0 { t.Fatalf("fresh 0 W site meter unavailable: point=%+v available=%v", zero, zeroAvailable) } } -func TestBuildHistoryPointExcludesAgedEVAndV2XFromTotals(t *testing.T) { +func TestBuildHistoryPointRequiresFreshEVAndV2X(t *testing.T) { tel := telemetry.NewStore() for _, name := range []string{"site-meter", "stale-ev", "live-ev", "stale-v2x", "live-v2x"} { tel.EnsureDriverHealth(name) @@ -149,32 +138,10 @@ func TestBuildHistoryPointExcludesAgedEVAndV2XFromTotals(t *testing.T) { point, available := buildHistoryPoint(tel, &control.State{SiteMeterDriver: "site-meter"}, now.UnixMilli(), time.Minute) - if !available { - t.Fatal("fresh site meter did not produce history") - } - if point.LoadW != 4100 { - t.Fatalf("load includes aged EV/V2X readings: got %v W, want 4100 W", point.LoadW) + if available { + t.Fatalf("aged EV/V2X became zero household demand: %+v", point) } - var detail struct { - Drivers map[string]map[string]float64 `json:"drivers"` - EVW float64 `json:"ev_w"` - V2XW float64 `json:"v2x_w"` - LoadHouseW float64 `json:"load_house_w"` - } - if err := json.Unmarshal([]byte(point.JSON), &detail); err != nil { - t.Fatal(err) - } - if detail.EVW != 600 || detail.V2XW != 300 || detail.LoadHouseW != point.LoadW { - t.Fatalf("top-level history disagrees with fresh readings: %+v", detail) - } - if len(detail.Drivers["stale-ev"]) != 0 || len(detail.Drivers["stale-v2x"]) != 0 { - t.Fatalf("per-driver history retained aged readings: %+v", detail.Drivers) - } - if detail.Drivers["live-ev"]["ev_w"] != detail.EVW || - detail.Drivers["live-v2x"]["v2x_w"] != detail.V2XW { - t.Fatalf("top-level and per-driver history disagree: %+v", detail) - } } func TestStaleMeterTickKeepsSamplesAndIndependentLedgerWithoutDispatch(t *testing.T) { diff --git a/go/cmd/ftw/forecast_curtailment.go b/go/cmd/ftw/forecast_curtailment.go new file mode 100644 index 00000000..75456011 --- /dev/null +++ b/go/cmd/ftw/forecast_curtailment.go @@ -0,0 +1,287 @@ +package main + +import ( + "context" + "encoding/json" + "log/slog" + "sort" + "sync" + "sync/atomic" + + "github.com/srcfl/ftw/go/internal/state" +) + +const forecastCurtailmentKey = "forecast/pv-curtailment-v1" + +type forecastCurtailmentStore interface { + LoadConfig(string) (string, bool) + SaveConfig(string, string) error + LookupDeviceByDriverName(string) *state.Device +} + +type forecastCurtailmentState struct { + Version int `json:"version"` + DeviceIDs []string `json:"device_ids"` + Unknown bool `json:"unknown"` + Intent bool `json:"intent"` +} + +type curtailmentEntry struct { + active bool + revision uint64 +} + +// forecastCurtailment only labels observations. It never sends an extra +// command, changes a payload or changes the sender's result. Active is safe +// under ctrlMu: it reads one atomic flag and never calls back into control. +// +// One background worker resolves stable identities and coalesces persistence. +// SQLite cannot extend a control command's deadline. There is a crash window +// before a queued transition reaches disk; this is not durable-before-command +// tracking. Close flushes the final state after dispatch has stopped. +type forecastCurtailment struct { + sender driverCommandSender + store forecastCurtailmentStore + active atomic.Bool + mu sync.Mutex + intent, unknown bool + ids map[string]bool + entries map[string]curtailmentEntry // runtime names only, never persisted + revision uint64 + wake chan struct{} + stop chan struct{} + done chan struct{} + closeOnce sync.Once + releaseEvidence func(string) bool +} + +func newForecastCurtailment(sender driverCommandSender, store forecastCurtailmentStore) *forecastCurtailment { + f := &forecastCurtailment{sender: sender, store: store, ids: map[string]bool{}, entries: map[string]curtailmentEntry{}, wake: make(chan struct{}, 1), stop: make(chan struct{}), done: make(chan struct{})} + if store != nil { + if raw, ok := store.LoadConfig(forecastCurtailmentKey); ok && raw != "" { + var saved forecastCurtailmentState + if json.Unmarshal([]byte(raw), &saved) != nil || saved.Version != 1 { + f.unknown = true + } else { + f.unknown, f.intent = saved.Unknown, saved.Intent + for _, id := range saved.DeviceIDs { + if id != "" { + f.ids[id] = true + } + } + } + } + } + f.publishLocked() + go f.run() + return f +} + +func (f *forecastCurtailment) Active() bool { return f != nil && f.active.Load() } + +// SetReleaseEvidence installs an immutable predicate for drivers whose release +// command attempts to remove the PV limit and reports failures. A nil predicate +// cannot confirm release: some drivers return success for unsupported no-ops. +func (f *forecastCurtailment) SetReleaseEvidence(evidence func(string) bool) { + if f == nil { + return + } + f.mu.Lock() + f.releaseEvidence = evidence + f.mu.Unlock() +} + +// PendingDrivers maps pending hardware identities to current runtime names. +// Call outside control locks: identity lookup may read SQLite. The caller may +// restore these names into Core's normal curtailment state, which still decides +// whether fresh telemetry and current intent permit release. Unknown identities +// remain censored and never map to an arbitrary driver. +func (f *forecastCurtailment) PendingDrivers(currentNames []string) []string { + if f == nil { + return nil + } + identities := make(map[string]string, len(currentNames)) + for _, name := range currentNames { + if f.store != nil { + if device := f.store.LookupDeviceByDriverName(name); device != nil { + identities[name] = device.DeviceID + } + } + } + f.mu.Lock() + defer f.mu.Unlock() + seen := make(map[string]bool, len(currentNames)) + var pending []string + for _, name := range currentNames { + if seen[name] { + continue + } + seen[name] = true + entry, exists := f.entries[name] + active := f.ids[identities[name]] + if exists { + // A recent successful release overrides the older persisted ID + // while the background worker saves that transition. + active = entry.active + } + if active { + pending = append(pending, name) + } + } + sort.Strings(pending) + return pending +} + +func (f *forecastCurtailment) publishLocked() { + active := f.intent || f.unknown || len(f.ids) > 0 + for _, entry := range f.entries { + active = active || entry.active + } + f.active.Store(active) +} + +func (f *forecastCurtailment) notify() { + select { + case f.wake <- struct{}{}: + default: + } +} + +// ObserveIntent covers active manual/planner holds, including zero targets +// for which Core may suppress a command. Clearing intent cannot clear an +// unacknowledged release or an unresolved hardware identity. +func (f *forecastCurtailment) ObserveIntent(active bool) { + if f == nil { + return + } + f.mu.Lock() + changed := f.intent != active + f.intent = active + f.publishLocked() + f.mu.Unlock() + if changed { + f.notify() + } +} + +func (f *forecastCurtailment) record(name string, active bool) { + f.mu.Lock() + f.revision++ + f.entries[name] = curtailmentEntry{active, f.revision} + f.publishLocked() + f.mu.Unlock() + f.notify() +} + +func (f *forecastCurtailment) Send(ctx context.Context, name string, payload []byte) error { + var command struct { + Action string `json:"action"` + } + _ = json.Unmarshal(payload, &command) + f.mu.Lock() + evidence := f.releaseEvidence + f.mu.Unlock() + if command.Action == "curtail" { + f.record(name, true) + } + err := f.sender.Send(ctx, name, payload) + if command.Action == "curtail_disable" && err == nil && evidence != nil && evidence(name) { + f.record(name, false) + } + return err +} + +// RecordDefault may be called only when that driver's confirmed default +// restores unrestricted PV. Driver startup alone is not confirmation. +func (f *forecastCurtailment) RecordDefault(name string, success bool) { + if f == nil || !success { + return + } + f.record(name, false) +} + +// ConfirmUncurtailed clears unknown identities only after the caller has +// authoritative confirmation that all PV devices are unrestricted. +func (f *forecastCurtailment) ConfirmUncurtailed() { + if f == nil { + return + } + f.mu.Lock() + f.unknown = false + f.ids = map[string]bool{} + f.entries = map[string]curtailmentEntry{} + f.publishLocked() + f.mu.Unlock() + f.notify() +} + +func (f *forecastCurtailment) run() { + defer close(f.done) + for { + select { + case <-f.wake: + f.persist() + case <-f.stop: + f.persist() + return + } + } +} + +func (f *forecastCurtailment) persist() { + f.mu.Lock() + entries := make(map[string]curtailmentEntry, len(f.entries)) + for name, e := range f.entries { + entries[name] = e + } + f.mu.Unlock() + for name, entry := range entries { + var device *state.Device + if f.store != nil { + device = f.store.LookupDeviceByDriverName(name) + } + f.mu.Lock() + if current, ok := f.entries[name]; ok && current.revision == entry.revision { + if device != nil && device.DeviceID != "" { + if entry.active { + f.ids[device.DeviceID] = true + } else { + delete(f.ids, device.DeviceID) + } + delete(f.entries, name) + } else if !entry.active { + delete(f.entries, name) + } + } + f.mu.Unlock() + } + f.mu.Lock() + saved := forecastCurtailmentState{Version: 1, Unknown: f.unknown, Intent: f.intent} + for id := range f.ids { + saved.DeviceIDs = append(saved.DeviceIDs, id) + } + for _, entry := range f.entries { + saved.Unknown = saved.Unknown || entry.active + } + f.publishLocked() + f.mu.Unlock() + sort.Strings(saved.DeviceIDs) + if f.store == nil { + return + } + encoded, err := json.Marshal(saved) + if err == nil { + err = f.store.SaveConfig(forecastCurtailmentKey, string(encoded)) + } + if err != nil { + slog.Warn("PV forecast curtailment state not persisted", "err", err) + } +} + +func (f *forecastCurtailment) Close() { + if f == nil { + return + } + f.closeOnce.Do(func() { close(f.stop) }) + <-f.done +} diff --git a/go/cmd/ftw/forecast_curtailment_test.go b/go/cmd/ftw/forecast_curtailment_test.go new file mode 100644 index 00000000..aa5a6974 --- /dev/null +++ b/go/cmd/ftw/forecast_curtailment_test.go @@ -0,0 +1,222 @@ +package main + +import ( + "context" + "errors" + "reflect" + "strings" + "sync" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/state" +) + +type curtailStore struct { + mu sync.Mutex + value string + identities map[string]string + block chan struct{} +} + +func (s *curtailStore) LoadConfig(string) (string, bool) { + s.mu.Lock() + defer s.mu.Unlock() + return s.value, s.value != "" +} +func (s *curtailStore) SaveConfig(_ string, value string) error { + if s.block != nil { + <-s.block + } + s.mu.Lock() + s.value = value + s.mu.Unlock() + return nil +} +func (s *curtailStore) LookupDeviceByDriverName(name string) *state.Device { + s.mu.Lock() + defer s.mu.Unlock() + id := s.identities[name] + if id == "" { + return nil + } + return &state.Device{DeviceID: id} +} + +func waitCurtailment(t *testing.T, f *forecastCurtailment, want bool) { + t.Helper() + deadline := time.Now().Add(time.Second) + for f.Active() != want && time.Now().Before(deadline) { + time.Sleep(time.Millisecond) + } + if f.Active() != want { + t.Fatalf("Active=%v want %v", f.Active(), want) + } +} + +func TestForecastCurtailmentFailedReleaseStaysCensored(t *testing.T) { + store := &curtailStore{identities: map[string]string{"pv": "hardware-1"}} + fail := false + sender := &stubSender{handler: func(context.Context, string) error { + if fail { + return errors.New("release failed") + } + return nil + }} + f := newTestForecastCurtailment(sender, store) + defer f.Close() + if err := f.Send(context.Background(), "pv", []byte(`{"action":"curtail","power_w":2000}`)); err != nil { + t.Fatal(err) + } + if !f.Active() { + t.Fatal("commanded curtailment not censored before acknowledgement") + } + fail = true + if err := f.Send(context.Background(), "pv", []byte(`{"action":"curtail_disable"}`)); err == nil { + t.Fatal("underlying error changed") + } + f.ObserveIntent(false) + if !f.Active() { + t.Fatal("failed release lost censorship") + } + fail = false + f.Send(context.Background(), "pv", []byte(`{"action":"curtail_disable"}`)) + waitCurtailment(t, f, false) + if len(sender.recorded()) != 3 { + t.Fatal("wrapper sent extra commands") + } +} + +func TestForecastCurtailmentRestartAndRenameUseHardwareIdentity(t *testing.T) { + store := &curtailStore{identities: map[string]string{"old-pv-name": "hardware-1", "second-pv": "hardware-2"}} + sender := &stubSender{} + f := newTestForecastCurtailment(sender, store) + f.Send(context.Background(), "old-pv-name", []byte(`{"action":"curtail","power_w":0}`)) + f.Send(context.Background(), "second-pv", []byte(`{"action":"curtail","power_w":2000}`)) + f.Close() + stored, _ := store.LoadConfig(forecastCurtailmentKey) + if strings.Contains(stored, "old-pv-name") || !strings.Contains(stored, "hardware-1") { + t.Fatalf("not stable identity keyed: %s", stored) + } + store.mu.Lock() + store.identities["new-pv-name"] = "hardware-1" + delete(store.identities, "old-pv-name") + store.mu.Unlock() + restarted := newTestForecastCurtailment(sender, store) + defer restarted.Close() + if !restarted.Active() { + t.Fatal("restart lost pending curtailment") + } + restarted.RecordDefault("new-pv-name", true) + if !restarted.Active() { + t.Fatal("one default cleared two devices") + } + restarted.RecordDefault("second-pv", false) + if !restarted.Active() { + t.Fatal("failed default cleared censorship") + } + restarted.RecordDefault("second-pv", true) + waitCurtailment(t, restarted, false) +} + +func TestForecastCurtailmentManualHoldAndUnknown(t *testing.T) { + store := &curtailStore{identities: map[string]string{}} + f := newTestForecastCurtailment(&stubSender{}, store) + f.ObserveIntent(true) + if !f.Active() { + t.Fatal("manual zero hold must censor without a command") + } + f.ObserveIntent(false) + if f.Active() { + t.Fatal("cleared command-free intent retained false curtailment") + } + f.Send(context.Background(), "unidentified", []byte(`{"action":"curtail","power_w":0}`)) + f.Close() + r := newTestForecastCurtailment(&stubSender{}, store) + defer r.Close() + r.RecordDefault("unrelated", true) + if !r.Active() { + t.Fatal("unrelated default cleared unknown prior identity") + } + r.ConfirmUncurtailed() + waitCurtailment(t, r, false) +} + +func TestForecastCurtailmentPersistenceCannotBlockDispatch(t *testing.T) { + store := &curtailStore{identities: map[string]string{"pv": "hardware-1"}, block: make(chan struct{})} + f := newTestForecastCurtailment(&stubSender{}, store) + defer f.Close() + defer close(store.block) + ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond) + defer cancel() + done := make(chan error, 1) + go func() { done <- f.Send(ctx, "pv", []byte(`{"action":"curtail","power_w":2000}`)) }() + select { + case err := <-done: + if err != nil { + t.Fatal(err) + } + case <-ctx.Done(): + t.Fatal("persistence blocked command return") + } + if !f.Active() { + t.Fatal("slow persistence delayed live censoring") + } +} + +func TestForecastCurtailmentPendingDriversRecoverAndRetry(t *testing.T) { + store := &curtailStore{identities: map[string]string{"renamed": "hardware-1", "unrelated": "hardware-2"}, value: `{"version":1,"device_ids":["hardware-1","absent-hardware"],"unknown":true}`} + fail := true + sender := &stubSender{handler: func(context.Context, string) error { + if fail { + return errors.New("release failed") + } + return nil + }} + f := newTestForecastCurtailment(sender, store) + defer f.Close() + names := []string{"unrelated", "renamed", "renamed", "missing"} + if got := f.PendingDrivers(names); !reflect.DeepEqual(got, []string{"renamed"}) { + t.Fatalf("restart identity mapping: %v", got) + } + f.Send(context.Background(), "renamed", []byte(`{"action":"curtail_disable"}`)) + if got := f.PendingDrivers(names); !reflect.DeepEqual(got, []string{"renamed"}) { + t.Fatalf("failed release must remain eligible for Core retry: %v", got) + } + fail = false + f.Send(context.Background(), "renamed", []byte(`{"action":"curtail_disable"}`)) + if got := f.PendingDrivers(names); len(got) != 0 { + t.Fatalf("acknowledged release still pending: %v", got) + } + if !f.Active() { + t.Fatal("release of one known device cleared unknown/absent identity") + } + if len(sender.recorded()) != 2 { + t.Fatal("identity recovery sent commands") + } +} + +func newTestForecastCurtailment(sender driverCommandSender, store forecastCurtailmentStore) *forecastCurtailment { + f := newForecastCurtailment(sender, store) + f.SetReleaseEvidence(func(string) bool { return true }) + return f +} + +func TestForecastCurtailmentReleaseRequiresEvidence(t *testing.T) { + store := &curtailStore{identities: map[string]string{"pv": "hardware-1"}} + f := newForecastCurtailment(&stubSender{}, store) + defer f.Close() + f.Send(context.Background(), "pv", []byte(`{"action":"curtail","power_w":2000}`)) + f.Send(context.Background(), "pv", []byte(`{"action":"curtail_disable"}`)) + if !f.Active() || len(f.PendingDrivers([]string{"pv"})) != 1 { + t.Fatal("nil evidence trusted a successful no-op release") + } + f.SetReleaseEvidence(func(string) bool { return false }) + f.Send(context.Background(), "pv", []byte(`{"action":"curtail_disable"}`)) + if !f.Active() { + t.Fatal("unverified driver cleared censorship") + } + f.SetReleaseEvidence(func(name string) bool { return name == "pv" }) + f.Send(context.Background(), "pv", []byte(`{"action":"curtail_disable"}`)) + waitCurtailment(t, f, false) +} diff --git a/go/cmd/ftw/forecast_measurements.go b/go/cmd/ftw/forecast_measurements.go new file mode 100644 index 00000000..9bc4bcc0 --- /dev/null +++ b/go/cmd/ftw/forecast_measurements.go @@ -0,0 +1,180 @@ +package main + +import ( + "path/filepath" + "strings" + "time" + + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/control" + "github.com/srcfl/ftw/go/internal/drivers" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +// forecastMeasurementOptions declares known significant sources. FlowIDs remain +// unset: driver names and inverter groups do not identify physical measurements. +func forecastMeasurementOptions(cfg *config.Config, catalog []drivers.CatalogEntry) telemetry.ForecastOptions { + opts, _ := forecastMeasurementTopology(cfg, catalog) + return opts +} + +// forecastMeasurementTopologyUnknown names sources whose presence config cannot +// establish. Callers must require fresh observations of these optional flows +// before qualifying a complete household balance; this is not only a log hint. +func forecastMeasurementTopologyUnknown(cfg *config.Config, catalog []drivers.CatalogEntry) []string { + _, unknown := forecastMeasurementTopology(cfg, catalog) + return unknown +} + +func forecastMeasurementTopology(cfg *config.Config, catalog []drivers.CatalogEntry) (telemetry.ForecastOptions, []string) { + opts := telemetry.ForecastOptions{} + if cfg == nil { + opts.HouseholdInvalidReason = "missing_config" + return opts, []string{"missing_config"} + } + var unknown []string + type configured struct { + driver config.Driver + entry drivers.CatalogEntry + found bool + } + active := make([]configured, 0, len(cfg.Drivers)) + pvSources := 0 + for _, d := range cfg.Drivers { + if d.Disabled { + continue + } + entry, found := forecastCatalogEntry(catalog, d.Lua) + active = append(active, configured{d, entry, found}) + if found && forecastCapability(entry, "pv") { + pvSources++ + } + } + sitePV := cfg.Weather != nil && (cfg.Weather.PVRatedW > 0 || len(cfg.Weather.PVArrays) > 0) + expectedPV := 0 + seen := make(map[telemetry.ForecastFlow]bool) + add := func(d config.Driver, kind telemetry.DerType) { + flow := telemetry.ForecastFlow{Driver: d.Name, DerType: kind} + if seen[flow] { + return + } + seen[flow] = true + if kind == telemetry.DerPV { + expectedPV++ + } + opts.ExpectedFlows = append(opts.ExpectedFlows, flow) + } + for _, item := range active { + d, e := item.driver, item.entry + if d.IsSiteMeter { + add(d, telemetry.DerMeter) + } + if !item.found { + unknown = append(unknown, d.Name+":unknown_driver_capabilities") + if d.BatteryCapacityWh > 0 || d.BatteryTelemetryOnly { + add(d, telemetry.DerBattery) + } + continue + } + pv, bat, ev, v2x := forecastCapability(e, "pv"), forecastCapability(e, "battery"), forecastCapability(e, "ev"), forecastCapability(e, "v2x_charger") + if v2x { + add(d, telemetry.DerV2X) + } else if ev { + add(d, telemetry.DerEV) + } + if bat && (d.BatteryCapacityWh > 0 || d.BatteryTelemetryOnly) { + add(d, telemetry.DerBattery) + } + if pv { + readPV, hasReadPV := d.Config["read_pv"].(bool) + dedicated := !bat && !ev && !v2x + declared := readPV || d.SupportsPVCurtail || dedicated || (sitePV && pvSources == 1) + if hasReadPV && !readPV { + continue + } + // Optional does not mean absent. Require a fresh reading (zero is valid) + // before using the household balance, while preserving why it was required. + add(d, telemetry.DerPV) + if !declared { + unknown = append(unknown, d.Name+":optional_pv_requires_measurement") + } + } + } + // Adopted OCPP chargers publish EV power under driver_name without a Lua + // registry entry. Their first missing reading is unknown, including at boot. + // A Lua V2X charger already owns the one bidirectional measurement. + for _, lp := range cfg.Loadpoints { + name := lp.DriverName + if strings.TrimSpace(name) == "" { + continue + } + if seen[telemetry.ForecastFlow{Driver: name, DerType: telemetry.DerV2X}] { + continue + } + add(config.Driver{Name: name}, telemetry.DerEV) + } + if sitePV && expectedPV == 0 { + opts.HouseholdInvalidReason = "configured_pv_without_measurement_source" + unknown = append(unknown, "site:configured_pv_without_measurement_source") + } + return opts, unknown +} + +func forecastCapability(e drivers.CatalogEntry, kind string) bool { + for _, capability := range e.Capabilities { + if capability == kind { + return true + } + } + return false +} + +func forecastCatalogEntry(catalog []drivers.CatalogEntry, luaPath string) (drivers.CatalogEntry, bool) { + if strings.TrimSpace(luaPath) == "" { + return drivers.CatalogEntry{}, false + } + want := filepath.ToSlash(filepath.Clean(luaPath)) + for _, e := range catalog { + if e.Path != "" && strings.EqualFold(filepath.ToSlash(filepath.Clean(e.Path)), want) { + return e, true + } + } + // Ambiguous basenames can refer to different user and managed packages. + var found drivers.CatalogEntry + matches := 0 + for _, e := range catalog { + name := e.Filename + if name == "" { + name = filepath.Base(e.Path) + } + if strings.EqualFold(name, filepath.Base(want)) { + found = e + matches++ + } + } + return found, matches == 1 +} + +// forecastCurtailmentActive only reads control intent. Caller holds ctrlMu. +// LastCurtailedDrivers does not prove release acknowledgment; callers must also +// retain unresolved failed releases from command results. +func forecastCurtailmentActive(ctrl *control.State, now time.Time) bool { + if ctrl == nil { + return false + } + if len(ctrl.LastCurtailedDrivers) > 0 { + return true + } + hold := ctrl.ManualPVHold + if !hold.ExpiresAt.IsZero() && now.Before(hold.ExpiresAt) { + return true + } + if ctrl.SlotDirective != nil { + if slot, ok := ctrl.SlotDirective(now); ok && slot.PVLimitW > 0 { + if (slot.SlotStart.IsZero() || !now.Before(slot.SlotStart)) && (slot.SlotEnd.IsZero() || now.Before(slot.SlotEnd)) { + return true + } + } + } + return false +} diff --git a/go/cmd/ftw/forecast_measurements_test.go b/go/cmd/ftw/forecast_measurements_test.go new file mode 100644 index 00000000..9952f523 --- /dev/null +++ b/go/cmd/ftw/forecast_measurements_test.go @@ -0,0 +1,204 @@ +package main + +import ( + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/control" + "github.com/srcfl/ftw/go/internal/drivers" + "github.com/srcfl/ftw/go/internal/telemetry" + "reflect" + "testing" + "time" +) + +func measurementCatalog() []drivers.CatalogEntry { + return []drivers.CatalogEntry{ + {Path: "drivers/meter.lua", Filename: "meter.lua", Capabilities: []string{"meter"}}, + {Path: "drivers/hybrid.lua", Filename: "hybrid.lua", Capabilities: []string{"meter", "pv", "battery"}}, + {Path: "drivers/solar.lua", Filename: "solar.lua", Capabilities: []string{"pv"}}, + {Path: "drivers/charger.lua", Filename: "charger.lua", Capabilities: []string{"ev"}}, + {Path: "drivers/v2x.lua", Filename: "v2x.lua", Capabilities: []string{"v2x_charger", "ev"}}, + {Path: "drivers/vehicle.lua", Filename: "vehicle.lua", ReadOnly: true, Capabilities: []string{"vehicle"}}, + } +} +func TestForecastMeasurementOptionsInstalledFlows(t *testing.T) { + cfg := &config.Config{Drivers: []config.Driver{ + {Name: "site", Lua: "drivers/meter.lua", IsSiteMeter: true}, + {Name: "hybrid-no-pack", Lua: "drivers/hybrid.lua", Config: map[string]any{"read_pv": false}}, + {Name: "battery", Lua: "drivers/hybrid.lua", BatteryCapacityWh: 10000, Config: map[string]any{"read_pv": false}}, + {Name: "observed-battery", Lua: "drivers/hybrid.lua", BatteryTelemetryOnly: true, Config: map[string]any{"read_pv": false}}, + {Name: "solar", Lua: "/install/drivers/solar.lua"}, + {Name: "charger", Lua: "drivers/charger.lua", BatteryCapacityWh: 70000}, + {Name: "vehicle", Lua: "drivers/vehicle.lua", BatteryCapacityWh: 70000}, + {Name: "v2x", Lua: "drivers/v2x.lua"}, + {Name: "disabled", Lua: "drivers/solar.lua", Disabled: true}, + }} + opts := forecastMeasurementOptions(cfg, measurementCatalog()) + want := []telemetry.ForecastFlow{ + {Driver: "site", DerType: telemetry.DerMeter}, + {Driver: "battery", DerType: telemetry.DerBattery}, + {Driver: "observed-battery", DerType: telemetry.DerBattery}, + {Driver: "solar", DerType: telemetry.DerPV}, + {Driver: "charger", DerType: telemetry.DerEV}, + {Driver: "v2x", DerType: telemetry.DerV2X}, + } + if !reflect.DeepEqual(opts.ExpectedFlows, want) { + t.Fatalf("flows=%+v want=%+v", opts.ExpectedFlows, want) + } +} +func TestForecastMeasurementNoPVSiteAndUnknownHybrid(t *testing.T) { + tel := telemetry.NewStore() + tel.Update("site", telemetry.DerMeter, 1000, nil, nil) + tel.RecordDriverSuccess("site") + cfg := &config.Config{Drivers: []config.Driver{{Name: "site", Lua: "drivers/meter.lua", IsSiteMeter: true}}} + r := tel.ForecastMeasurement(time.Now(), "site", forecastMeasurementOptions(cfg, measurementCatalog())) + if !r.Valid || r.PVValid { + t.Fatalf("no-PV site: %+v", r) + } + cfg.Drivers = append(cfg.Drivers, config.Driver{Name: "hybrid", Lua: "drivers/hybrid.lua"}) + opts := forecastMeasurementOptions(cfg, measurementCatalog()) + r = tel.ForecastMeasurement(time.Now(), "site", opts) + if r.Valid || r.PVValid || len(forecastMeasurementTopologyUnknown(cfg, measurementCatalog())) != 1 { + t.Fatalf("implicit hybrid PV absence became zero: %+v", r) + } + tel.Update("hybrid", telemetry.DerPV, 0, nil, nil) + tel.RecordDriverSuccess("hybrid") + r = tel.ForecastMeasurement(time.Now(), "site", opts) + if !r.Valid || !r.PVValid || r.HouseholdW != 1000 { + t.Fatalf("fresh optional zero did not qualify: %+v", r) + } +} +func TestForecastMeasurementKnownNeverEmittedSources(t *testing.T) { + tel := telemetry.NewStore() + tel.Update("site", telemetry.DerMeter, 4000, nil, nil) + tel.RecordDriverSuccess("site") + for _, d := range []config.Driver{ + {Name: "missing", Lua: "drivers/hybrid.lua", BatteryCapacityWh: 10000, Config: map[string]any{"read_pv": false}}, + {Name: "missing", Lua: "drivers/solar.lua"}, + } { + cfg := &config.Config{Drivers: []config.Driver{{Name: "site", Lua: "drivers/meter.lua", IsSiteMeter: true}, d}} + if r := tel.ForecastMeasurement(time.Now(), "site", forecastMeasurementOptions(cfg, measurementCatalog())); r.Valid { + t.Fatalf("known missing source accepted: %+v", d) + } + } +} +func TestForecastCatalogPathAndAmbiguousFallback(t *testing.T) { + cat := []drivers.CatalogEntry{{Path: "managed/same.lua", Filename: "same.lua", Capabilities: []string{"pv"}}, {Path: "user/same.lua", Filename: "same.lua", Capabilities: []string{"vehicle"}}} + if e, ok := forecastCatalogEntry(cat, "user/same.lua"); !ok || !forecastCapability(e, "vehicle") { + t.Fatal("exact path lost") + } + if _, ok := forecastCatalogEntry(cat, "other/same.lua"); ok { + t.Fatal("ambiguous fallback invented source") + } +} +func TestForecastDeclaredPVWithoutSourceInvalidatesOnlyHouse(t *testing.T) { + cfg := &config.Config{Drivers: []config.Driver{{Name: "site", Lua: "drivers/meter.lua", IsSiteMeter: true}}} + cfg.Weather = &config.Weather{PVRatedW: 8000} + opts := forecastMeasurementOptions(cfg, measurementCatalog()) + if opts.HouseholdInvalidReason == "" { + t.Fatal("declared PV missing without qualification") + } + tel := telemetry.NewStore() + tel.Update("site", telemetry.DerMeter, 1000, nil, nil) + tel.RecordDriverSuccess("site") + tel.Update("independent", telemetry.DerPV, -3000, nil, nil) + tel.RecordDriverSuccess("independent") + r := tel.ForecastMeasurement(time.Now(), "site", opts) + if r.Valid || !r.PVValid { + t.Fatalf("house topology ambiguity affected independent PV: %+v", r) + } +} +func TestForecastCatalogFailureRetainsProvisionalObservedFlows(t *testing.T) { + cfg := &config.Config{Drivers: []config.Driver{{Name: "site", Lua: "custom/meter.lua", IsSiteMeter: true}}} + opts := forecastMeasurementOptions(cfg, nil) + tel := telemetry.NewStore() + tel.Update("site", telemetry.DerMeter, 1000, nil, nil) + tel.RecordDriverSuccess("site") + if r := tel.ForecastMeasurement(time.Now(), "site", opts); !r.Valid { + t.Fatalf("catalog failure blocked coherent observed site: %+v", r) + } + if len(forecastMeasurementTopologyUnknown(cfg, nil)) == 0 { + t.Fatal("unknown capabilities concealed") + } +} +func TestForecastCurtailmentIntentAndRelease(t *testing.T) { + now := time.Now() + ctrl := &control.State{} + if forecastCurtailmentActive(ctrl, now) { + t.Fatal("empty state curtailed") + } + ctrl.ManualPVHold = control.PVManualHold{LimitW: 0, ExpiresAt: now.Add(time.Minute)} + if !forecastCurtailmentActive(ctrl, now) { + t.Fatal("manual zero not curtailed") + } + before := ctrl.ManualPVHold + if forecastCurtailmentActive(ctrl, now.Add(time.Minute)) { + t.Fatal("expired hold active") + } + if ctrl.ManualPVHold != before { + t.Fatal("read mutated hold") + } + ctrl.ManualPVHold = control.PVManualHold{} + ctrl.LastCurtailedDrivers = map[string]bool{"pv": true} + if !forecastCurtailmentActive(ctrl, now) { + t.Fatal("tracked curtailment lost") + } + ctrl.LastCurtailedDrivers = nil + ctrl.SlotDirective = func(time.Time) (control.SlotDirective, bool) { + return control.SlotDirective{SlotStart: now, SlotEnd: now.Add(15 * time.Minute), PVLimitW: 100}, true + } + if !forecastCurtailmentActive(ctrl, now) || forecastCurtailmentActive(ctrl, now.Add(15*time.Minute)) { + t.Fatal("slot interval boundary wrong") + } + ctrl.SlotDirective = func(time.Time) (control.SlotDirective, bool) { return control.SlotDirective{PVLimitW: 0}, true } + if forecastCurtailmentActive(ctrl, now) { + t.Fatal("planner zero should release") + } +} + +func TestForecastMeasurementConfiguredOCPPRequiresFirstPower(t *testing.T) { + cfg := &config.Config{Drivers: []config.Driver{{Name: "site", Lua: "drivers/meter.lua", IsSiteMeter: true}, {Name: "pv", Lua: "drivers/solar.lua"}}, Loadpoints: []config.Loadpoint{{ID: "garage", DriverName: "ocpp-charger"}}} + tel := telemetry.NewStore() + tel.Update("site", telemetry.DerMeter, 1000, nil, nil) + tel.RecordDriverSuccess("site") + tel.Update("pv", telemetry.DerPV, -2000, nil, nil) + tel.RecordDriverSuccess("pv") + opts := forecastMeasurementOptions(cfg, measurementCatalog()) + first := tel.ForecastMeasurement(time.Now(), "site", opts) + if first.Valid || !first.PVValid { + t.Fatalf("never-emitted EV treated as zero or blocked independent PV: %+v", first) + } + tel.Update("ocpp-charger", telemetry.DerEV, 0, nil, nil) + tel.RecordDriverSuccess("ocpp-charger") + zero := tel.ForecastMeasurement(time.Now(), "site", opts) + if !zero.Valid || !zero.PVValid || zero.HouseholdW != 3000 { + t.Fatalf("fresh known EV zero did not qualify: %+v", zero) + } + tel.Update("ocpp-charger", telemetry.DerEV, 600, nil, nil) + charging := tel.ForecastMeasurement(time.Now(), "site", opts) + if !charging.Valid || charging.HouseholdW != 2400 { + t.Fatalf("charger load did not leave household balance: %+v", charging) + } +} + +func TestForecastMeasurementLoadpointDoesNotDuplicateLuaEVOrV2X(t *testing.T) { + cfg := &config.Config{Drivers: []config.Driver{{Name: "lua-ev", Lua: "drivers/charger.lua"}, {Name: "lua-v2x", Lua: "drivers/v2x.lua"}}, Loadpoints: []config.Loadpoint{{ID: "one", DriverName: "lua-ev"}, {ID: "two", DriverName: "lua-v2x"}, {ID: "three", DriverName: "ocpp"}, {ID: "duplicate", DriverName: "ocpp"}, {ID: "empty"}}} + opts := forecastMeasurementOptions(cfg, measurementCatalog()) + want := []telemetry.ForecastFlow{{Driver: "lua-ev", DerType: telemetry.DerEV}, {Driver: "lua-v2x", DerType: telemetry.DerV2X}, {Driver: "ocpp", DerType: telemetry.DerEV}} + if !reflect.DeepEqual(opts.ExpectedFlows, want) { + t.Fatalf("EV topology duplicated a physical stream: %+v", opts.ExpectedFlows) + } +} + +func TestForecastMeasurementLoadpointChangeChangesModelBinding(t *testing.T) { + st := hostForecastDB(t) + cfg := &config.Config{Drivers: []config.Driver{{Name: "site", Lua: "drivers/meter.lua", IsSiteMeter: true}}, Loadpoints: []config.Loadpoint{{ID: "garage", DriverName: "ocpp-first"}}} + site := newForecastSiteConfig(st) + site.Configure(cfg, measurementCatalog()) + before := site.Snapshot() + cfg.Loadpoints[0].DriverName = "ocpp-replacement" + site.Configure(cfg, measurementCatalog()) + after := site.Snapshot() + if before.LearningRevision == after.LearningRevision || before.Revision == after.Revision { + t.Fatal("adopted EV source changed without changing model/evaluation binding") + } +} diff --git a/go/cmd/ftw/forecast_occupancy_test.go b/go/cmd/ftw/forecast_occupancy_test.go new file mode 100644 index 00000000..af9e41d5 --- /dev/null +++ b/go/cmd/ftw/forecast_occupancy_test.go @@ -0,0 +1,174 @@ +package main + +import ( + "context" + "encoding/json" + "os" + "reflect" + "sync" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/energyforecast" + "github.com/srcfl/ftw/go/internal/forecasting" +) + +func TestForecastOccupancySnapshotSurvivesIntentChange(t *testing.T) { + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + tracker := trackerFixture(at) + away := true + tracker.away = func(time.Time) bool { return away } + inputs := tracker.Snapshot(at, trackerWeather(at, at)) + away = false + slots := trackerSlots(at, 4) + inputs.Record(slots, slots, "occupancy-frozen", at.UnixMilli()) + job := <-tracker.queue + if len(job.issue.Occupancy) != 193 { + t.Fatalf("captured quarter count=%d", len(job.issue.Occupancy)) + } + for _, row := range job.issue.Occupancy { + if row.Home || row.AvailableAtMS > job.issue.OriginMS { + t.Fatalf("live intent or future knowledge entered archive: %+v", row) + } + if row.AvailableAtMS > job.issue.LatestInputMS { + t.Fatal("latest input precedes occupancy feature") + } + } + if err := job.issue.Validate(); err != nil { + t.Fatal(err) + } +} + +func TestRustForecastOccupancyRejectsGapBeforeWorker(t *testing.T) { + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + issue := hostForecastIssue(start, start, 1) + issue.Occupancy = []forecasting.Occupancy{{StartMS: start.UnixMilli(), EndMS: start.Add(15 * time.Minute).UnixMilli(), AvailableAtMS: start.UnixMilli(), Home: false}} + called := false + r := &rustForecast{client: energyforecast.NewClient(hostForecastExchange(func(context.Context, []byte) ([]byte, error) { called = true; return nil, nil }))} + if _, err := r.Predict(context.Background(), hostForecastSite(), issue, nil, nil); err == nil || called { + t.Fatal("missing archived occupancy defaulted to current home profile") + } +} + +func TestRustForecastNativeOccupancyReplayAfterIntentChange(t *testing.T) { + binary := os.Getenv("FTW_FORECAST_WORKER") + if binary == "" { + t.Skip("set FTW_FORECAST_WORKER for native occupancy replay") + } + st := hostForecastDB(t) + site := hostForecastSite() + site.HasLocation = false + worker, err := newRustForecast(st, binary) + if err != nil { + t.Fatal(err) + } + defer worker.Close() + origin := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + // Different measured profiles make replacing captured absence observable. + for day := 16; day > 0; day-- { + at := origin.AddDate(0, 0, -day) + away := day%2 == 0 + load := 4000.0 + if away { + load = 200 + } + o := forecasting.Observation{StartMS: at.UnixMilli(), EndMS: at.Add(15 * time.Minute).UnixMilli(), AvailableAtMS: at.Add(15 * time.Minute).UnixMilli(), LoadKnown: true, LoadW: load, ConfigVersion: site.Revision, Quality: "complete"} + if err = worker.Update(context.Background(), site, o, nil, away); err != nil { + t.Fatal(err) + } + } + frozen := worker.Snapshot() + issue := hostForecastIssue(origin, origin, 1) + awayAtIssue := map[int64]bool{} + for i := 0; i < 4; i++ { + at := origin.Add(time.Duration(i) * 15 * time.Minute).UnixMilli() + awayAtIssue[at] = true + } + first, err := worker.Predict(context.Background(), site, issue, frozen, awayAtIssue) + if err != nil { + t.Fatal(err) + } + for _, row := range first.Occupancy { + if row.AvailableAtMS > first.LatestInputMS { + t.Fatal("candidate latest input precedes occupancy feature") + } + } + applyForecastBands(&first, nil) + if err = st.SaveForecastIssue(context.Background(), first); err != nil { + t.Fatal(err) + } + archived, err := st.LoadForecastIssues(context.Background(), 0, time.Now().Add(time.Hour).UnixMilli(), 10) + if err != nil || len(archived) != 1 { + t.Fatalf("archive read: %d %v", len(archived), err) + } + replayIssue := archived[0] + var opaque json.RawMessage + for _, model := range replayIssue.Models { + if model.Name == "energyplan" { + opaque, err = st.LoadForecastModelState(context.Background(), model.StateID) + if err != nil { + t.Fatal(err) + } + } + } + if len(opaque) == 0 { + t.Fatal("missing archived native model") + } + replaySite := forecastSite{SiteID: replayIssue.Site.SiteID, Revision: replayIssue.ConfigVersion, LearningRevision: replayIssue.Site.LearningRevision, Timezone: replayIssue.Site.Timezone, HasLocation: replayIssue.Site.HasLocation, Latitude: replayIssue.Site.Latitude, Longitude: replayIssue.Site.Longitude} + replayRaw, err := json.Marshal(savedForecastState{SiteID: replaySite.SiteID, ConfigRevision: rustConfigRevision(replaySite), LatestAvailableMS: replayIssue.Models[0].UpdatedAtMS, State: opaque}) + if err != nil { + t.Fatal(err) + } + restarted, err := newRustForecast(st, binary) + if err != nil { + t.Fatal(err) + } + defer restarted.Close() + // The caller now says home. Archived features must take precedence. + replay, err := restarted.Predict(context.Background(), replaySite, replayIssue, replayRaw, map[int64]bool{}) + if err != nil { + t.Fatal(err) + } + applyForecastBands(&replay, nil) + if !reflect.DeepEqual(first.Series, replay.Series) || !reflect.DeepEqual(first.Occupancy, replay.Occupancy) { + t.Fatal("archived absence changed after restart/current intent change") + } + homeIssue := issue + home, err := restarted.Predict(context.Background(), site, homeIssue, frozen, map[int64]bool{}) + if err != nil { + t.Fatal(err) + } + if reflect.DeepEqual(home.Series[0].Points[0].LoadW, first.Series[0].Points[0].LoadW) { + t.Fatal("fixture did not distinguish home and away predictions") + } +} + +func TestForecastPendingIdentityCannotUseSavedModels(t *testing.T) { + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + f := trackerFixture(at) + pending := trackerSite() + pending.IdentityPending = true + f.site = func() forecastSite { return pending } + f.configMu = &sync.RWMutex{} + refreshes := 0 + f.refreshIdentity = func() { + if !f.configMu.TryLock() { + t.Fatal("identity refresh runs under config read lock") + } + f.configMu.Unlock() + refreshes++ + } + candidateRead := false + f.candidate = &trackingCandidate{onSnapshot: func() { candidateRead = true }} + in := f.Snapshot(at, trackerWeather(at, at)) + if in.Weather == nil || len(in.Weather) != 0 || in.PV != nil || in.Load != nil || in.Record != nil || candidateRead { + t.Fatal("unconfirmed hardware used or archived a saved model") + } + // Pending startup must not touch live telemetry or the archive either. + f.tele = nil + f.store = nil + f.observe(context.Background(), at) + if refreshes != 2 { + t.Fatalf("identity refreshes=%d want2", refreshes) + } +} diff --git a/go/cmd/ftw/forecast_release_evidence.go b/go/cmd/ftw/forecast_release_evidence.go new file mode 100644 index 00000000..87753449 --- /dev/null +++ b/go/cmd/ftw/forecast_release_evidence.go @@ -0,0 +1,147 @@ +package main + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "math" + "os" + "path/filepath" + "strconv" + "strings" + + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/drivers" +) + +// forecastReleaseEvidence is only evidence about a curtail_disable command +// that the caller has already seen succeed. Generic default never qualifies. +// Config must contain the resolved Lua paths used by the driver host. Hashing +// runs at configuration time; the returned immutable lookup performs no I/O. +func forecastReleaseEvidence(cfg *config.Config, catalog []drivers.CatalogEntry) func(string) bool { + return forecastReleaseEvidenceWithDigest(cfg, catalog, forecastReleaseScriptDigest) +} + +func forecastReleaseEvidenceWithDigest(cfg *config.Config, catalog []drivers.CatalogEntry, digest func(string) (string, error)) func(string) bool { + known := map[string]bool{} + if cfg != nil { + for _, d := range cfg.Drivers { + if d.Disabled || d.ObserveOnly || d.BatteryTelemetryOnly || d.Name == "" { + continue + } + e, found := forecastCatalogEntry(catalog, d.Lua) + if !found || e.ReadOnly || !forecastCapability(e, "pv") { + continue + } + hash, err := digest(d.Lua) + if err == nil { + known[d.Name] = forecastReviewedRelease(hash, d.Config) + } + } + } + return func(name string) bool { return known[name] } +} + +func forecastReleaseScriptDigest(path string) (string, error) { + // A relative lookup could inspect a different script from the one resolved + // by the host. Unresolved or unreadable source cannot prove release behavior. + if !filepath.IsAbs(path) { + return "", fmt.Errorf("unresolved driver path") + } + f, err := os.Open(path) + if err != nil { + return "", err + } + defer f.Close() + info, err := f.Stat() + if err != nil { + return "", err + } + if !info.Mode().IsRegular() || info.Size() > 1<<20 { + return "", fmt.Errorf("invalid driver source size or type") + } + h := sha256.New() + n, err := io.Copy(h, io.LimitReader(f, (1<<20)+1)) + if err != nil { + return "", err + } + if n > 1<<20 { + return "", fmt.Errorf("driver source exceeds size limit") + } + return hex.EncodeToString(h.Sum(nil)), nil +} + +// These exact public scripts attempt PV release and return write failures. +// Reviewed source and recovery baselines: +// https://github.com/srcfl/device-drivers/tree/0ce2c55db48f3ded7cf1aeeeec29e5caed09454b +// Unknown revisions remain censored until their release branch is reviewed. +// ArtifactSHA256 is deliberately unused: a signed package/archive digest is +// not the digest of the Lua bytes actually loaded by the host. +func forecastReviewedRelease(digest string, settings map[string]any) bool { + switch digest { + case "c04d137d595ba50b8c6178c82d917b115dbe9a7cbd2cf671ef2660e871f96de3": // ferroamp.lua + // Without this value Ferroamp returns success but publishes nothing. + return forecastReleaseWatts(settings["pplim_release_w"], math.MaxInt32) + case "a11ddc8de433c527a3d63cd014d243b09f3393ee3afa9b8e1594d4de8de37562", // sungrow.lua + "466a5f8637e6756fc2e1af4197d4edc1845474231413c0016f0e5900acb7b7ac": + if settings["pv_curtail_method"] == "feed_in" { + return forecastReleaseWatts(settings["feed_in_release_w"], math.MaxUint16) + } + return true // disable active-power limit, then restore its inert ratio + case "94b5f18fb42c1413540d7321bca47ed755c8a0a9b069f8d51dbac4384910c496", // solaredge.lua + "38e8b39254e3171d758cd27fa7a07bd87d62f94e62b74d2d87ad81eb19b53823", + "8ea6381cdc608939919b8ff55c22c1febe8a8da5a0b81f93cbd341a7d1733467", // solaredge_pv.lua + "d956b2473c27e52f63504862a85b36f803414327a583464fca087679c428de47", + "7a590f5f35efc395754f002f0d48aef8b2d46cab525bf2ae863f4fd73b01781b", // solaredge_legacy.lua + "669aa969467e81c337269ab0f5a2d01d01a0f270deb55491c6a5adc6df848a6f": + return true // atomic APC enable=0, limit=100%; no nameplate needed + } + return false +} + +func forecastReleaseWatts(value any, ceiling float64) bool { + var w float64 + switch v := value.(type) { + case int: + w = float64(v) + case int64: + w = float64(v) + case float64: + w = v + case json.Number: + w, _ = v.Float64() + case string: + w, _ = strconv.ParseFloat(strings.TrimSpace(v), 64) + default: + return false + } + // Lua floors these settings before sending integer watts. Sub-watt values + // are zero on the wire, and cannot qualify as a release ceiling. + return !math.IsNaN(w) && !math.IsInf(w, 0) && w >= 1 && w <= ceiling +} + +// Proof is bound to the loaded driver generation. An independent driver +// restart/update cannot inherit release semantics from the previous instance. +func forecastReleaseEvidenceForRegistry(cfg *config.Config, catalog []drivers.CatalogEntry, reg *drivers.Registry) func(string) bool { + get := func(name string) (uint64, bool) { + s, ok := reg.ControlStatus(name) + return s.Generation, ok + } + return bindForecastReleaseGeneration(forecastReleaseEvidence(cfg, catalog), reg.Names(), get) +} + +func bindForecastReleaseGeneration(evidence func(string) bool, names []string, generation func(string) (uint64, bool)) func(string) bool { + bound := make(map[string]uint64) + for _, name := range names { + if value, ok := generation(name); ok && evidence(name) { + bound[name] = value + } + } + return func(name string) bool { + old, known := bound[name] + current, live := generation(name) + return known && live && old == current + } +} diff --git a/go/cmd/ftw/forecast_release_evidence_test.go b/go/cmd/ftw/forecast_release_evidence_test.go new file mode 100644 index 00000000..2c7da937 --- /dev/null +++ b/go/cmd/ftw/forecast_release_evidence_test.go @@ -0,0 +1,123 @@ +package main + +import ( + "crypto/sha256" + "encoding/hex" + "fmt" + "math" + "os" + "path/filepath" + "testing" + + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/drivers" +) + +const releaseFerroamp = "c04d137d595ba50b8c6178c82d917b115dbe9a7cbd2cf671ef2660e871f96de3" +const releaseSungrow = "a11ddc8de433c527a3d63cd014d243b09f3393ee3afa9b8e1594d4de8de37562" +const releaseSolarEdge = "94b5f18fb42c1413540d7321bca47ed755c8a0a9b069f8d51dbac4384910c496" + +func TestForecastReleaseRequiresReviewedCodeAndPhysicalReleaseConfig(t *testing.T) { + for _, tc := range []struct { + name, digest string + settings map[string]any + want bool + }{ + {"Ferroamp missing release", releaseFerroamp, nil, false}, + {"Ferroamp zero release", releaseFerroamp, map[string]any{"pplim_release_w": 0}, false}, + {"Ferroamp subwatt becomes zero", releaseFerroamp, map[string]any{"pplim_release_w": 0.5}, false}, + {"Ferroamp declared ceiling", releaseFerroamp, map[string]any{"pplim_release_w": 15000}, true}, + {"Ferroamp Lua numeric string", releaseFerroamp, map[string]any{"pplim_release_w": " 15000 "}, true}, + {"Ferroamp invalid number", releaseFerroamp, map[string]any{"pplim_release_w": math.Inf(1)}, false}, + {"Ferroamp NaN", releaseFerroamp, map[string]any{"pplim_release_w": math.NaN()}, false}, + {"Sungrow explicit disable", releaseSungrow, nil, true}, + {"Sungrow feedin missing ceiling", releaseSungrow, map[string]any{"pv_curtail_method": "feed_in"}, false}, + {"Sungrow feedin ceiling", releaseSungrow, map[string]any{"pv_curtail_method": "feed_in", "feed_in_release_w": 11000}, true}, + {"Sungrow register overflow", releaseSungrow, map[string]any{"pv_curtail_method": "feed_in", "feed_in_release_w": 100000}, false}, + {"SolarEdge explicit enablebit release", releaseSolarEdge, nil, true}, + {"unknown revision", "unknown", map[string]any{"pplim_release_w": 15000}, false}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := forecastReviewedRelease(tc.digest, tc.settings); got != tc.want { + t.Fatalf("release evidence=%v want=%v", got, tc.want) + } + }) + } +} + +func TestForecastReleaseEvidenceFreezesConfigurationAndRejectsCustomReplacement(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "ferroamp.lua") + cfg := &config.Config{Drivers: []config.Driver{{Name: "pv", Lua: path, SupportsPVCurtail: true, Config: map[string]any{"pplim_release_w": 15000}}}} + catalog := []drivers.CatalogEntry{{Path: "drivers/ferroamp.lua", Filename: "ferroamp.lua", Capabilities: []string{"pv"}, ArtifactSHA256: releaseFerroamp}} + reads := 0 + digest := func(got string) (string, error) { + reads++ + if got != path { + t.Fatalf("hashed %q instead of resolved host path", got) + } + return releaseFerroamp, nil + } + evidence := forecastReleaseEvidenceWithDigest(cfg, catalog, digest) + cfg.Drivers[0].Config["pplim_release_w"] = 0 + if !evidence("pv") || evidence("other") || reads != 1 { + t.Fatal("lookup changed or performed extra source reads") + } + if forecastReleaseEvidenceWithDigest(cfg, catalog, digest)("pv") { + t.Fatal("new config retained obsolete release ceiling") + } + cfg.Drivers[0].Config["pplim_release_w"] = 15000 + if err := os.WriteFile(path, []byte("-- custom driver with the same name\nfunction driver_command() return true end"), 0600); err != nil { + t.Fatal(err) + } + if forecastReleaseEvidence(cfg, catalog)("pv") { + t.Fatal("catalog artifact hash or name vouched for changed Lua bytes") + } + if forecastReleaseEvidenceWithDigest(cfg, nil, digest)("pv") { + t.Fatal("unknown catalog qualified") + } + for _, tc := range []struct { + name string + mutate func(*config.Driver) + }{ + {"disabled", func(d *config.Driver) { d.Disabled = true }}, + {"observe only", func(d *config.Driver) { d.ObserveOnly = true }}, + {"telemetry only", func(d *config.Driver) { d.BatteryTelemetryOnly = true }}, + } { + t.Run(tc.name, func(t *testing.T) { + copy := *cfg + copy.Drivers = append([]config.Driver(nil), cfg.Drivers...) + tc.mutate(©.Drivers[0]) + if forecastReleaseEvidenceWithDigest(©, catalog, digest)("pv") { + t.Fatal("inactive controller qualified") + } + }) + } + if forecastReleaseEvidenceWithDigest(cfg, catalog, func(string) (string, error) { return "", fmt.Errorf("missing") })("pv") { + t.Fatal("unreadable source qualified") + } +} + +func TestForecastReleaseScriptDigestUsesExactResolvedBytes(t *testing.T) { + p := filepath.Join(t.TempDir(), "driver.lua") + data := []byte("return true\n") + if err := os.WriteFile(p, data, 0600); err != nil { + t.Fatal(err) + } + got, err := forecastReleaseScriptDigest(p) + want := sha256.Sum256(data) + if err != nil || got != hex.EncodeToString(want[:]) { + t.Fatalf("digest=%s err=%v", got, err) + } + for _, invalid := range []string{"driver.lua", filepath.Dir(p), p + ".missing"} { + if _, err := forecastReleaseScriptDigest(invalid); err == nil { + t.Fatalf("invalid path accepted: %s", invalid) + } + } + if err := os.WriteFile(p, make([]byte, (1<<20)+1), 0600); err != nil { + t.Fatal(err) + } + if _, err := forecastReleaseScriptDigest(p); err == nil { + t.Fatal("unbounded driver source accepted") + } +} diff --git a/go/cmd/ftw/forecast_rust.go b/go/cmd/ftw/forecast_rust.go new file mode 100644 index 00000000..abd4f97e --- /dev/null +++ b/go/cmd/ftw/forecast_rust.go @@ -0,0 +1,346 @@ +package main + +import ( + "context" + "crypto/sha256" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "sync" + "time" + + "github.com/google/uuid" + "github.com/srcfl/ftw/go/internal/energyforecast" + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/mpc" + "github.com/srcfl/ftw/go/internal/state" +) + +const forecastRustStateKey = "forecast/energyplan_state_v1" + +type savedForecastState struct { + SiteID string `json:"site_id"` + ConfigRevision string `json:"config_revision"` + ModelRevision uint64 `json:"model_revision"` + LatestAvailableMS int64 `json:"latest_available_ms"` + State json.RawMessage `json:"state"` +} + +type rustForecast struct { + version string + client *energyforecast.Client + transport interface{ Close() error } + store *state.Store + mu sync.RWMutex + saved savedForecastState +} + +func newRustForecast(st *state.Store, binary string) (*rustForecast, error) { + transport, err := mpc.NewProcessTransport(mpc.ProcessTransportConfig{Command: []string{binary}, ModuleDir: filepath.Dir(binary), IdleTimeout: 2 * time.Minute}) + if err != nil { + return nil, err + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + line, err := transport.RoundTrip(ctx, []byte(`{"type":"handshake","protocol_version":1}`)) + var info struct { + Name string `json:"name"` + Version string `json:"version"` + ForecastVersion int `json:"forecast_protocol_version"` + } + if err == nil { + err = json.Unmarshal(line, &info) + } + if err != nil || info.Name != "ftw-solver" || info.ForecastVersion != 1 { + _ = transport.Close() + return nil, fmt.Errorf("Energyplan forecast v1 unavailable: name=%q version=%d: %v", info.Name, info.ForecastVersion, err) + } + r := &rustForecast{version: forecastBinaryIdentity(binary), client: energyforecast.NewClient(transport), transport: transport, store: st} + if data, ok := st.LoadConfig(forecastRustStateKey); ok { + if len(data) <= energyforecast.MaxStateBytes+4096 { + var saved savedForecastState + if json.Unmarshal([]byte(data), &saved) == nil && json.Valid(saved.State) { + r.saved = saved + } + } + } + return r, nil +} +func (r *rustForecast) Close() error { return r.transport.Close() } +func (r *rustForecast) Snapshot() json.RawMessage { + r.mu.RLock() + defer r.mu.RUnlock() + data, _ := json.Marshal(r.saved) + return data +} + +func rustForecastConfig(site forecastSite) energyforecast.Config { + cfg := energyforecast.Config{Load: &energyforecast.LoadConfig{}} + if site.HasLocation { + cfg.PV = &energyforecast.PVConfig{LatitudeDeg: site.Latitude, LongitudeDeg: site.Longitude} + } + return cfg +} +func rustFeatures(t time.Time, site forecastSite, home bool, row *state.ForecastPoint) energyforecast.Features { + loc, err := time.LoadLocation(site.Timezone) + if err != nil { + loc = time.UTC + } + local := t.In(loc) + day := time.Date(local.Year(), local.Month(), local.Day(), 0, 0, 0, 0, time.UTC).Unix() / 86400 + f := energyforecast.Features{LocalDay: day, LocalWeekday: (int(local.Weekday()) + 6) % 7, + LocalMinute: local.Hour()*60 + local.Minute(), Home: &home} + if row != nil { + f.GHIWm2 = row.SolarWm2 + f.CloudPct = row.CloudCoverPct + f.TempC = row.TempC + if f.GHIWm2 != nil || f.CloudPct != nil || f.TempC != nil { + available := row.FetchedAtMs + f.WeatherAvailableAtMs = &available + } + } + return f +} + +func (r *rustForecast) Update(ctx context.Context, site forecastSite, o forecasting.Observation, weather *state.ForecastPoint, away bool) error { + r.mu.RLock() + saved := r.saved + r.mu.RUnlock() + if saved.SiteID != site.SiteID || saved.ConfigRevision != rustConfigRevision(site) { + saved = savedForecastState{SiteID: site.SiteID, ConfigRevision: rustConfigRevision(site)} + } + origin := o.AvailableAtMS + if weather != nil && weather.FetchedAtMs > origin { + return errors.New("observation weather arrived after update origin") + } + input := energyforecast.Observation{Interval: energyforecast.Interval{ValidStartMs: o.StartMS, ValidEndMs: o.EndMS}, + Features: rustFeatures(time.UnixMilli(o.StartMS), site, !away, weather), AvailableAtMs: o.AvailableAtMS, + LoadQuality: energyforecast.QualityMissing, PVQuality: energyforecast.QualityMissing} + if o.LoadKnown { + input.HouseholdLoadW = &o.LoadW + input.LoadQuality = energyforecast.QualityGood + } + if o.PVKnown { + input.PVAvailableW = &o.PVW + input.PVQuality = energyforecast.QualityGood + } + reply, err := r.client.Update(ctx, energyforecast.UpdateRequest{RequestContext: energyforecast.RequestContext{ + RequestID: uuid.NewString(), SiteID: site.SiteID, ConfigRevision: rustConfigRevision(site), OriginMs: origin, + Config: rustForecastConfig(site), State: saved.State}, Observations: []energyforecast.Observation{input}}) + if err != nil { + return err + } + next := savedForecastState{SiteID: site.SiteID, ConfigRevision: rustConfigRevision(site), ModelRevision: reply.ModelRevision, + LatestAvailableMS: origin, State: reply.State} + data, err := json.Marshal(next) + if err != nil { + return err + } + // Persist the complete response atomically before exposing it to planning. + if err = r.store.SaveConfig(forecastRustStateKey, string(data)); err != nil { + return err + } + r.mu.Lock() + r.saved = next + r.mu.Unlock() + return nil +} + +func (r *rustForecast) Predict(ctx context.Context, site forecastSite, issued forecasting.Issue, raw json.RawMessage, away map[int64]bool) (forecasting.Issue, error) { + if err := forecasting.ValidateOccupancy(issued.Occupancy, issued.OriginMS); err != nil { + return forecasting.Issue{}, err + } + occupancy := append([]forecasting.Occupancy(nil), issued.Occupancy...) + homeByQuarter := make(map[int64]bool, len(occupancy)) + for _, row := range occupancy { + homeByQuarter[row.StartMS] = row.Home + } + var saved savedForecastState + if len(raw) > 0 { + if err := json.Unmarshal(raw, &saved); err != nil { + return forecasting.Issue{}, err + } + } + if saved.SiteID != site.SiteID || saved.ConfigRevision != rustConfigRevision(site) { + saved = savedForecastState{SiteID: site.SiteID, ConfigRevision: rustConfigRevision(site)} + } + if saved.LatestAvailableMS > issued.OriginMS { + return forecasting.Issue{}, errors.New("candidate state newer than forecast origin") + } + if len(issued.Series) == 0 { + return forecasting.Issue{}, errors.New("no champion intervals") + } + base := issued.Series[0].Points + horizon := make([]energyforecast.HorizonSlot, 0) + for _, p := range base { + for at := p.StartMS; at < p.EndMS; at += 900000 { + if at < issued.OriginMS || at%900000 != 0 || at+900000 > p.EndMS { + continue + } + home, knownHome := homeByQuarter[at] + if len(issued.Occupancy) > 0 && !knownHome { + return forecasting.Issue{}, errors.New("archived occupancy does not cover candidate quarter") + } + if len(issued.Occupancy) == 0 { + home = !away[at] + occupancy = append(occupancy, forecasting.Occupancy{StartMS: at, EndMS: at + 900000, AvailableAtMS: issued.OriginMS, Home: home}) + } + var weather *state.ForecastPoint + for _, w := range issued.Weather { + if at >= w.StartMS && at < w.EndMS { + weather = &state.ForecastPoint{SlotTsMs: w.StartMS, SlotLenMin: int((w.EndMS - w.StartMS) / 60000), + FetchedAtMs: w.AvailableAtMS, Source: w.Source, SolarWm2: w.GHIWm2, TempC: w.TempC, CloudCoverPct: w.CloudPct} + break + } + } + horizon = append(horizon, energyforecast.HorizonSlot{Interval: energyforecast.Interval{ValidStartMs: at, ValidEndMs: at + 900000}, + Features: rustFeatures(time.UnixMilli(at), site, home, weather)}) + } + } + if len(horizon) == 0 { + return forecasting.Issue{}, errors.New("no future full quarter for candidate") + } + reply, err := r.client.Predict(ctx, energyforecast.PredictRequest{RequestContext: energyforecast.RequestContext{ + RequestID: uuid.NewString(), SiteID: site.SiteID, ConfigRevision: rustConfigRevision(site), OriginMs: issued.OriginMS, + Config: rustForecastConfig(site), State: saved.State}, Horizon: horizon}) + if err != nil { + return forecasting.Issue{}, err + } + now := time.Now().UnixMilli() + out := forecasting.Issue{Schema: forecasting.Schema, ID: uuid.NewString(), DecisionID: issued.DecisionID, + OriginMS: issued.OriginMS, IssuedAtMS: now, ConfigVersion: issued.ConfigVersion, Site: forecastSiteContext(site), Weather: issued.Weather, + LatestInputMS: max(saved.LatestAvailableMS, issued.LatestInputMS), Occupancy: occupancy} + for _, row := range out.Occupancy { + out.LatestInputMS = max(out.LatestInputMS, row.AvailableAtMS) + } + for _, row := range out.Weather { + out.LatestInputMS = max(out.LatestInputMS, row.AvailableAtMS) + } + modelState := saved.State + if len(modelState) == 0 { + modelState = json.RawMessage("null") + } + quality := forecasting.ModelQualityColdStart + if saved.LatestAvailableMS > 0 { + quality = forecasting.ModelQualityWarm + } + version := "energyplan/v1/" + r.version + if r.version == "" { + version = "energyplan/v1/test" + } + out.Models = []forecasting.ModelState{{Name: "energyplan", Version: version, UpdatedAtMS: saved.LatestAvailableMS, Quality: quality, State: modelState}} + metadata, _ := json.Marshal(struct { + ModelRevision uint64 `json:"model_revision"` + LatestInput energyforecast.LatestInput `json:"latest_input_ms"` + LatestTraining energyforecast.LatestInput `json:"latest_training_ms"` + LatestAvailable energyforecast.LatestInput `json:"latest_available_at_ms"` + }{reply.ModelRevision, reply.LatestInputMs, reply.LatestTrainingMs, reply.LatestAvailableAtMs}) + out.Models = append(out.Models, forecasting.ModelState{Name: "energyplan_metadata", Version: version, + UpdatedAtMS: saved.LatestAvailableMS, Quality: quality, State: metadata}) + series := forecasting.Series{Name: "energyplan", ModelVersion: version} + // Preserve the planner's interval duration. Rust v1 only predicts quarters; + // four quarters form an hourly energy mean, never an hourly maximum. + for _, p := range base { + if p.StartMS < issued.OriginMS { + continue + } + got := forecasting.Point{StartMS: p.StartMS, EndMS: p.EndMS, PVKnown: site.HasLocation, LoadKnown: true, PVQuality: "ready", LoadQuality: "ready"} + cursor := p.StartMS + parts, pvEvidence, loadEvidence := 0, 0, 0 + for _, v := range reply.Predictions { + if v.ValidStartMs < cursor { + continue + } + if v.ValidStartMs != cursor || v.ValidEndMs > p.EndMS { + break + } + fraction := float64(v.ValidEndMs-v.ValidStartMs) / float64(p.EndMS-p.StartMS) + parts++ + if addModelEvidence(&got.ModelPV, v.PV, fraction) { + pvEvidence++ + } + if addModelEvidence(&got.ModelLoad, v.Load, fraction) { + loadEvidence++ + } + if v.PV == nil || !v.PV.Known || v.PV.PointW == nil { + got.PVKnown = false + got.PVQuality = "unknown" + } else { + got.PVW += *v.PV.PointW * fraction + got.PVQuality = leastForecastQuality(got.PVQuality, v.PV.Quality) + } + if v.Load == nil || !v.Load.Known || v.Load.PointW == nil { + got.LoadKnown = false + got.LoadQuality = "unknown" + } else { + got.LoadW += *v.Load.PointW * fraction + got.LoadQuality = leastForecastQuality(got.LoadQuality, v.Load.Quality) + } + cursor = v.ValidEndMs + if cursor == p.EndMS { + break + } + } + if pvEvidence != parts || !got.PVKnown { + got.ModelPV = nil + } + if loadEvidence != parts || !got.LoadKnown { + got.ModelLoad = nil + } + if cursor == p.EndMS { + series.Points = append(series.Points, got) + } + } + if len(series.Points) == 0 { + return forecasting.Issue{}, errors.New("candidate did not cover a complete planner interval") + } + out.Series = []forecasting.Series{series} + return out, nil +} + +func leastForecastQuality(a, b string) string { + order := map[string]int{"unknown": 0, "cold_start": 1, "learning": 2, "ready": 3} + if order[b] < order[a] { + return b + } + return a +} + +// The actual worker bytes, not its revision counter, identify the model code. +func forecastBinaryIdentity(binary string) string { + f, err := os.Open(binary) + if err != nil { + return "unavailable" + } + defer f.Close() + h := sha256.New() + if _, err := io.Copy(h, f); err != nil { + return "unavailable" + } + return fmt.Sprintf("%x", h.Sum(nil)) +} + +func rustConfigRevision(site forecastSite) string { + if site.LearningRevision != "" { + return site.LearningRevision + } + return site.Revision +} + +// Aggregated bounds retain the worker's provisional label. Averaging four +// such bounds does not turn them into a calibrated hourly quantile. +func addModelEvidence(dst **forecasting.ModelEstimateEvidence, v *energyforecast.Estimate, fraction float64) bool { + if v == nil || !v.Known || v.Uncertainty != "provisional" || v.LowerW == nil || v.UpperW == nil { + return false + } + if *dst == nil { + *dst = &forecasting.ModelEstimateEvidence{Uncertainty: "provisional", Coverage: v.Coverage} + } + (*dst).LowerW += *v.LowerW * fraction + (*dst).UpperW += *v.UpperW * fraction + (*dst).Coverage = min((*dst).Coverage, v.Coverage) + return true +} diff --git a/go/cmd/ftw/forecast_rust_test.go b/go/cmd/ftw/forecast_rust_test.go new file mode 100644 index 00000000..b12b1c44 --- /dev/null +++ b/go/cmd/ftw/forecast_rust_test.go @@ -0,0 +1,404 @@ +package main + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "reflect" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/energyforecast" + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/state" +) + +type hostForecastExchange func(context.Context, []byte) ([]byte, error) + +func (f hostForecastExchange) RoundTrip(ctx context.Context, p []byte) ([]byte, error) { + return f(ctx, p) +} +func hostForecastPtr[T any](v T) *T { return &v } +func hostForecastSite() forecastSite { + return forecastSite{SiteID: "host-test", Revision: "cfg-1", Latitude: 57, Longitude: 15, HasLocation: true, Timezone: "Europe/Stockholm"} +} +func hostForecastIssue(start time.Time, origin time.Time, hours int) forecasting.Issue { + issue := forecasting.Issue{Schema: forecasting.Schema, ID: "champion-test", DecisionID: "decision-test", OriginMS: origin.UnixMilli(), IssuedAtMS: origin.UnixMilli(), ConfigVersion: "cfg-1"} + series := forecasting.Series{Name: "champion", ModelVersion: "test"} + for i := 0; i < hours; i++ { + at := start.Add(time.Duration(i) * time.Hour).UnixMilli() + series.Points = append(series.Points, forecasting.Point{StartMS: at, EndMS: at + 3600000, PVKnown: true, LoadKnown: true, PVQuality: "cold_start", LoadQuality: "cold_start"}) + issue.Weather = append(issue.Weather, forecasting.Weather{StartMS: at, EndMS: at + 3600000, AvailableAtMS: origin.Add(-time.Hour).UnixMilli(), Source: "test", GHIWm2: hostForecastPtr(500.0)}) + } + issue.Series = []forecasting.Series{series} + applyForecastBands(&issue, nil) + return issue +} +func hostForecastReply(payload []byte) (map[string]any, map[string]any) { + var req map[string]any + _ = json.Unmarshal(payload, &req) + reply := map[string]any{"ok": true, "model_revision": 1, "latest_input_ms": map[string]any{"pv": nil, "load": nil}, "latest_training_ms": map[string]any{"pv": nil, "load": nil}, "latest_available_at_ms": map[string]any{"pv": nil, "load": nil}} + for _, key := range []string{"op", "version", "action", "request_id", "site_id", "config_revision", "origin_ms"} { + reply[key] = req[key] + } + if req["action"] == "update" { + reply["state"] = map[string]any{"observed_at": req["origin_ms"]} + reply["updates"] = map[string]any{"pv": map[string]any{"applied": 1, "skipped": 0}, "load": map[string]any{"applied": 1, "skipped": 0}} + return req, reply + } + var predictions []any + for _, raw := range req["horizon"].([]any) { + slot := raw.(map[string]any) + quarter := (int64(slot["valid_start_ms"].(float64)) % 3600000) / 900000 + pv := float64((quarter + 1) * 100) + quality := "ready" + if quarter == 2 { + quality = "learning" + } + predictions = append(predictions, map[string]any{"valid_start_ms": slot["valid_start_ms"], "valid_end_ms": slot["valid_end_ms"], "pv": map[string]any{"known": true, "point_w": pv, "lower_w": pv - 50, "upper_w": pv + 50, "quality": quality, "uncertainty": "provisional", "coverage": 0.5}, "load": map[string]any{"known": true, "point_w": pv + 1000, "lower_w": pv + 900, "upper_w": pv + 1100, "quality": "cold_start", "uncertainty": "provisional", "coverage": 0}}) + } + reply["predictions"] = predictions + return req, reply +} +func hostForecastDB(t *testing.T) *state.Store { + t.Helper() + st, err := state.Open(filepath.Join(t.TempDir(), "forecast.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { st.Close() }) + if err = st.InitForecastArchive(context.Background()); err != nil { + t.Fatal(err) + } + return st +} + +func TestRustForecastHostQuarterEnergyAndPartialHour(t *testing.T) { + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + issue := hostForecastIssue(start, start.Add(7*time.Minute), 2) + var captured energyforecast.PredictRequest + r := &rustForecast{client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + if err := json.Unmarshal(p, &captured); err != nil { + t.Fatal(err) + } + _, reply := hostForecastReply(p) + return json.Marshal(reply) + }))} + away := map[int64]bool{start.Add(75 * time.Minute).UnixMilli(): true} + got, err := r.Predict(context.Background(), hostForecastSite(), issue, nil, away) + if err != nil { + t.Fatal(err) + } + if len(captured.Horizon) != 7 { + t.Fatalf("future full quarters=%d want7", len(captured.Horizon)) + } + for _, slot := range captured.Horizon { + if slot.ValidStartMs < issue.OriginMS || slot.ValidStartMs%900000 != 0 || slot.ValidEndMs-slot.ValidStartMs != 900000 { + t.Fatalf("invalid candidate quarter: %+v", slot) + } + if slot.Home == nil || *slot.Home == away[slot.ValidStartMs] { + t.Fatal("occupancy did not follow quarter") + } + if slot.WeatherAvailableAtMs == nil || *slot.WeatherAvailableAtMs > issue.OriginMS { + t.Fatal("weather availability lost") + } + } + points := got.Series[0].Points + if len(points) != 1 || points[0].StartMS != start.Add(time.Hour).UnixMilli() { + t.Fatalf("partial current hour was published: %+v", points) + } + p := points[0] + if p.PVW != 250 || p.LoadW != 1250 { + t.Fatalf("quarter power not energy mean: PV=%v load=%v", p.PVW, p.LoadW) + } + if !p.PVKnown || !p.LoadKnown || p.PVQuality != "learning" || p.LoadQuality != "cold_start" { + t.Fatalf("known cold-start or weakest quality lost: %+v", p) + } + if p.ModelPV == nil || p.ModelLoad == nil || p.ModelPV.LowerW != 200 || p.ModelPV.UpperW != 300 || p.ModelPV.Uncertainty != "provisional" || p.ModelLoad.Coverage != 0 { + t.Fatalf("provisional model evidence lost: %+v %+v", p.ModelPV, p.ModelLoad) + } + applyForecastBands(&got, nil) + if got.Series[0].Points[0].PVBand.Method != forecasting.BandMethodColdStart || got.Series[0].Points[0].PVBand.Samples != 0 { + t.Fatal("model bounds claimed empirical calibration") + } + if err = got.Validate(); err != nil { + t.Fatal(err) + } +} + +func TestRustForecastHostDSTQuarterFeatures(t *testing.T) { + for _, tc := range []struct { + name string + start time.Time + minutes []int + }{{"spring", time.Date(2026, 3, 29, 0, 0, 0, 0, time.UTC), []int{60, 75, 90, 105, 180, 195, 210, 225}}, {"autumn", time.Date(2025, 10, 26, 0, 0, 0, 0, time.UTC), []int{120, 135, 150, 165, 120, 135, 150, 165}}} { + t.Run(tc.name, func(t *testing.T) { + var captured energyforecast.PredictRequest + r := &rustForecast{client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + json.Unmarshal(p, &captured) + _, reply := hostForecastReply(p) + return json.Marshal(reply) + }))} + _, err := r.Predict(context.Background(), hostForecastSite(), hostForecastIssue(tc.start, tc.start, 2), nil, nil) + if err != nil { + t.Fatal(err) + } + if len(captured.Horizon) != len(tc.minutes) { + t.Fatal("DST changed UTC quarter count") + } + for i, s := range captured.Horizon { + if s.LocalMinute != tc.minutes[i] || s.LocalWeekday != 6 || s.LocalDay != tc.start.Unix()/86400 || s.ValidStartMs != tc.start.Add(time.Duration(i)*15*time.Minute).UnixMilli() { + t.Fatalf("DST quarter%d: %+v", i, s) + } + } + }) + } +} + +func TestRustForecastHostFrozenStateAndConfigBoundary(t *testing.T) { + st := hostForecastDB(t) + site := hostForecastSite() + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + var requests []energyforecast.PredictRequest + r := &rustForecast{store: st, client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + req, reply := hostForecastReply(p) + if req["action"] == "predict" { + var captured energyforecast.PredictRequest + json.Unmarshal(p, &captured) + requests = append(requests, captured) + } + return json.Marshal(reply) + }))} + observe := func(at time.Time) { + t.Helper() + if err := r.Update(context.Background(), site, forecasting.Observation{StartMS: at.Add(-15 * time.Minute).UnixMilli(), EndMS: at.UnixMilli(), AvailableAtMS: at.UnixMilli(), PVKnown: true, PVW: 2000, LoadKnown: true, LoadW: 1000}, nil, false); err != nil { + t.Fatal(err) + } + } + observe(start) + frozen := r.Snapshot() + observe(start.Add(time.Hour)) + issue := hostForecastIssue(start, start, 1) + if _, err := r.Predict(context.Background(), site, issue, frozen, nil); err != nil { + t.Fatal(err) + } + if len(requests) != 1 { + t.Fatalf("prediction requests=%d want1", len(requests)) + } + var frozenState map[string]int64 + if err := json.Unmarshal(requests[0].State, &frozenState); err != nil { + t.Fatal(err) + } + if frozenState["observed_at"] != start.UnixMilli() { + t.Fatalf("new input leaked into frozen request: %s", requests[0].State) + } + if _, err := r.Predict(context.Background(), site, issue, r.Snapshot(), nil); err == nil { + t.Fatal("future state accepted") + } + if len(requests) != 1 { + t.Fatal("future state reached worker") + } + site.Revision = "cfg-2" + issue.ConfigVersion = site.Revision + if _, err := r.Predict(context.Background(), site, issue, frozen, nil); err != nil { + t.Fatal(err) + } + if len(requests) != 2 || len(requests[1].State) != 0 || requests[1].ConfigRevision != "cfg-2" { + t.Fatal("old config state crossed model boundary") + } +} + +func TestRustForecastHostNativePersistenceAndArchive(t *testing.T) { + binary := os.Getenv("FTW_FORECAST_WORKER") + if binary == "" { + t.Skip("set FTW_FORECAST_WORKER for native host integration") + } + st := hostForecastDB(t) + site := hostForecastSite() + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + r, err := newRustForecast(st, binary) + if err != nil { + t.Fatal(err) + } + defer r.Close() + o := forecasting.Observation{StartMS: start.Add(-15 * time.Minute).UnixMilli(), EndMS: start.UnixMilli(), AvailableAtMS: start.UnixMilli(), LoadW: 1000, LoadKnown: true, PVW: 2000, PVKnown: true, Quality: "complete", ConfigVersion: site.Revision} + weather := &state.ForecastPoint{SlotTsMs: o.StartMS, SlotLenMin: 15, FetchedAtMs: start.Add(-time.Hour).UnixMilli(), Source: "test", SolarWm2: hostForecastPtr(500.0)} + if err = r.Update(context.Background(), site, o, weather, false); err != nil { + t.Fatal(err) + } + frozen := r.Snapshot() + issue := hostForecastIssue(start, start, 1) + first, err := r.Predict(context.Background(), site, issue, frozen, nil) + if err != nil { + t.Fatal(err) + } + restarted, err := newRustForecast(st, binary) + if err != nil { + t.Fatal(err) + } + defer restarted.Close() + if string(restarted.Snapshot()) != string(frozen) { + t.Fatal("constructor failed to reload saved model") + } + second, err := restarted.Predict(context.Background(), site, issue, restarted.Snapshot(), nil) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(first.Series, second.Series) || !reflect.DeepEqual(first.Models, second.Models) { + t.Fatal("native host replay changed forecast or frozen model") + } + applyForecastBands(&first, nil) + if err = first.Validate(); err != nil { + t.Fatal(err) + } + if err = st.SaveForecastIssue(context.Background(), first); err != nil { + t.Fatal(err) + } + archived, err := st.LoadForecastIssues(context.Background(), 0, time.Now().Add(time.Hour).UnixMilli(), 10) + if err != nil || len(archived) != 1 { + t.Fatalf("native issue archive: count=%d err=%v", len(archived), err) + } + if !reflect.DeepEqual(archived[0].Series, first.Series) { + t.Fatal("archive changed model predictions or evidence") + } +} + +func TestRustForecastHostUnknownQuarterCannotBecomeKnownHour(t *testing.T) { + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + r := &rustForecast{client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + _, reply := hostForecastReply(p) + predictions := reply["predictions"].([]any) + predictions[1].(map[string]any)["pv"] = map[string]any{"known": false, "quality": "unknown", "uncertainty": "unavailable", "coverage": 0} + return json.Marshal(reply) + }))} + out, err := r.Predict(context.Background(), hostForecastSite(), hostForecastIssue(start, start, 1), nil, nil) + if err != nil { + t.Fatal(err) + } + p := out.Series[0].Points[0] + if p.PVKnown || p.PVQuality != "unknown" || p.ModelPV != nil { + t.Fatalf("missing quarter acquired numeric evidence: %+v", p) + } + if !p.LoadKnown || p.LoadQuality != "cold_start" { + t.Fatal("independent known cold load erased by unknown PV") + } +} + +func TestRustForecastHostUpdateZeroAvailabilityAndDeadline(t *testing.T) { + st := hostForecastDB(t) + site := hostForecastSite() + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + var captured energyforecast.UpdateRequest + calls := 0 + r := &rustForecast{store: st, client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + calls++ + if err := json.Unmarshal(p, &captured); err != nil { + t.Fatal(err) + } + _, reply := hostForecastReply(p) + return json.Marshal(reply) + }))} + observation := forecasting.Observation{StartMS: start.Add(-15 * time.Minute).UnixMilli(), EndMS: start.UnixMilli(), AvailableAtMS: start.UnixMilli(), PVKnown: true, PVW: 0, LoadKnown: false} + if err := r.Update(context.Background(), site, observation, nil, true); err != nil { + t.Fatal(err) + } + sample := captured.Observations[0] + if sample.PVAvailableW == nil || *sample.PVAvailableW != 0 || sample.PVQuality != energyforecast.QualityGood || sample.HouseholdLoadW != nil || sample.LoadQuality != energyforecast.QualityMissing || sample.Home == nil || *sample.Home { + t.Fatalf("zero/missing/away labels changed: %+v", sample) + } + frozen := string(r.Snapshot()) + futureWeather := &state.ForecastPoint{FetchedAtMs: start.Add(time.Second).UnixMilli(), SolarWm2: hostForecastPtr(500.0)} + if err := r.Update(context.Background(), site, observation, futureWeather, false); err == nil { + t.Fatal("future weather accepted") + } + if calls != 1 || string(r.Snapshot()) != frozen { + t.Fatal("invalid update changed state or reached worker") + } + r.client = energyforecast.NewClient(hostForecastExchange(func(ctx context.Context, _ []byte) ([]byte, error) { <-ctx.Done(); return nil, ctx.Err() })) + ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond) + defer cancel() + if err := r.Update(ctx, site, observation, nil, false); err == nil { + t.Fatal("deadline ignored") + } + if string(r.Snapshot()) != frozen { + t.Fatal("timed-out update replaced frozen state") + } +} + +func TestRustForecastHostPreservesIndependentInputClocks(t *testing.T) { + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + origin := start.UnixMilli() + site := hostForecastSite() + wantInput := energyforecast.LatestInput{PV: hostForecastPtr(origin - 1800000), Load: hostForecastPtr(origin - 900000)} + wantTraining := energyforecast.LatestInput{PV: hostForecastPtr(origin - 2700000), Load: hostForecastPtr(origin - 900000)} + wantAvailable := energyforecast.LatestInput{PV: hostForecastPtr(origin - 1500000), Load: hostForecastPtr(origin - 840000)} + r := &rustForecast{client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + _, reply := hostForecastReply(p) + reply["model_revision"] = 17 + reply["latest_input_ms"] = wantInput + reply["latest_training_ms"] = wantTraining + reply["latest_available_at_ms"] = wantAvailable + return json.Marshal(reply) + }))} + raw, err := json.Marshal(savedForecastState{SiteID: site.SiteID, ConfigRevision: site.Revision, LatestAvailableMS: *wantAvailable.Load, State: json.RawMessage(`{"opaque":true}`)}) + if err != nil { + t.Fatal(err) + } + out, err := r.Predict(context.Background(), site, hostForecastIssue(start, start, 1), raw, nil) + if err != nil { + t.Fatal(err) + } + var evidence struct { + Revision uint64 `json:"model_revision"` + Input energyforecast.LatestInput `json:"latest_input_ms"` + Training energyforecast.LatestInput `json:"latest_training_ms"` + Available energyforecast.LatestInput `json:"latest_available_at_ms"` + } + found := false + for _, m := range out.Models { + if m.Name == "energyplan_metadata" { + found = true + if err = json.Unmarshal(m.State, &evidence); err != nil { + t.Fatal(err) + } + } + } + if !found || evidence.Revision != 17 || !reflect.DeepEqual(evidence.Input, wantInput) || !reflect.DeepEqual(evidence.Training, wantTraining) || !reflect.DeepEqual(evidence.Available, wantAvailable) { + t.Fatalf("PV/load consumed, learned and availability clocks conflated: %+v", evidence) + } + applyForecastBands(&out, nil) + if err = out.Validate(); err != nil { + t.Fatal(err) + } +} + +func TestRustForecastHostEvaluationConfigKeepsLearningState(t *testing.T) { + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + site := hostForecastSite() + site.LearningRevision = "electrical-1" + var states []json.RawMessage + r := &rustForecast{client: energyforecast.NewClient(hostForecastExchange(func(_ context.Context, p []byte) ([]byte, error) { + var req energyforecast.PredictRequest + if err := json.Unmarshal(p, &req); err != nil { + t.Fatal(err) + } + states = append(states, req.State) + _, reply := hostForecastReply(p) + return json.Marshal(reply) + }))} + raw, _ := json.Marshal(savedForecastState{SiteID: site.SiteID, ConfigRevision: site.LearningRevision, LatestAvailableMS: start.Add(-time.Hour).UnixMilli(), State: json.RawMessage(`{"opaque":"learned"}`)}) + issue := hostForecastIssue(start, start, 1) + site.Revision = "evaluation-provider-2" + issue.ConfigVersion = site.Revision + if _, err := r.Predict(context.Background(), site, issue, raw, nil); err != nil { + t.Fatal(err) + } + site.LearningRevision = "electrical-2" + if _, err := r.Predict(context.Background(), site, issue, raw, nil); err != nil { + t.Fatal(err) + } + if len(states) != 2 || len(states[0]) == 0 || len(states[1]) != 0 { + t.Fatalf("evaluation and learning revision boundaries confused: %q", states) + } +} diff --git a/go/cmd/ftw/forecast_site.go b/go/cmd/ftw/forecast_site.go new file mode 100644 index 00000000..2a21f276 --- /dev/null +++ b/go/cmd/ftw/forecast_site.go @@ -0,0 +1,303 @@ +package main + +import ( + "crypto/sha256" + "encoding/json" + "fmt" + "log/slog" + "math" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "time" + + "github.com/google/uuid" + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/drivers" + "github.com/srcfl/ftw/go/internal/state" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +// forecastSiteConfig owns the small, immutable subset needed by asynchronous +// forecast work. It never holds cfgMu or ctrlMu while a model runs. +type forecastSiteConfig struct { + mu sync.RWMutex + value forecastSite + store *state.Store + engineVersion string + weatherRevision string + weatherSinceMS int64 + identity func(string) (string, bool) + baseRevision string + baseOptions telemetry.ForecastOptions + required map[string]bool // value identifies PV sources + accepted forecastIdentityReceipt + configuredAt time.Time + heatingPrior, ratedPV float64 +} + +type forecastIdentityReceipt struct { + BaseRevision string `json:"base_revision"` + IDs map[string]string `json:"ids"` +} + +const forecastIdentityReceiptKey = "forecast/live_identity_v1" + +func newForecastSiteConfig(st *state.Store) *forecastSiteConfig { + id, _ := st.LoadConfig("forecast/site_id") + if id == "" { + id = uuid.NewString() + if err := st.SaveConfig("forecast/site_id", id); err != nil { + slog.Warn("forecast site identity not saved", "err", err) + } + } + revision, _ := st.LoadConfig("forecast/config_revision") + var receipt struct { + Revision string + SinceMS int64 + } + if raw, ok := st.LoadConfig("forecast/weather_generation"); ok { + _ = json.Unmarshal([]byte(raw), &receipt) + } + var accepted forecastIdentityReceipt + if raw, ok := st.LoadConfig(forecastIdentityReceiptKey); ok { + _ = json.Unmarshal([]byte(raw), &accepted) + } + return &forecastSiteConfig{accepted: accepted, weatherRevision: receipt.Revision, weatherSinceMS: receipt.SinceMS, store: st, engineVersion: forecastBinaryIdentity(resolveEnergyplanBinary()), value: forecastSite{SiteID: id, Revision: revision}} +} + +func (s *forecastSiteConfig) Snapshot() forecastSite { + s.mu.RLock() + defer s.mu.RUnlock() + v := s.value + v.Options.ExpectedFlows = append([]telemetry.ForecastFlow(nil), v.Options.ExpectedFlows...) + return v +} + +func (s *forecastSiteConfig) Configure(cfg *config.Config, catalog []drivers.CatalogEntry) bool { + v := forecastSite{Meter: cfg.SiteMeterDriver(), Timezone: forecastTimezone(), Options: forecastMeasurementOptions(cfg, catalog)} + if cfg.Weather != nil && cfg.Weather.Provider != "" && cfg.Weather.Provider != "none" { + v.Latitude, v.Longitude = cfg.Weather.Latitude, cfg.Weather.Longitude + v.HasLocation = !math.IsNaN(v.Latitude) && !math.IsNaN(v.Longitude) && math.Abs(v.Latitude) <= 90 && math.Abs(v.Longitude) <= 180 + v.HasPVScale = forecastRatedPVW(cfg.Weather) > 0 + } + // The revision contains model inputs, never provider credentials or unrelated + // control settings. Sorting prevents driver order alone from losing learning. + sort.Slice(v.Options.ExpectedFlows, func(i, j int) bool { + a, b := v.Options.ExpectedFlows[i], v.Options.ExpectedFlows[j] + if a.Driver != b.Driver { + return a.Driver < b.Driver + } + return a.DerType < b.DerType + }) + var weather *config.Weather + if cfg.Weather != nil { + cp := *cfg.Weather + cp.APIKey = "" + weather = &cp + } + driverInputs := append([]config.Driver(nil), cfg.Drivers...) + sort.Slice(driverInputs, func(i, j int) bool { return driverInputs[i].Name < driverInputs[j].Name }) + scripts := make(map[string]string) + for _, d := range driverInputs { + if digest, err := forecastReleaseScriptDigest(d.Lua); err == nil { + scripts[d.Name] = digest + } else { + scripts[d.Name] = "unavailable" + } + } + // Only the digest leaves this function. Driver measurement settings and + // stable hardware bindings must invalidate learning when they change. + data, err := json.Marshal(struct { + Meter, Timezone string + Options telemetry.ForecastOptions + Weather *config.Weather + Drivers []config.Driver + Scripts map[string]string + }{v.Meter, v.Timezone, v.Options, weather, driverInputs, scripts}) + if err != nil { + slog.Warn("forecast configuration is not serializable", "err", err) + v.Options.HouseholdInvalidReason = "invalid_forecast_configuration" + v.HasLocation = false + data = []byte("invalid:" + uuid.NewString()) + } + baseRevision := fmt.Sprintf("site-static-v1:%x", sha256.Sum256(data)) + weatherData, _ := json.Marshal(weather) + weatherRevision := fmt.Sprintf("%x", sha256.Sum256(weatherData)) + s.mu.Lock() + if s.weatherRevision != weatherRevision || s.weatherSinceMS <= 0 { + s.weatherRevision = weatherRevision + s.weatherSinceMS = time.Now().UnixMilli() + receipt, _ := json.Marshal(struct { + Revision string + SinceMS int64 + }{weatherRevision, s.weatherSinceMS}) + if err := s.store.SaveConfig("forecast/weather_generation", string(receipt)); err != nil { + slog.Warn("forecast weather generation not saved", "err", err) + } + } + v.WeatherSinceMS = s.weatherSinceMS + v.SiteID = s.value.SiteID + previous := s.value.Revision + s.value = v + if s.baseRevision != baseRevision { + s.configuredAt = time.Now() + } + s.baseRevision = baseRevision + s.baseOptions = v.Options + s.required = make(map[string]bool) + if v.Meter != "" { + s.required[v.Meter] = false + } + for _, flow := range v.Options.ExpectedFlows { + s.required[flow.Driver] = s.required[flow.Driver] || flow.DerType == telemetry.DerPV + } + s.heatingPrior = 0 + if cfg.Weather != nil { + s.heatingPrior = cfg.Weather.HeatingWPerDegC + } + s.ratedPV = forecastRatedPVW(cfg.Weather) + s.mu.Unlock() + s.RefreshIdentity(time.Now()) + return previous != s.Snapshot().Revision +} + +// RefreshIdentity reads the running host, never the historical devices table. +// Serial/MAC identities are usable immediately. Endpoint fallback retains the +// existing device contract after a short init grace. A previously stronger +// identity must return before it can qualify again after restart. +// Caller serializes this with model rebinding under forecastConfigMu. +func (s *forecastSiteConfig) RefreshIdentity(now time.Time) bool { + s.mu.Lock() + defer s.mu.Unlock() + ids := make(map[string]string, len(s.required)) + pending, pvPending := false, false + for name, isPV := range s.required { + id, known := "", false + if s.identity != nil { + id, known = s.identity(name) + } + old := "" + if s.accepted.BaseRevision == s.baseRevision { + old = s.accepted.IDs[name] + } + ready := known && id != "" && forecastIdentityStrength(id) >= forecastIdentityStrength(old) + if forecastIdentityStrength(id) == 1 && now.Sub(s.configuredAt) < 3*time.Second { + ready = false + } + if !ready { + pending = true + pvPending = pvPending || isPV + } + if ready { + ids[name] = id + } else { + ids[name] = "unconfirmed" + } + } + data, _ := json.Marshal(ids) + learning := fmt.Sprintf("site-v2:%x", sha256.Sum256([]byte(s.baseRevision+"/"+string(data)))) + cohort := learning + "/" + Version + "/" + s.engineVersion + revision := fmt.Sprintf("forecast-v1:%x", sha256.Sum256([]byte(cohort))) + opts := s.baseOptions + if pending && opts.HouseholdInvalidReason == "" { + opts.HouseholdInvalidReason = "unconfirmed_device_identity" + } + if pvPending { + opts.PVInvalidReason = "unconfirmed_pv_identity" + } + changed := s.value.Revision != revision || s.value.IdentityPending != pending || s.value.Options.PVInvalidReason != opts.PVInvalidReason + s.value.LearningRevision, s.value.Revision, s.value.IdentityPending, s.value.Options = learning, revision, pending, opts + if !pending && (s.accepted.BaseRevision != s.baseRevision || !forecastIdentitiesEqual(s.accepted.IDs, ids)) { + s.accepted = forecastIdentityReceipt{s.baseRevision, ids} + if encoded, err := json.Marshal(s.accepted); err == nil { + if err = s.store.SaveConfig(forecastIdentityReceiptKey, string(encoded)); err != nil { + slog.Warn("forecast identity binding not saved", "err", err) + } + } + } + if changed { + if err := s.store.SaveConfig("forecast/config_revision", revision); err != nil { + slog.Warn("forecast revision not saved", "err", err) + } + } + return changed +} + +func forecastIdentityStrength(id string) int { + switch { + case id == "": + return 0 + case strings.HasPrefix(id, "ep:"): + return 1 + case strings.HasPrefix(id, "mac:"): + return 2 + default: + return 3 + } +} +func forecastIdentitiesEqual(a, b map[string]string) bool { + if len(a) != len(b) { + return false + } + for name, id := range a { + if b[name] != id { + return false + } + } + return true +} +func (s *forecastSiteConfig) ModelPriors() (heating, rated float64) { + s.mu.RLock() + defer s.mu.RUnlock() + return s.heatingPrior, s.ratedPV +} + +func forecastRatedPVW(w *config.Weather) float64 { + if w == nil { + return 0 + } + var total float64 + for _, a := range w.PVArrays { + x := a.RatedWatts() + if x > 0 && !math.IsInf(x, 0) && !math.IsNaN(x) { + total += x + } + } + if total > 0 { + return total + } + if w.PVRatedW > 0 && !math.IsInf(w.PVRatedW, 0) && !math.IsNaN(w.PVRatedW) { + return w.PVRatedW + } + return 0 +} + +// Prefer the host's IANA name so persisted clock buckets retain DST rules. +// UTC is valid when that is the box's configured timezone; never guess a country. +func forecastTimezone() string { + candidates := []string{strings.TrimPrefix(os.Getenv("TZ"), ":"), time.Local.String()} + if target, err := filepath.EvalSymlinks("/etc/localtime"); err == nil { + if _, zone, ok := strings.Cut(target, "/zoneinfo/"); ok { + candidates = append(candidates, zone) + } + } + if data, err := os.ReadFile("/etc/timezone"); err == nil { + candidates = append(candidates, strings.TrimSpace(string(data))) + } + for _, zone := range candidates { + if zone == "" || zone == "Local" { + continue + } + if _, err := time.LoadLocation(zone); err == nil { + return zone + } + } + return "UTC" +} + +func usableTrainingWeather(row state.ForecastPoint, now time.Time) bool { + return row.FetchedAtMs > 0 && row.FetchedAtMs <= now.UnixMilli() && now.UnixMilli()-row.FetchedAtMs <= (12*time.Hour).Milliseconds() +} diff --git a/go/cmd/ftw/forecast_site_test.go b/go/cmd/ftw/forecast_site_test.go new file mode 100644 index 00000000..e237820e --- /dev/null +++ b/go/cmd/ftw/forecast_site_test.go @@ -0,0 +1,239 @@ +package main + +import ( + "github.com/srcfl/ftw/go/internal/drivers" + "github.com/srcfl/ftw/go/internal/loadmodel" + "github.com/srcfl/ftw/go/internal/modelstate" + "github.com/srcfl/ftw/go/internal/telemetry" + "math" + "os" + "path/filepath" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/config" + "github.com/srcfl/ftw/go/internal/state" +) + +func TestForecastSiteSeparatesLearningAndEvaluationRevisions(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + script := filepath.Join(t.TempDir(), "meter.lua") + if err := os.WriteFile(script, []byte("first measurement code"), 0600); err != nil { + t.Fatal(err) + } + cfg := &config.Config{Drivers: []config.Driver{{Name: "meter", Lua: script, IsSiteMeter: true, Config: map[string]any{"scale": 1.0}}}, Weather: &config.Weather{Provider: "open_meteo", Latitude: 59, Longitude: 18}} + s := newForecastSiteConfig(st) + s.Configure(cfg, nil) + first := s.Snapshot() + if first.HasPVScale || forecastRatedPVW(cfg.Weather) != 0 { + t.Fatal("unknown PV capacity became a guessed rating") + } + s.engineVersion = "another-worker-build" + s.Configure(cfg, nil) + build := s.Snapshot() + if build.LearningRevision != first.LearningRevision || build.Revision == first.Revision { + t.Fatal("worker build must change evaluation cohort, not learned site binding") + } + cfg.Drivers[0].Config["scale"] = 2.0 + s.Configure(cfg, nil) + scaled := s.Snapshot() + if scaled.LearningRevision == build.LearningRevision { + t.Fatal("meter scaling retained old learned state") + } + if err := os.WriteFile(script, []byte("changed measurement code"), 0600); err != nil { + t.Fatal(err) + } + s.Configure(cfg, nil) + if s.Snapshot().LearningRevision == scaled.LearningRevision { + t.Fatal("changed measurement code retained old learned state") + } + copy := s.Snapshot() + copy.Options.ExpectedFlows[0].Driver = "mutated" + if s.Snapshot().Options.ExpectedFlows[0].Driver == "mutated" { + t.Fatal("site snapshot aliases expected flows") + } + cfg.Weather.Latitude = math.NaN() + s.Configure(cfg, nil) + if s.Snapshot().HasLocation || s.Snapshot().Options.HouseholdInvalidReason == "" { + t.Fatal("unserializable configuration remained qualified") + } +} + +func TestForecastReleaseEvidenceDoesNotCrossDriverRestart(t *testing.T) { + current := uint64(4) + live := true + get := func(string) (uint64, bool) { return current, live } + evidence := bindForecastReleaseGeneration(func(string) bool { return true }, []string{"solar"}, get) + if !evidence("solar") || evidence("other") { + t.Fatal("incorrect initial binding") + } + current++ + if evidence("solar") { + t.Fatal("new driver instance inherited old release proof") + } + evidence = bindForecastReleaseGeneration(func(string) bool { return true }, []string{"solar"}, get) + if !evidence("solar") { + t.Fatal("fresh proof did not bind new driver") + } + live = false + if evidence("solar") { + t.Fatal("missing driver retained release proof") + } +} + +func TestForecastLiveIdentityDelayedSerialRestartAndReplacement(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + cfg := &config.Config{Drivers: []config.Driver{{Name: "meter", IsSiteMeter: true}}} + // The historical row is deliberately stale; it cannot bind this process. + _, _ = st.RegisterDevice(state.Device{DriverName: "meter", Make: "vendor", Serial: "wrong-device"}) + live := "" + s := newForecastSiteConfig(st) + s.identity = func(string) (string, bool) { return live, live != "" } + s.Configure(cfg, nil) + if !s.Snapshot().IdentityPending { + t.Fatal("historical devices row vouched for unknown running device") + } + live = "vendor:serial-a" + if !s.RefreshIdentity(time.Now()) { + t.Fatal("delayed serial did not trigger binding") + } + first := s.Snapshot() + if first.IdentityPending { + t.Fatal("reported serial remained pending") + } + // Save actual legacy models with their physical binding. + for _, p := range loadmodel.Profiles() { + m := loadmodel.NewModel(4000) + m.ConfigRevision = first.LearningRevision + m.Timezone = first.Timezone + m.Samples = 7 + encoded, err := modelstate.Wrap(loadmodel.FeatureHash(), m) + if err != nil { + t.Fatal(err) + } + if err := st.SaveConfig("loadmodel/state_utc:"+string(p), string(encoded)); err != nil { + t.Fatal(err) + } + } + _ = st.SaveConfig("loadmodel/timezone", first.Timezone) + restarted := newForecastSiteConfig(st) + live = "ep:tcp://meter:502" + restarted.identity = func(string) (string, bool) { return live, live != "" } + restarted.Configure(cfg, nil) + restarted.RefreshIdentity(time.Now().Add(time.Minute)) + if !restarted.Snapshot().IdentityPending { + t.Fatal("weak startup endpoint replaced confirmed serial") + } + model := loadmodel.NewService(st, telemetry.NewStore(), "meter", 4000, 0) + if model.Model().Samples != 7 { + t.Fatal("pending startup overwrote learned model") + } + live = "vendor:serial-a" + restarted.RefreshIdentity(time.Now()) + same := restarted.Snapshot() + if same.IdentityPending || same.LearningRevision != first.LearningRevision { + t.Fatal("same final live identity changed persisted binding") + } + if err := model.Reconfigure(same.Meter, same.Options, same.Timezone, same.LearningRevision); err != nil { + t.Fatal(err) + } + if model.Model().Samples != 7 { + t.Fatal("same serial discarded restored learning") + } + live = "vendor:serial-b" + if !restarted.RefreshIdentity(time.Now()) { + t.Fatal("same-alias physical replacement was not detected") + } + next := restarted.Snapshot() + if next.IdentityPending || next.LearningRevision == same.LearningRevision { + t.Fatal("new serial reused old site model binding") + } + if err := model.Reconfigure(next.Meter, next.Options, next.Timezone, next.LearningRevision); err != nil { + t.Fatal(err) + } + if model.Model().Samples != 0 { + t.Fatal("new device inherited old household model") + } +} + +func TestForecastEndpointFallbackAndIndependentPVIdentity(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + cfg := &config.Config{Drivers: []config.Driver{{Name: "meter", Lua: "meter.lua", IsSiteMeter: true}, {Name: "pv", Lua: "pv.lua"}, {Name: "ev", Lua: "ev.lua"}}} + catalog := []drivers.CatalogEntry{{Filename: "meter.lua", Capabilities: []string{"meter"}}, {Filename: "pv.lua", Capabilities: []string{"pv"}}, {Filename: "ev.lua", Capabilities: []string{"ev"}}} + ids := map[string]string{"meter": "meter:sn", "pv": "pv:sn"} + s := newForecastSiteConfig(st) + s.identity = func(name string) (string, bool) { id := ids[name]; return id, id != "" } + s.Configure(cfg, catalog) + first := s.Snapshot() + if !first.IdentityPending || first.Options.HouseholdInvalidReason == "" || first.Options.PVInvalidReason != "" { + t.Fatal("unknown EV failed to preserve independent PV qualification") + } + ids["ev"] = "ep:charger-endpoint" + s.RefreshIdentity(s.configuredAt.Add(time.Second)) + if !s.Snapshot().IdentityPending { + t.Fatal("endpoint bypassed init grace") + } + s.RefreshIdentity(s.configuredAt.Add(4 * time.Second)) + ready := s.Snapshot() + if ready.IdentityPending { + t.Fatal("endpoint-only device can never learn") + } + restarted := newForecastSiteConfig(st) + restarted.identity = s.identity + restarted.Configure(cfg, catalog) + restarted.RefreshIdentity(restarted.configuredAt.Add(4 * time.Second)) + if restarted.Snapshot().LearningRevision != ready.LearningRevision { + t.Fatal("same endpoint fallback changed across restart") + } + ids["ev"] = "charger:new-serial" + restarted.RefreshIdentity(time.Now()) + if restarted.Snapshot().LearningRevision == ready.LearningRevision { + t.Fatal("stronger live identity was ignored") + } + ids["pv"] = "" + restarted.RefreshIdentity(time.Now()) + if restarted.Snapshot().Options.PVInvalidReason == "" { + t.Fatal("unknown PV identity remained eligible") + } +} + +func TestForecastWeatherGenerationReceiptSurvivesRestart(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + cfg := &config.Config{Weather: &config.Weather{Provider: "open_meteo", Latitude: 59, Longitude: 18}} + first := newForecastSiteConfig(st) + first.Configure(cfg, nil) + cutoff := first.Snapshot().WeatherSinceMS + second := newForecastSiteConfig(st) + second.Configure(cfg, nil) + if second.Snapshot().WeatherSinceMS != cutoff { + t.Fatal("restart changed unchanged provider cutoff") + } + // A prior receipt cannot qualify forecasts for a new weather location. + second.weatherSinceMS = cutoff - 1000 + cfg.Weather.Latitude = 60 + second.Configure(cfg, nil) + if second.Snapshot().WeatherSinceMS <= cutoff-1000 { + t.Fatal("new location kept old weather generation") + } + third := newForecastSiteConfig(st) + third.Configure(cfg, nil) + if third.Snapshot().WeatherSinceMS != second.Snapshot().WeatherSinceMS { + t.Fatal("new generation did not persist") + } +} diff --git a/go/cmd/ftw/forecast_tracking.go b/go/cmd/ftw/forecast_tracking.go new file mode 100644 index 00000000..7ee4789d --- /dev/null +++ b/go/cmd/ftw/forecast_tracking.go @@ -0,0 +1,807 @@ +package main + +import ( + "context" + "crypto/sha256" + "encoding/json" + "fmt" + "log/slog" + "math" + "sort" + "sync" + "time" + + "github.com/google/uuid" + "github.com/srcfl/ftw/go/internal/forecast" + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/loadmodel" + "github.com/srcfl/ftw/go/internal/mpc" + "github.com/srcfl/ftw/go/internal/pvmodel" + "github.com/srcfl/ftw/go/internal/state" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +type forecastSite struct { + IdentityPending bool + WeatherSinceMS int64 + LearningRevision string + Revision string + SiteID string + Meter string + Latitude, Longitude float64 + HasLocation bool + HasPVScale bool + Timezone string + Options telemetry.ForecastOptions +} + +// forecastCandidate is a host adapter around the compiled model. State is +// captured at forecast origin; later observations cannot alter that request. +type forecastCandidate interface { + Snapshot() json.RawMessage + Update(context.Context, forecastSite, forecasting.Observation, *state.ForecastPoint, bool) error + Predict(context.Context, forecastSite, forecasting.Issue, json.RawMessage, map[int64]bool) (forecasting.Issue, error) + Close() error +} + +type forecastJob struct { + issue forecasting.Issue + site forecastSite + candidateState json.RawMessage + away map[int64]bool +} + +type forecastTracker struct { + refreshIdentity func() + configMu *sync.RWMutex + store *state.Store + tele *telemetry.Store + pv *pvmodel.Service + load *loadmodel.Service + site func() forecastSite + away func(time.Time) bool + curtailed func(time.Time) bool + candidate forecastCandidate + queue chan forecastJob + cancel context.CancelFunc + wg sync.WaitGroup + mu sync.RWMutex + errors []forecasting.ErrorSample + observations []forecasting.Observation + accumulator telemetry.ForecastAccumulator + lastRevision string + pvAccumulator telemetry.ForecastAccumulator + stopped bool + clock func() time.Time +} + +func (f *forecastTracker) Start(ctx context.Context) error { + initCtx, cancel := context.WithTimeout(ctx, 3*time.Second) + err := f.store.InitForecastArchive(initCtx) + cancel() + if err != nil { + return err + } + f.queue = make(chan forecastJob, 8) + workerCtx, stop := context.WithCancel(ctx) + f.cancel = stop + f.wg.Add(1) + go func() { defer f.wg.Done(); f.run(workerCtx) }() + return nil +} +func (f *forecastTracker) Stop() { + if f == nil { + return + } + f.mu.Lock() + f.stopped = true + f.mu.Unlock() + if f.cancel != nil { + f.cancel() + } + f.wg.Wait() + if f.candidate != nil { + _ = f.candidate.Close() + } +} + +func (f *forecastTracker) now() time.Time { + if f.clock != nil { + return f.clock().UTC() + } + return time.Now().UTC() +} + +func (f *forecastTracker) run(ctx context.Context) { + var pending *forecastJob + defer func() { + f.mu.Lock() + f.stopped = true + f.mu.Unlock() + // Finish archiving already issued champion forecasts under a fresh bounded + // context. Candidate work can be recreated; issued inputs cannot. + drainCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) + defer cancel() + save := func(job forecastJob) { + if err := f.store.SaveForecastIssue(drainCtx, job.issue); err != nil { + slog.Warn("forecast archive: shutdown issue unavailable", "id", job.issue.ID, "err", err) + } + } + if pending != nil { + save(*pending) + } + for { + select { + case job := <-f.queue: + save(job) + default: + return + } + } + }() + f.refreshEvidence(ctx, f.now()) + tick := time.NewTicker(10 * time.Second) + defer tick.Stop() + for { + select { + case <-ctx.Done(): + return + case job := <-f.queue: + pending = &job + writeCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + err := f.store.SaveForecastIssue(writeCtx, job.issue) + cancel() + if err != nil { + if ctx.Err() != nil { + return + } + pending = nil + slog.Warn("forecast archive: issue not saved", "id", job.issue.ID, "err", err) + continue + } + pending = nil + if f.candidate != nil { + workCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + candidate, err := f.candidate.Predict(workCtx, job.site, job.issue, job.candidateState, job.away) + cancel() + if err != nil { + slog.Debug("forecast candidate unavailable", "err", err) + continue + } + f.applyBands(&candidate) + writeCtx, cancel = context.WithTimeout(ctx, 2*time.Second) + err = f.store.SaveForecastIssue(writeCtx, candidate) + cancel() + if err != nil { + slog.Warn("forecast archive: candidate not saved", "err", err) + } + } + case now := <-tick.C: + f.observe(ctx, now) + } + } +} + +func (f *forecastTracker) observe(ctx context.Context, now time.Time) { + if f.refreshIdentity != nil { + f.refreshIdentity() + } + if f.configMu != nil { + f.configMu.RLock() + } + site := f.site() + if site.IdentityPending { + if f.configMu != nil { + f.configMu.RUnlock() + } + f.accumulator = telemetry.ForecastAccumulator{} + f.pvAccumulator = telemetry.ForecastAccumulator{} + f.lastRevision = "" + return + } + + r := f.tele.ForecastMeasurement(now, site.Meter, site.Options) + if f.configMu != nil { + f.configMu.RUnlock() + } + if f.curtailed != nil && f.curtailed(now) { + r.PVValid = false + r.PVReason = "curtailed" + } + for _, o := range f.observationIntervals(r, site, now) { + writeCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + err := f.store.SaveForecastObservation(writeCtx, o) + cancel() + if err != nil { + slog.Warn("forecast archive: observation not saved", "err", err) + continue + } + if f.candidate != nil { + rows, _ := f.store.LoadForecasts(o.StartMS-time.Hour.Milliseconds(), o.EndMS) + weather := forecastRow(usableTrackingWeather(rows, now.UnixMilli()), o.StartMS, now.UnixMilli()) + if weather != nil && weather.FetchedAtMs < site.WeatherSinceMS { + weather = nil + } + away := f.away != nil && f.away(time.UnixMilli(o.StartMS)) + workCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + err = f.candidate.Update(workCtx, site, o, weather, away) + cancel() + if err != nil { + slog.Debug("forecast candidate update unavailable", "err", err) + } + } + f.score(ctx, now) + } +} + +// observationIntervals keeps the two measurement claims independent. Unknown +// battery power invalidates household load, but cannot erase valid PV evidence. +func (f *forecastTracker) observationIntervals(r telemetry.ForecastReading, site forecastSite, now time.Time) []forecasting.Observation { + if site.Revision != f.lastRevision { + f.accumulator = telemetry.ForecastAccumulator{} + f.pvAccumulator = telemetry.ForecastAccumulator{} + f.lastRevision = site.Revision + } + byStart := map[int64]forecasting.Observation{} + for _, v := range f.accumulator.Observe(r) { + byStart[v.Start.UnixMilli()] = forecasting.Observation{StartMS: v.Start.UnixMilli(), EndMS: v.End.UnixMilli(), AvailableAtMS: now.UnixMilli(), LoadW: v.HouseholdW, LoadKnown: true, Quality: v.Quality, ConfigVersion: site.Revision} + } + pv := r + pv.Valid = r.PVValid + pv.HouseholdW = 0 + pv.Latest = r.PVLatest + for _, v := range f.pvAccumulator.Observe(pv) { + key := v.Start.UnixMilli() + o, ok := byStart[key] + if !ok { + o = forecasting.Observation{StartMS: key, EndMS: v.End.UnixMilli(), AvailableAtMS: now.UnixMilli(), Quality: "complete_pv_v1", ConfigVersion: site.Revision} + } + o.PVW = math.Max(0, -v.PVW) + o.PVKnown = v.PVValid + byStart[key] = o + } + out := make([]forecasting.Observation, 0, len(byStart)) + for _, o := range byStart { + out = append(out, o) + } + sort.Slice(out, func(i, j int) bool { return out[i].StartMS < out[j].StartMS }) + return out +} + +func (f *forecastTracker) score(ctx context.Context, now time.Time) { + scoreCtx, cancel := context.WithTimeout(ctx, 10*time.Second) + defer cancel() + observations, err := f.store.LoadForecastObservations(scoreCtx, now.Add(-2*time.Hour).UnixMilli(), now.UnixMilli()) + if err != nil { + slog.Warn("forecast evaluation: observations unavailable", "err", err) + return + } + // Decode one archived model snapshot at a time. Only the last complete + // hour of outcomes can have become scoreable since the previous tick. + scores := make(map[forecastErrorKey]forecasting.ErrorSample) + err = f.store.VisitForecastIssues(scoreCtx, now.Add(-50*time.Hour).UnixMilli(), now.UnixMilli(), func(issue forecasting.Issue) error { + mergeForecastErrors(scores, forecasting.Errors([]forecasting.Issue{issue}, observations, now.UnixMilli())) + return nil + }) + if err == nil { + err = f.store.SaveForecastErrors(scoreCtx, forecastErrorValues(scores), now.UnixMilli()) + } + if err != nil { + slog.Warn("forecast evaluation failed", "err", err) + return + } + f.refreshEvidence(ctx, now) +} + +type forecastErrorKey struct { + Series, Config string + Start, End int64 + Lead int +} + +func mergeForecastErrors(dst map[forecastErrorKey]forecasting.ErrorSample, src []forecasting.ErrorSample) { + for _, e := range src { + key := forecastErrorKey{e.Series, e.ConfigVersion, e.StartMS, e.EndMS, e.Lead} + old, ok := dst[key] + if !ok || e.OriginMS > old.OriginMS || (e.OriginMS == old.OriginMS && (e.IssuedAtMS > old.IssuedAtMS || (e.IssuedAtMS == old.IssuedAtMS && e.IssueID > old.IssueID))) { + dst[key] = e + } + } +} +func forecastErrorValues(m map[forecastErrorKey]forecasting.ErrorSample) []forecasting.ErrorSample { + out := make([]forecasting.ErrorSample, 0, len(m)) + for _, v := range m { + out = append(out, v) + } + sort.Slice(out, func(i, j int) bool { + a, b := out[i], out[j] + if a.StartMS != b.StartMS { + return a.StartMS < b.StartMS + } + if a.Series != b.Series { + return a.Series < b.Series + } + if a.ConfigVersion != b.ConfigVersion { + return a.ConfigVersion < b.ConfigVersion + } + if a.Lead != b.Lead { + return a.Lead < b.Lead + } + return a.EndMS < b.EndMS + }) + return out +} + +func (f *forecastTracker) refreshEvidence(ctx context.Context, now time.Time) { + readCtx, cancel := context.WithTimeout(ctx, 3*time.Second) + defer cancel() + errors, err := f.store.LoadForecastErrors(readCtx, now.Add(-30*24*time.Hour).UnixMilli(), now.UnixMilli(), true) + if err != nil { + slog.Warn("forecast calibration unavailable", "err", err) + return + } + observations, err := f.store.LoadForecastObservations(readCtx, now.Add(-8*24*time.Hour).UnixMilli(), now.UnixMilli()) + if err != nil { + slog.Warn("forecast baselines unavailable", "err", err) + return + } + f.mu.Lock() + f.errors = errors + f.observations = observations + f.mu.Unlock() +} + +func forecastHash(value any) string { + data, _ := json.Marshal(value) + return fmt.Sprintf("%x", sha256.Sum256(data)) +} + +func forecastRow(rows []state.ForecastPoint, target, origin int64) *state.ForecastPoint { + for i := range rows { + r := &rows[i] + length := r.SlotLenMin + if length <= 0 { + length = 60 + } + if target >= r.SlotTsMs && target < r.SlotTsMs+int64(length)*60000 && + r.FetchedAtMs > 0 && r.FetchedAtMs <= origin && origin-r.FetchedAtMs <= mpc.ForecastMaxAge.Milliseconds() { + return r + } + } + return nil +} + +func (f *forecastTracker) Snapshot(_ time.Time, weather []state.ForecastPoint) mpc.ForecastInputs { + if f.refreshIdentity != nil { + f.refreshIdentity() + } + if f.configMu != nil { + f.configMu.RLock() + defer f.configMu.RUnlock() + } + captureAt := f.now() + site := f.site() + if site.IdentityPending { + // Keep persisted learning untouched until the running hardware proves its + // binding. An explicit empty weather slice prevents fallback to old rows. + return mpc.ForecastInputs{Weather: []state.ForecastPoint{}} + } + site.Options.ExpectedFlows = append([]telemetry.ForecastFlow(nil), site.Options.ExpectedFlows...) + pv := f.pv.ForecastSnapshot() + load := f.load.Snapshot() + f.mu.RLock() + history := f.errors + observations := f.observations + f.mu.RUnlock() + candidateState := json.RawMessage(nil) + if f.candidate != nil { + candidateState = append(json.RawMessage(nil), f.candidate.Snapshot()...) + } + away := make(map[int64]bool) + start := captureAt.Truncate(15 * time.Minute) + for i := 0; i < 193; i++ { + at := start.Add(time.Duration(i) * 15 * time.Minute) + away[at.UnixMilli()] = f.away != nil && f.away(at) + } + frozen := cloneForecastRows(weather) + if !site.HasPVScale { + for i := range frozen { + if frozen[i].Source != "forecast_solar" { + frozen[i].PVWEstimated = nil + } + } + } + origin := f.now() // all models, occupancy and weather captured before inference + frozen = usableTrackingWeather(frozen, origin.UnixMilli()) + if site.WeatherSinceMS > 0 { + fresh := frozen[:0] + for _, row := range frozen { + if row.FetchedAtMs >= site.WeatherSinceMS { + fresh = append(fresh, row) + } + } + frozen = fresh + } + calibrator := forecasting.NewCalibrator(history, site.Revision, origin.UnixMilli()) + pvFn := mpc.PVPredictor(nil) + if f.pv != nil && site.HasLocation { + pvFn = func(t time.Time, cloud float64) float64 { + return pv.Structural(t, forecast.ClearSkyWm2(site.Latitude, site.Longitude, t), cloud) + } + } + loadFn := func(t time.Time) float64 { + profile := load.ActiveProfile + if away[t.Truncate(15*time.Minute).UnixMilli()] { + profile = loadmodel.ProfileAway + } + m := load.Profiles[profile] + temp := math.NaN() + if row := forecastRow(frozen, t.UnixMilli(), origin.UnixMilli()); row != nil && row.TempC != nil { + temp = *row.TempC + } + return m.Predict(t, temp) + } + in := mpc.ForecastInputs{PV: pvFn, PVResidualCorrect: pv.ResidualCorrect, Load: loadFn, + PVUncertaintyW: pv.ResidualStdW(origin), PVRelativeUncertainty: pv.RelativeUncertainty(), Weather: frozen} + in.PVWeight = func(t time.Time) float64 { + if !site.HasPVScale { + return 1 + } + return mpc.PlannerRadiationWeight * pv.Model.Trust(t) + } + models := []forecasting.ModelState{} + latest := int64(0) + if f.pv != nil { + data, _ := json.Marshal(struct { + Model pvmodel.Model `json:"model"` + Residuals []pvmodel.ResidualObservation `json:"residuals"` + }{pv.Model, pv.Residuals}) + updated := int64(0) + quality := "cold_start" + if !pv.LatestInput.IsZero() { + updated = pv.LatestInput.UnixMilli() + quality = forecasting.ModelQualityWarm + } + models = append(models, forecasting.ModelState{Name: "legacy_pv", Version: pv.Revision, UpdatedAtMS: updated, Quality: quality, State: data}) + latest = max(latest, updated) + } + for _, profile := range loadmodel.Profiles() { + m, ok := load.Profiles[profile] + if !ok { + continue + } + data, _ := json.Marshal(m) + quality := "cold_start" + if m.LastMs > 0 { + quality = forecasting.ModelQualityWarm + } + models = append(models, forecasting.ModelState{Name: "legacy_load_" + string(profile), Version: forecastHash(m), + UpdatedAtMS: m.LastMs, Quality: quality, State: data}) + latest = max(latest, m.LastMs) + } + for _, r := range frozen { + if r.FetchedAtMs <= origin.UnixMilli() { + latest = max(latest, r.FetchedAtMs) + } + } + for _, o := range observations { + if o.ConfigVersion == site.Revision && o.AvailableAtMS <= origin.UnixMilli() { + latest = max(latest, o.AvailableAtMS) + } + } + for _, e := range history { + if e.ConfigVersion == site.Revision && e.AvailableAtMS <= origin.UnixMilli() { + latest = max(latest, e.AvailableAtMS) + } + } + // Calibrated net error uses the same issued champion, including its actual + // blend. Prior uncertainty remains explicit until held-out evidence exists. + in.Risk = func(base, planning []mpc.Slot, k float64) { + if k <= 0 || math.IsNaN(k) || math.IsInf(k, 0) { + return + } + for i, s := range base { + net := s.LoadW + s.PVW + end := s.StartMs + int64(s.LenMin)*time.Minute.Milliseconds() + band := calibrator.BandForInterval("champion", "net", s.StartMs, end, net) + if band.Method == forecasting.BandMethodEmpirical { + extra := math.Max(0, k*(band.HighW-net)) + pvLoss := math.Min(-s.PVW, extra) + planning[i].PVW = s.PVW + pvLoss + planning[i].LoadW = s.LoadW + extra - pvLoss + } else if pv.RelativeUncertainty() <= 0 && pv.ResidualStdW(origin) <= 0 { + // An empty residual window is not certainty. This prior only + // reduces existing generation; it never creates solar at night. + loss := math.Min(-s.PVW, k*.5*(-s.PVW)) + planning[i].PVW = s.PVW + loss + } + } + } + in.Record = func(base, planning []mpc.Slot, decisionID string, issued int64) { + issue := forecasting.Issue{Schema: forecasting.Schema, ID: uuid.NewString(), DecisionID: decisionID, + OriginMS: origin.UnixMilli(), IssuedAtMS: issued, LatestInputMS: latest, ConfigVersion: site.Revision, Site: forecastSiteContext(site), Models: cloneForecastModels(models)} + for i := 0; i < 193; i++ { + at := start.Add(time.Duration(i) * 15 * time.Minute).UnixMilli() + issue.Occupancy = append(issue.Occupancy, forecasting.Occupancy{StartMS: at, EndMS: at + 900000, AvailableAtMS: issue.OriginMS, Home: !away[at]}) + issue.LatestInputMS = max(issue.LatestInputMS, issue.OriginMS) + } + for _, r := range frozen { + if r.FetchedAtMs <= 0 || r.FetchedAtMs > issue.OriginMS { + continue + } + length := r.SlotLenMin + if length <= 0 { + length = 60 + } + var directPV *float64 + if r.Source == "forecast_solar" { + directPV = r.PVWEstimated + } + issue.Weather = append(issue.Weather, forecasting.Weather{StartMS: r.SlotTsMs, EndMS: r.SlotTsMs + int64(length)*60000, + AvailableAtMS: r.FetchedAtMs, Source: r.Source, GHIWm2: r.SolarWm2, CloudPct: r.CloudCoverPct, TempC: r.TempC, DirectPVW: directPV, EstimatedPVW: r.PVWEstimated}) + } + issue.Series = append(issue.Series, forecasting.Series{Name: "champion", ModelVersion: forecastModelRevision(models), Points: forecastPoints(base, frozen, site, origin, load)}) + issue.Series = append(issue.Series, forecasting.Series{Name: "planning", ModelVersion: forecastModelRevision(models), Points: forecastPoints(planning, frozen, site, origin, load)}) + issue.Series = append(issue.Series, forecastBaselines(base, frozen, observations, site, origin)...) + applyForecastBandsWith(&issue, calibrator) + job := forecastJob{issue: issue, site: site, candidateState: candidateState, away: away} + f.mu.Lock() + defer f.mu.Unlock() + if f.stopped { + slog.Warn("forecast archive stopped; issue unavailable for evaluation", "decision_id", decisionID) + return + } + select { + case f.queue <- job: + default: + slog.Warn("forecast archive queue full; issue unavailable for evaluation", "decision_id", decisionID) + } + } + return in +} + +func usableTrackingWeather(rows []state.ForecastPoint, origin int64) []state.ForecastPoint { + out := make([]state.ForecastPoint, 0, len(rows)) + for _, r := range rows { + length := r.SlotLenMin + if length <= 0 { + length = 60 + } + if r.Source == "" || r.FetchedAtMs <= 0 || r.FetchedAtMs > origin || origin-r.FetchedAtMs > mpc.ForecastMaxAge.Milliseconds() || length > 60 { + continue + } + if !forecastFinite(r.PVWEstimated) || (r.PVWEstimated != nil && *r.PVWEstimated < 0) { + r.PVWEstimated = nil + } + if !forecastFinite(r.SolarWm2) || (r.SolarWm2 != nil && *r.SolarWm2 < 0) { + r.SolarWm2 = nil + } + if !forecastFinite(r.CloudCoverPct) || (r.CloudCoverPct != nil && (*r.CloudCoverPct < 0 || *r.CloudCoverPct > 100)) { + r.CloudCoverPct = nil + } + if !forecastFinite(r.TempC) { + r.TempC = nil + } + out = append(out, r) + } + return out +} + +func cloneForecastRows(rows []state.ForecastPoint) []state.ForecastPoint { + out := append([]state.ForecastPoint(nil), rows...) + copyNumber := func(v *float64) *float64 { + if v == nil { + return nil + } + copy := *v + return © + } + for i := range out { + r := &out[i] + r.CloudCoverPct = copyNumber(r.CloudCoverPct) + r.TempC = copyNumber(r.TempC) + r.SolarWm2 = copyNumber(r.SolarWm2) + r.PVWEstimated = copyNumber(r.PVWEstimated) + } + return out +} +func cloneForecastModels(models []forecasting.ModelState) []forecasting.ModelState { + out := append([]forecasting.ModelState(nil), models...) + for i := range out { + out[i].State = append(json.RawMessage(nil), out[i].State...) + } + return out +} +func forecastModelRevision(models []forecasting.ModelState) string { + revisions := make(map[string]string, len(models)) + for _, m := range models { + revisions[m.Name] = m.Version + } + return forecastHash(revisions) +} + +func forecastFinite(v *float64) bool { return v != nil && !math.IsNaN(*v) && !math.IsInf(*v, 0) } +func forecastPVKnown(row *state.ForecastPoint, site forecastSite) bool { + if row == nil { + return false + } + if row.Source == "forecast_solar" { + return forecastFinite(row.PVWEstimated) && *row.PVWEstimated >= 0 + } + if !site.HasLocation || !site.HasPVScale { + return false + } + return (forecastFinite(row.CloudCoverPct) && *row.CloudCoverPct >= 0 && *row.CloudCoverPct <= 100) || (forecastFinite(row.SolarWm2) && *row.SolarWm2 >= 0) +} +func forecastPoints(slots []mpc.Slot, weather []state.ForecastPoint, site forecastSite, origin time.Time, loads ...loadmodel.Snapshot) []forecasting.Point { + out := make([]forecasting.Point, 0, len(slots)) + for _, s := range slots { + row := forecastRow(weather, s.StartMs, origin.UnixMilli()) + known := forecastPVKnown(row, site) + quality := "pv_input_unknown" + if known { + quality = "weather_model" + if row.Source == "forecast_solar" { + quality = "weather_direct" + } + } + loadQuality := "cold_start" + if len(loads) > 0 { + snap := loads[0] + m := snap.Profiles[snap.ActiveProfile] + if m.LastMs > 0 { + loadQuality = "learning" + if m.Coverage(time.UnixMilli(s.StartMs)) == 0 { + loadQuality = "uncovered" + } + } + } + out = append(out, forecasting.Point{StartMS: s.StartMs, EndMS: s.StartMs + int64(s.LenMin)*60000, + PVW: math.Max(0, -s.PVW), LoadW: math.Max(0, s.LoadW), PVKnown: known, LoadKnown: true, + PVQuality: quality, LoadQuality: loadQuality}) + } + return out +} + +// baselineObservation averages a fully covered source interval by energy. +// It never stretches one quarter's observation across an hour or fills a gap. +func baselineObservation(obs []forecasting.Observation, site forecastSite, start, end, origin int64) (forecasting.Observation, bool) { + return coverBaseline(indexBaselineObservations(obs, site, origin), start, end, site.Revision) +} +func indexBaselineObservations(obs []forecasting.Observation, site forecastSite, origin int64) map[int64]forecasting.Observation { + byStart := make(map[int64]forecasting.Observation) + for _, o := range obs { + if o.ConfigVersion != site.Revision || o.AvailableAtMS > origin || o.Validate() != nil { + continue + } + if old, ok := byStart[o.StartMS]; !ok || o.EndMS > old.EndMS { + byStart[o.StartMS] = o + } + } + return byStart +} +func coverBaseline(byStart map[int64]forecasting.Observation, start, end int64, revision string) (forecasting.Observation, bool) { + out := forecasting.Observation{StartMS: start, EndMS: end, PVKnown: true, LoadKnown: true, ConfigVersion: revision, Quality: "observed_baseline"} + var pvEnergy, loadEnergy float64 + for cursor := start; cursor < end; { + o, ok := byStart[cursor] + if !ok || o.EndMS <= cursor || o.EndMS > end { + return forecasting.Observation{}, false + } + duration := float64(o.EndMS - o.StartMS) + pvEnergy += o.PVW * duration + loadEnergy += o.LoadW * duration + out.PVKnown = out.PVKnown && o.PVKnown + out.LoadKnown = out.LoadKnown && o.LoadKnown + out.AvailableAtMS = max(out.AvailableAtMS, o.AvailableAtMS) + cursor = o.EndMS + } + if end <= start { + return forecasting.Observation{}, false + } + out.PVW = pvEnergy / float64(end-start) + out.LoadW = loadEnergy / float64(end-start) + return out, true +} +func baselineDayShift(target int64, days int, zone string) (int64, bool) { + loc, err := time.LoadLocation(zone) + if err != nil { + loc = time.UTC + } + return baselineDayShiftAt(target, days, loc) +} +func baselineDayShiftAt(target int64, days int, loc *time.Location) (int64, bool) { + local := time.UnixMilli(target).In(loc) + shifted := local.AddDate(0, 0, days) + // A spring-forward wall hour may not exist on the source day. + if shifted.Hour() != local.Hour() || shifted.Minute() != local.Minute() { + return 0, false + } + return shifted.UnixMilli(), true +} +func forecastBaselines(slots []mpc.Slot, weather []state.ForecastPoint, obs []forecasting.Observation, site forecastSite, origin time.Time) []forecasting.Series { + out := []forecasting.Series{} + index := indexBaselineObservations(obs, site, origin.UnixMilli()) + loc, err := time.LoadLocation(site.Timezone) + if err != nil { + loc = time.UTC + } + for _, name := range []string{"weather_prior", "previous_day", "previous_week", "persistence"} { + series := forecasting.Series{Name: name, ModelVersion: "baseline-v2-local-interval"} + for _, s := range slots { + p := forecasting.Point{StartMS: s.StartMs, EndMS: s.StartMs + int64(s.LenMin)*60000, PVQuality: "missing", LoadQuality: "missing"} + switch name { + case "weather_prior": + if row := forecastRow(weather, p.StartMS, origin.UnixMilli()); forecastPVKnown(row, site) && forecastFinite(row.PVWEstimated) { + p.PVW = math.Max(0, *row.PVWEstimated) + p.PVKnown = true + p.PVQuality = "weather" + } + p.LoadW = s.LoadW + p.LoadKnown = true + p.LoadQuality = "champion_load" + default: + target, valid := p.StartMS, true + if name == "previous_day" { + target, valid = baselineDayShiftAt(p.StartMS, -1, loc) + } + if name == "previous_week" { + target, valid = baselineDayShiftAt(p.StartMS, -7, loc) + } + length := p.EndMS - p.StartMS + if name == "persistence" { + // The most recent complete interval of the same duration is available + // even if observation delivery lagged the latest quarter boundary. + target = 0 + for _, o := range obs { + if o.ConfigVersion == site.Revision && o.AvailableAtMS <= origin.UnixMilli() && o.EndMS <= origin.UnixMilli() && o.EndMS-length > target { + target = o.EndMS - length + } + } + valid = target > 0 + } + if valid { + if o, ok := coverBaseline(index, target, target+length, site.Revision); ok { + p.PVW, p.LoadW, p.PVKnown, p.LoadKnown = o.PVW, o.LoadW, o.PVKnown, o.LoadKnown + p.PVQuality, p.LoadQuality = "observed_baseline", "observed_baseline" + } + } + } + series.Points = append(series.Points, p) + } + out = append(out, series) + } + return out +} + +func applyForecastBandsWith(issue *forecasting.Issue, calibrator *forecasting.Calibrator) { + for i := range issue.Series { + s := &issue.Series[i] + for j := range s.Points { + p := &s.Points[j] + p.PVBand = calibrator.BandForInterval(s.Name, "pv", p.StartMS, p.EndMS, p.PVW) + p.LoadBand = calibrator.BandForInterval(s.Name, "load", p.StartMS, p.EndMS, p.LoadW) + p.NetBand = calibrator.BandForInterval(s.Name, "net", p.StartMS, p.EndMS, p.LoadW-p.PVW) + } + } +} +func applyForecastBands(issue *forecasting.Issue, history []forecasting.ErrorSample) { + applyForecastBandsWith(issue, forecasting.NewCalibrator(history, issue.ConfigVersion, issue.OriginMS)) +} +func (f *forecastTracker) applyBands(issue *forecasting.Issue) { + f.mu.RLock() + history := f.errors + f.mu.RUnlock() + applyForecastBands(issue, history) +} + +func forecastSiteContext(site forecastSite) *forecasting.SiteContext { + if !site.HasLocation { + site.Latitude, site.Longitude = 0, 0 + } + if site.SiteID == "" || site.Timezone == "" { + return nil + } + return &forecasting.SiteContext{SiteID: site.SiteID, LearningRevision: rustConfigRevision(site), Timezone: site.Timezone, + HasLocation: site.HasLocation, Latitude: site.Latitude, Longitude: site.Longitude} +} diff --git a/go/cmd/ftw/forecast_tracking_test.go b/go/cmd/ftw/forecast_tracking_test.go new file mode 100644 index 00000000..c4228d70 --- /dev/null +++ b/go/cmd/ftw/forecast_tracking_test.go @@ -0,0 +1,449 @@ +package main + +import ( + "context" + "encoding/json" + "math" + "path/filepath" + "sync" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/loadmodel" + "github.com/srcfl/ftw/go/internal/mpc" + "github.com/srcfl/ftw/go/internal/pvmodel" + "github.com/srcfl/ftw/go/internal/state" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func trackerNumber(v float64) *float64 { return &v } +func trackerSite() forecastSite { + return forecastSite{Revision: "site-v1", Meter: "site", Timezone: "Europe/Stockholm", HasLocation: true, HasPVScale: true, Latitude: 59, Longitude: 18} +} +func trackerFixture(at time.Time) *forecastTracker { + tel := telemetry.NewStore() + return &forecastTracker{tele: tel, load: loadmodel.NewService(nil, tel, "site", 4000, 0), pv: pvmodel.NewService(nil, tel, func(time.Time) float64 { return 800 }, nil, 8000), site: trackerSite, clock: func() time.Time { return at }, queue: make(chan forecastJob, 8)} +} +func trackerSlots(at time.Time, n int) []mpc.Slot { + out := make([]mpc.Slot, n) + for i := range out { + out[i] = mpc.Slot{StartMs: at.Add(time.Duration(i) * 15 * time.Minute).UnixMilli(), LenMin: 15, PVW: -2000, LoadW: 1000} + } + return out +} +func trackerWeather(at, origin time.Time) []state.ForecastPoint { + return []state.ForecastPoint{{SlotTsMs: at.UnixMilli(), SlotLenMin: 60, FetchedAtMs: origin.Add(-time.Minute).UnixMilli(), Source: "open_meteo", SolarWm2: trackerNumber(500), CloudCoverPct: trackerNumber(10), TempC: trackerNumber(5), PVWEstimated: trackerNumber(4000)}} +} +func TestForecastTrackingKnownPVInputs(t *testing.T) { + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + site := trackerSite() + slots := trackerSlots(at, 1) + tests := []struct { + name string + row state.ForecastPoint + site forecastSite + known bool + }{ + {"direct without location", state.ForecastPoint{Source: "forecast_solar", PVWEstimated: trackerNumber(3000)}, forecastSite{}, true}, + {"temp only", state.ForecastPoint{Source: "open_meteo", TempC: trackerNumber(5)}, site, false}, + {"cloud", state.ForecastPoint{Source: "met_no", CloudCoverPct: trackerNumber(80)}, site, true}, + {"invalid cloud", state.ForecastPoint{Source: "met_no", CloudCoverPct: trackerNumber(math.NaN())}, site, false}, + {"unknown scale", state.ForecastPoint{Source: "open_meteo", SolarWm2: trackerNumber(500)}, forecastSite{HasLocation: true}, false}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.row.SlotTsMs = at.UnixMilli() + tc.row.SlotLenMin = 60 + tc.row.FetchedAtMs = at.Add(-time.Minute).UnixMilli() + p := forecastPoints(slots, []state.ForecastPoint{tc.row}, tc.site, at)[0] + if p.PVKnown != tc.known { + t.Fatalf("known=%v want=%v %+v", p.PVKnown, tc.known, p) + } + }) + } + stale := trackerWeather(at, at) + stale[0].FetchedAtMs = at.Add(-mpc.ForecastMaxAge - time.Second).UnixMilli() + if forecastPoints(slots, stale, site, at)[0].PVKnown { + t.Fatal("stale weather marked known") + } +} +func TestForecastBaselineRequiresWholeHourAndLocalDay(t *testing.T) { + loc, _ := time.LoadLocation("Europe/Stockholm") + target := time.Date(2026, 3, 30, 19, 0, 0, 0, loc) + prior := time.Date(2026, 3, 23, 19, 0, 0, 0, loc) + site := trackerSite() + origin := target.Add(-time.Hour) + obs := []forecasting.Observation{} + for i, w := range []float64{1000, 3000, 1000, 3000} { + start := prior.Add(time.Duration(i) * 15 * time.Minute) + obs = append(obs, forecasting.Observation{StartMS: start.UnixMilli(), EndMS: start.Add(15 * time.Minute).UnixMilli(), AvailableAtMS: start.Add(15 * time.Minute).UnixMilli(), LoadW: w, PVW: 2000, LoadKnown: true, PVKnown: true, ConfigVersion: site.Revision, Quality: "complete_balance_v1"}) + } + slots := []mpc.Slot{{StartMs: target.UnixMilli(), LenMin: 60, LoadW: 1000}} + baselines := forecastBaselines(slots, nil, obs, site, origin) + week := baselines[2].Points[0] + if !week.LoadKnown || week.LoadW != 2000 { + t.Fatalf("DST week/energy wrong: %+v", week) + } + broken := forecastBaselines(slots, nil, obs[:3], site, origin)[2].Points[0] + if broken.LoadKnown || broken.PVKnown { + t.Fatal("missing quarter stretched into an hour") + } + springMissing := time.Date(2026, 3, 30, 2, 0, 0, 0, loc) + if _, ok := baselineDayShift(springMissing.UnixMilli(), -1, site.Timezone); ok { + t.Fatal("nonexistent source wall hour accepted") + } +} +func TestForecastSnapshotFreezesHorizonAndRecord(t *testing.T) { + origin := time.Date(2026, 1, 5, 11, 59, 0, 0, time.UTC) + target := origin.Add(time.Minute) + f := trackerFixture(origin) + weather := trackerWeather(target, origin) + in := f.Snapshot(origin, weather) + before := in.Load(target) + pvBefore := in.PV(target, 10) + *weather[0].TempC = -40 + *weather[0].CloudCoverPct = 99 + f.load.SetHeatingCoef(1000) + f.pv.SetRated(100000) + if in.Load(target) != before || in.PV(target, 10) != pvBefore { + t.Fatal("live changes altered captured horizon") + } + slots := trackerSlots(target, 1) + in.Record(slots, slots, "decision", origin.UnixMilli()) + job := <-f.queue + if err := job.issue.Validate(); err != nil { + t.Fatal(err) + } + slots[0].LoadW = 99999 + if job.issue.Series[0].Points[0].LoadW == 99999 || *job.issue.Weather[0].TempC != 5 { + t.Fatal("record shared mutable input") + } + if job.issue.LatestInputMS != origin.UnixMilli() { + t.Fatalf("latest frozen occupancy input missing: %d", job.issue.LatestInputMS) + } + if job.issue.Series[0].Points[0].LoadQuality != "cold_start" { + t.Fatal("cold load called trained") + } + in.Record(trackerSlots(target, 1), trackerSlots(target, 1), "decision-2", origin.UnixMilli()) + job2 := <-f.queue + if job.issue.Series[0].ModelVersion != job2.issue.Series[0].ModelVersion { + t.Fatal("one capture has multiple model revisions") + } +} + +func TestForecastSnapshotRejectsWeatherFromPreviousLocation(t *testing.T) { + origin := time.Date(2026, 6, 15, 11, 59, 0, 0, time.UTC) + target := origin.Add(time.Minute) + f := trackerFixture(origin) + site := trackerSite() + site.SiteID, site.LearningRevision = "site", "physical-v2" + site.WeatherSinceMS = origin.Add(-30 * time.Second).UnixMilli() + f.site = func() forecastSite { return site } + weather := trackerWeather(target, origin) + old := f.Snapshot(origin, weather) + if len(old.Weather) != 0 { + t.Fatal("weather captured before a location change survived the snapshot") + } + slots := trackerSlots(target, 1) + old.Record(slots, slots, "old-weather", origin.UnixMilli()) + job := <-f.queue + if err := job.issue.Validate(); err != nil { + t.Fatal(err) + } + if len(job.issue.Weather) != 0 || job.issue.Series[0].Points[0].PVKnown { + t.Fatal("old location weather was archived as usable PV evidence") + } + if job.issue.Site == nil || job.issue.Site.SiteID != site.SiteID || job.issue.Site.LearningRevision != site.LearningRevision { + t.Fatal("issue lost the new location binding") + } + weather[0].FetchedAtMs = origin.Add(-10 * time.Second).UnixMilli() + fresh := f.Snapshot(origin, weather) + if len(fresh.Weather) != 1 { + t.Fatal("new location weather was rejected") + } + fresh.Record(slots, slots, "new-weather", origin.UnixMilli()) + job = <-f.queue + if len(job.issue.Weather) != 1 || !job.issue.Series[0].Points[0].PVKnown { + t.Fatal("new location weather did not restore PV evidence") + } +} + +type trackingCandidate struct { + onSnapshot func() + snapshot json.RawMessage +} + +func (c *trackingCandidate) Snapshot() json.RawMessage { + if c.onSnapshot != nil { + c.onSnapshot() + } + return c.snapshot +} +func (c *trackingCandidate) Update(context.Context, forecastSite, forecasting.Observation, *state.ForecastPoint, bool) error { + return nil +} +func (c *trackingCandidate) Predict(context.Context, forecastSite, forecasting.Issue, json.RawMessage, map[int64]bool) (forecasting.Issue, error) { + return forecasting.Issue{}, context.Canceled +} +func (c *trackingCandidate) Close() error { return nil } +func TestForecastOriginFollowsCandidateCapture(t *testing.T) { + at := time.Date(2026, 1, 5, 11, 59, 0, 0, time.UTC) + f := trackerFixture(at) + clock := at + f.clock = func() time.Time { return clock } + c := &trackingCandidate{snapshot: json.RawMessage("{}"), onSnapshot: func() { clock = at.Add(time.Second) }} + f.candidate = c + in := f.Snapshot(at, nil) + slots := trackerSlots(at.Add(time.Minute), 1) + in.Record(slots, slots, "decision", clock.UnixMilli()) + job := <-f.queue + if job.issue.OriginMS != clock.UnixMilli() { + t.Fatal("origin preceded candidate snapshot") + } + c.snapshot[0] = 'x' + if !json.Valid(job.candidateState) { + t.Fatal("candidate snapshot aliased") + } +} +func TestForecastIndependentPVIntervalsAndCurtailment(t *testing.T) { + f := &forecastTracker{} + site := trackerSite() + start := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + var out []forecasting.Observation + for i := 0; i <= 15; i++ { + at := start.Add(time.Duration(i) * time.Minute) + out = append(out, f.observationIntervals(telemetry.ForecastReading{At: at, Latest: at, PVLatest: at, Valid: false, PVValid: true, PVW: -2000}, site, at)...) + } + if len(out) != 1 || !out[0].PVKnown || out[0].LoadKnown || out[0].PVW != 2000 { + t.Fatalf("missing battery blocked PV: %+v", out) + } + f = &forecastTracker{} + out = nil + for i := 0; i <= 15; i++ { + at := start.Add(time.Duration(i) * time.Minute) + out = append(out, f.observationIntervals(telemetry.ForecastReading{At: at, Latest: at, PVLatest: at, Valid: true, PVValid: i != 7, PVW: -2000, HouseholdW: 1000}, site, at)...) + } + if len(out) != 1 || out[0].PVKnown || !out[0].LoadKnown { + t.Fatalf("curtailment became available PV or hid house: %+v", out) + } +} +func TestForecastMergeDeduplicatesTargetLead(t *testing.T) { + samples := make(map[forecastErrorKey]forecasting.ErrorSample) + a := forecasting.ErrorSample{Series: "champion", ConfigVersion: "v1", StartMS: 1000, EndMS: 2000, Lead: 0, OriginMS: 100, IssuedAtMS: 101, IssueID: "a"} + b := a + b.OriginMS = 200 + b.IssuedAtMS = 201 + b.IssueID = "b" + for i := 0; i < 1000; i++ { + mergeForecastErrors(samples, []forecasting.ErrorSample{b, a}) + } + if len(samples) != 1 || forecastErrorValues(samples)[0].IssueID != "b" { + t.Fatal("replans multiplied evidence") + } + b.ConfigVersion = "v2" + mergeForecastErrors(samples, []forecasting.ErrorSample{b}) + if len(samples) != 2 { + t.Fatal("config epochs merged") + } +} +func TestForecastArchiveRejectsCurrentPartialAsEvidence(t *testing.T) { + origin := time.Date(2026, 1, 5, 12, 1, 0, 0, time.UTC) + f := trackerFixture(origin) + in := f.Snapshot(origin, trackerWeather(origin.Truncate(time.Hour), origin)) + slots := trackerSlots(origin.Truncate(15*time.Minute), 1) + in.Record(slots, slots, "decision", origin.UnixMilli()) + job := <-f.queue + end := slots[0].StartMs + 15*time.Minute.Milliseconds() + obs := []forecasting.Observation{{StartMS: slots[0].StartMs, EndMS: end, AvailableAtMS: end, PVW: 2000, LoadW: 1000, PVKnown: true, LoadKnown: true, Quality: "complete_balance_v1", ConfigVersion: trackerSite().Revision}} + if got := forecasting.Errors([]forecasting.Issue{job.issue}, obs, end); len(got) != 0 { + t.Fatalf("partial issued interval scored: %+v", got) + } +} +func TestForecastColdPriorRiskPreservesPowerSigns(t *testing.T) { + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + f := trackerFixture(at) + in := f.Snapshot(at, nil) + base := trackerSlots(at, 2) + base[1].PVW = 0 + planning := append([]mpc.Slot(nil), base...) + in.Risk(base, planning, 1) + if planning[0].PVW <= base[0].PVW || planning[0].PVW > 0 || planning[1].PVW != 0 { + t.Fatal("cold prior no hedge or invented solar") + } + in.Record(base, planning, "decision", at.UnixMilli()) + job := <-f.queue + if job.issue.Series[0].Points[0].PVBand.Method != forecasting.BandMethodColdStart { + t.Fatal("cold prior called empirical") + } +} + +func TestForecastBandsUsePointIntervalDuration(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC) + prior := forecasting.Band{LowW: 0, HighW: 5000, Method: forecasting.BandMethodColdStart} + history := make([]forecasting.ErrorSample, 0, 56) + for day := 0; day < 7; day++ { + for hour := 0; hour < 8; hour++ { + start := base.Add(time.Duration(day*24+hour) * time.Hour) + end := start.Add(15 * time.Minute) + prediction := forecasting.Point{StartMS: start.UnixMilli(), EndMS: end.UnixMilli(), PVW: 100, LoadW: 1000, + PVKnown: true, LoadKnown: true, PVQuality: "test", LoadQuality: "test", PVBand: prior, LoadBand: prior, NetBand: prior} + history = append(history, forecasting.ErrorSample{Series: "champion", ConfigVersion: "site-v1", IssueID: "quarter", + OriginMS: start.Add(-2 * time.Hour).UnixMilli(), IssuedAtMS: start.Add(-2 * time.Hour).UnixMilli(), + StartMS: start.UnixMilli(), EndMS: end.UnixMilli(), AvailableAtMS: end.UnixMilli(), + Lead: forecasting.LeadBucket(start.Add(-2*time.Hour).UnixMilli(), start.UnixMilli()), PVErrorW: 40, LoadErrorW: 20, + PVKnown: true, LoadKnown: true, Prediction: prediction}) + } + } + origin := base.Add(8 * 24 * time.Hour) + target := origin.Add(2*time.Hour + 15*time.Minute) + issue := forecasting.Issue{Series: []forecasting.Series{{Name: "champion", Points: []forecasting.Point{{ + StartMS: target.UnixMilli(), EndMS: target.Add(15 * time.Minute).UnixMilli(), PVW: 1000, LoadW: 2000, + }}}}} + applyForecastBandsWith(&issue, forecasting.NewCalibrator(history, "site-v1", origin.UnixMilli())) + band := issue.Series[0].Points[0].PVBand + if band.Method != forecasting.BandMethodEmpirical || band.Samples != 56 || band.LowW != 1040 || band.HighW != 1040 { + t.Fatalf("quarter-hour point band = %+v", band) + } +} + +func TestForecastStopDrainsIssuedChampion(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + at := time.Now().UTC() + f := trackerFixture(at) + f.store = st + // Prevent the worker from running until a queued issue exists, then cancel + // immediately. Both queued and in-flight persistence must survive Stop. + if err := st.InitForecastArchive(context.Background()); err != nil { + t.Fatal(err) + } + in := f.Snapshot(at, trackerWeather(at.Add(time.Minute), at)) + slots := trackerSlots(at.Add(time.Minute), 1) + in.Record(slots, slots, "shutdown-decision", at.UnixMilli()) + ctx, cancel := context.WithCancel(context.Background()) + f.cancel = cancel + f.wg = sync.WaitGroup{} + f.wg.Add(1) + cancel() + go func() { defer f.wg.Done(); f.run(ctx) }() + f.Stop() + issues, err := st.LoadForecastIssues(context.Background(), at.Add(-time.Hour).UnixMilli(), at.Add(time.Hour).UnixMilli(), 10) + if err != nil { + t.Fatal(err) + } + if len(issues) != 1 { + t.Fatalf("shutdown lost issued forecast: %d", len(issues)) + } +} +func TestForecastFullHorizonRecordFitsArchive(t *testing.T) { + at := time.Now().UTC().Truncate(15 * time.Minute) + f := trackerFixture(at) + rows := []state.ForecastPoint{} + for h := 0; h < 48; h++ { + rows = append(rows, trackerWeather(at.Add(time.Duration(h)*time.Hour), at)...) + } + in := f.Snapshot(at, rows) + slots := trackerSlots(at, 192) + for i := range slots { + slots[i].LoadW = 1234.567 + float64(i)*0.03 + slots[i].PVW = -2345.678 + } + in.Record(slots, slots, "full-horizon", at.UnixMilli()) + job := <-f.queue + if err := job.issue.Validate(); err != nil { + t.Fatal(err) + } + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + if err = st.InitForecastArchive(context.Background()); err != nil { + t.Fatal(err) + } + if err = st.SaveForecastIssue(context.Background(), job.issue); err != nil { + raw, _ := json.Marshal(job.issue) + t.Fatalf("full horizon archive rejected (%d embedded bytes): %v", len(raw), err) + } + restored, err := st.LoadForecastIssues(context.Background(), at.Add(-time.Hour).UnixMilli(), at.Add(time.Hour).UnixMilli(), 1) + if err != nil || len(restored) != 1 { + t.Fatalf("full horizon unavailable: %v", err) + } + raw, _ := json.Marshal(restored[0]) + t.Logf("stored full horizon JSON bytes=%d", len(raw)) +} +func TestForecastConfigChangeBreaksInterval(t *testing.T) { + f := &forecastTracker{} + site := trackerSite() + start := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + for i := 0; i <= 15; i++ { + if i == 8 { + site.Revision = "changed" + } + at := start.Add(time.Duration(i) * time.Minute) + out := f.observationIntervals(telemetry.ForecastReading{At: at, Latest: at, PVLatest: at, Valid: true, PVValid: true, HouseholdW: 1000, PVW: -2000}, site, at) + if len(out) > 0 { + t.Fatal("interval crosses config revision") + } + } +} +func TestForecastMalformedWeatherDoesNotPoisonArchive(t *testing.T) { + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + f := trackerFixture(at) + rows := trackerWeather(at, at) + rows[0].SolarWm2 = trackerNumber(math.NaN()) + rows[0].CloudCoverPct = nil + in := f.Snapshot(at, rows) + slots := trackerSlots(at, 1) + in.Record(slots, slots, "bad-weather", at.UnixMilli()) + job := <-f.queue + if err := job.issue.Validate(); err != nil { + t.Fatal(err) + } + if job.issue.Series[0].Points[0].PVKnown { + t.Fatal("malformed weather marked as usable PV") + } +} + +func TestForecastDirectPVAndStableModelStateArchive(t *testing.T) { + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + f := trackerFixture(at) + rows := trackerWeather(at, at) + rows[0].Source = "forecast_solar" + slots := trackerSlots(at, 1) + f.Snapshot(at, rows).Record(slots, slots, "first", at.UnixMilli()) + first := <-f.queue + f.Snapshot(at, rows).Record(slots, slots, "second", at.UnixMilli()) + second := <-f.queue + if first.issue.Weather[0].DirectPVW == nil || *first.issue.Weather[0].DirectPVW != 4000 { + t.Fatal("direct forecast power missing from input archive") + } + if string(first.issue.Models[0].State) != string(second.issue.Models[0].State) { + t.Fatal("unchanged model state differs merely because capture time changed") + } +} + +func BenchmarkForecastTrackingFullHorizon(b *testing.B) { + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + f := trackerFixture(at) + rows := []state.ForecastPoint{} + for h := 0; h < 48; h++ { + rows = append(rows, trackerWeather(at.Add(time.Duration(h)*time.Hour), at)...) + } + slots := trackerSlots(at, 192) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + in := f.Snapshot(at, rows) + for _, s := range slots { + _ = in.Load(time.UnixMilli(s.StartMs)) + } + in.Risk(slots, append([]mpc.Slot(nil), slots...), 1) + in.Record(slots, slots, "benchmark", at.UnixMilli()) + <-f.queue + } +} diff --git a/go/cmd/ftw/main.go b/go/cmd/ftw/main.go index 30e4e016..2d908065 100644 --- a/go/cmd/ftw/main.go +++ b/go/cmd/ftw/main.go @@ -19,6 +19,8 @@ import ( "os" "os/signal" "path/filepath" + "reflect" + "runtime" "strconv" "strings" "sync" @@ -569,7 +571,7 @@ func main() { // ask the catalog "is this driver an EV charger / vehicle source?" // rather than sniffing filenames. The Lua DRIVER table's // capabilities list is the driver's self-declaration. - driverCatalog, catErr := drivers.LoadCatalogMulti(*userDriversDirFlag, resolveDriverDir()) + driverCatalog, catErr := drivers.LoadCatalogSources(drivers.CatalogSource{Dir: *userDriversDirFlag, Source: "local"}, drivers.CatalogSource{Dir: config.ManagedDriversDirOverride, Source: "managed"}, drivers.CatalogSource{Dir: resolveDriverDir(), Source: "bundled"}) if catErr != nil || len(driverCatalog) == 0 { slog.Warn("driver catalog load failed; EV-driver classification will be conservative", "err", catErr, "entries", len(driverCatalog)) @@ -733,6 +735,29 @@ func main() { // in place. var pvSvc *pvmodel.Service var forecastSvc *forecast.Service + var forecastConfigMu sync.RWMutex + var ocppSrv *ocpp.Server + forecastSettings := newForecastSiteConfig(st) + forecastSettings.identity = func(name string) (string, bool) { + if id, ok := runningDeviceID(reg, name); ok { + return id, true + } + if ocppSrv != nil { + if ident, ok := ocppSrv.Handler().CurrentIdentity(name); ok { + id := state.ResolveDeviceID(ident.Vendor, ident.Serial, "", "ocpp://"+ident.ID) + return id, id != "" + } + } + return "", false + } + if forecastSettings.Configure(cfg, driverCatalog) { + if err := st.InvalidateWeatherForecasts(); err != nil { + slog.Warn("forecast cache invalidation failed", "err", err) + } + } + forecastCurtail := newForecastCurtailment(reg, st) + forecastCurtail.SetReleaseEvidence(forecastReleaseEvidenceForRegistry(cfg, driverCatalog, reg)) + defer forecastCurtail.Close() // Notifications: pre-declared so the hot-reload Applier can push // fresh config into the provider + rule engine. Constructed // unconditionally below so API handlers always have a live pointer. @@ -825,6 +850,43 @@ func main() { // works because Go closes over the variable, not its value. var loadSvc *loadmodel.Service + // Caller holds forecastConfigMu for a live transition. Keep persisted state + // intact during a short unconfirmed startup; only confirmed live bindings + // may reset or resume models. No cfgMu acquisition occurs on this path. + applyForecastModelBinding := func() { + site := forecastSettings.Snapshot() + heating, rated := forecastSettings.ModelPriors() + if loadSvc != nil { + loadSvc.SetForecastOptions(site.Options) + if !site.IdentityPending { + if err := loadSvc.Reconfigure(site.Meter, site.Options, site.Timezone, site.LearningRevision); err != nil { + slog.Warn("loadmodel configuration not saved", "err", err) + } + loadSvc.SeedHeatingCoef(heating) + } + } + if pvSvc != nil { + pvSvc.SetForecastOptions(site.Options) + if !site.IdentityPending { + pvSvc.SetRated(rated) + pvSvc.Reconfigure(func(t time.Time) float64 { + if !site.HasLocation { + return 0 + } + return forecast.ClearSkyWm2(site.Latitude, site.Longitude, t) + }, site.LearningRevision) + } + } + } + refreshForecastIdentity := func() { + forecastConfigMu.Lock() + defer forecastConfigMu.Unlock() + if forecastSettings.RefreshIdentity(time.Now()) { + applyForecastModelBinding() + registerAllDevices(st, reg) + } + } + // Pre-declared so the hot-reload Applier can call (*ha.Bridge).Reload // when broker / credentials / publish interval change. Constructed // further down once the registry + control callbacks exist; the @@ -850,17 +912,13 @@ func main() { // hot-reload the calendar client (#498). Assigned later (calendar.New). var calSvc *calendar.Service - // Forward-declared so the reload callback can keep the OCPP quarantine - // in step with hot-reloaded loadpoints — adopting a pending charger is - // naming it in a charger entry, and must take effect on the same save. - // Assigned where the OCPP server starts (optional; nil-guarded). - var ocppSrv *ocpp.Server - // ---- Config hot-reload watcher ---- // Named because two callers share it: the fsnotify watcher created // below and POST /api/config (Deps.ConfigApplier), so a config saved // through the API is applied exactly like an edit of the file (#760). applyConfigChange := func(newCfg, oldCfg *config.Config) { + forecastConfigMu.Lock() + defer forecastConfigMu.Unlock() // Restore EV charger password from state.db (not in YAML). if newCfg.EVCharger != nil { if pw, ok := st.LoadConfig("ev_charger_password"); ok { @@ -895,7 +953,7 @@ func main() { // Re-scan the catalog so a hot-edited Lua driver's // capability change is picked up by the EV-classification // filter on the very next reload tick. - reloadCatalog, err := drivers.LoadCatalogMulti(*userDriversDirFlag, resolveDriverDir()) + reloadCatalog, err := drivers.LoadCatalogSources(drivers.CatalogSource{Dir: *userDriversDirFlag, Source: "local"}, drivers.CatalogSource{Dir: config.ManagedDriversDirOverride, Source: "managed"}, drivers.CatalogSource{Dir: resolveDriverDir(), Source: "bundled"}) if err != nil || len(reloadCatalog) == 0 { slog.Warn("driver catalog reload failed; retaining last known catalog", "err", err, "entries", len(reloadCatalog)) @@ -1073,52 +1131,22 @@ func main() { } } - // Weather diff → push live into the PV twin + forecast - // fetcher without a process restart. Users adjust rated PV - // + lat/lon from Settings and expect the change to take - // effect right away. - if newCfg.Weather != nil { - oldLat, oldLon, oldRated := 0.0, 0.0, 0.0 - if oldCfg.Weather != nil { - oldLat = oldCfg.Weather.Latitude - oldLon = oldCfg.Weather.Longitude - oldRated = oldCfg.Weather.PVRatedW - } - newRated := newCfg.Weather.PVRatedW - if newRated > 0 && newRated != oldRated { - if pvSvc != nil { - pvSvc.SetRated(newRated) - } - if forecastSvc != nil { - forecastSvc.RatedPVW = newRated - } - if mpcSvc != nil { - if forecastSvc != nil { - mpcSvc.PVNameplateW = forecast.NameplateW(forecastSvc.RatedPVW, forecastSvc.Arrays) - } else { - mpcSvc.PVNameplateW = newRated - } - } - } - newLat := newCfg.Weather.Latitude - newLon := newCfg.Weather.Longitude - if newLat != oldLat || newLon != oldLon { - if pvSvc != nil { - pvSvc.ClearSky = func(t time.Time) float64 { return forecast.ClearSkyWm2(newLat, newLon, t) } - } - if forecastSvc != nil { - forecastSvc.Lat = newLat - forecastSvc.Lon = newLon - } - slog.Info("weather location updated", "lat", newLat, "lon", newLon) - } + // Forecast workers consume a copied site config. A changed electrical + // boundary or location invalidates the learned state for that boundary. + forecastSettings.Configure(newCfg, reloadCatalog) + // Set the new weather cutoff, then retire old in-flight provider requests + // before any learner binds to the new site/location. + if forecastSvc != nil && !reflect.DeepEqual(newCfg.Weather, oldCfg.Weather) { + forecastSvc.Reconfigure(newCfg.Weather, forecastRatedPVW(newCfg.Weather), "ftw/"+Version+" github.com/srcfl/ftw") } + forecastCurtail.SetReleaseEvidence(forecastReleaseEvidenceForRegistry(newCfg, reloadCatalog, reg)) + applyForecastModelBinding() + } watcher, err := configreload.New(*configPath, cfgMu, cfg, ctrlMu, ctrl, applyConfigChange) if err != nil { slog.Warn("could not start config watcher", "err", err) } else { - watcher.Start() defer watcher.Stop() } @@ -1155,21 +1183,9 @@ func main() { slog.Info("price service started", "zone", priceSvc.Zone, "provider", priceSvc.Provider.Name()) } - // Sum rated PV from all drivers for the forecast estimator - // Prefer explicit config; fall back to heuristic if unset. - ratedPVW := 0.0 - if cfg.Weather != nil && cfg.Weather.PVRatedW > 0 { - ratedPVW = cfg.Weather.PVRatedW - } else { - for _, d := range cfg.Drivers { - if d.BatteryCapacityWh > 0 { - ratedPVW += d.BatteryCapacityWh / 3 - } - } - if ratedPVW == 0 { - ratedPVW = 10000 - } - } + // An optional DC rating seeds the model. Unknown capacity stays unknown + // until measured production establishes it; battery size is unrelated. + ratedPVW := forecastRatedPVW(cfg.Weather) forecastSvc = forecast.FromConfig(cfg.Weather, ratedPVW, st, "ftw/"+Version+" github.com/srcfl/ftw") if forecastSvc != nil { @@ -1197,13 +1213,18 @@ func main() { slotLen = 60 } end := r.SlotTsMs + int64(slotLen)*60*1000 - if nowMs >= r.SlotTsMs && nowMs < end && r.CloudCoverPct != nil { + if nowMs >= r.SlotTsMs && nowMs < end && r.CloudCoverPct != nil && usableTrainingWeather(r, t) && r.FetchedAtMs >= forecastSettings.Snapshot().WeatherSinceMS { return *r.CloudCoverPct, true } } return 0, false } pvSvc = pvmodel.NewService(st, tel, clearSkyFn, cloudFn, ratedPVW) + pvSvc.SetForecastOptions(forecastSettings.Snapshot().Options) + pvSvc.CurtailmentActive = forecastCurtail.Active + if site := forecastSettings.Snapshot(); !site.IdentityPending { + pvSvc.Reconfigure(clearSkyFn, site.LearningRevision) + } pvSvc.Start(ctx) defer pvSvc.Stop() slog.Info("pvmodel started", "rated_w", ratedPVW, "quality", pvSvc.Model().Quality()) @@ -1217,15 +1238,16 @@ func main() { if loadPeakW <= 0 { loadPeakW = 5000 } - // Training ceiling: the main fuse is the one hard limit on what a house - // can actually draw, so a sample above it is a measurement fault rather - // than an unusual hour. Passed separately from loadPeakW — that one is a - // tunable proxy for "typical peak", this one is physics, and deriving - // the second from the first would silently move a safety bound whenever - // somebody retuned the proxy. Zero when no fuse is configured, which - // disables the check rather than inventing a limit. - loadMaxPlausibleW := cfg.Fuse.MaxPowerW() * loadmodel.PlausibleLoadHeadroom - loadSvc = loadmodel.NewService(st, tel, cfg.SiteMeterDriver(), loadPeakW, loadMaxPlausibleW) + // PV and batteries can supply household demand above the grid fuse. + // No independent gross-load ceiling is configured here. + loadSvc = loadmodel.NewService(st, tel, cfg.SiteMeterDriver(), loadPeakW, 0) + forecastSiteAtBoot := forecastSettings.Snapshot() + loadSvc.SetForecastOptions(forecastSiteAtBoot.Options) + if !forecastSiteAtBoot.IdentityPending { + if err := loadSvc.Reconfigure(forecastSiteAtBoot.Meter, forecastSiteAtBoot.Options, forecastSiteAtBoot.Timezone, forecastSiteAtBoot.LearningRevision); err != nil { + slog.Warn("loadmodel configuration not saved", "err", err) + } + } // SeedHeatingCoef — operator config is a cold-start prior. Once the // load model has accumulated samples in production, its // telemetry-fit HeatingW_per_degC survives restart and the config @@ -1248,7 +1270,7 @@ func main() { slotLen = 60 } end := r.SlotTsMs + int64(slotLen)*60*1000 - if nowMs >= r.SlotTsMs && nowMs < end && r.TempC != nil { + if nowMs >= r.SlotTsMs && nowMs < end && r.TempC != nil && usableTrainingWeather(r, t) && r.FetchedAtMs >= forecastSettings.Snapshot().WeatherSinceMS { return *r.TempC, true } } @@ -1452,6 +1474,58 @@ func main() { ocppChargersFn = ocppSrv.Handler().Snapshot } + // Archive observations even when price planning is disabled. The Rust + // candidate runs on a separate worker and never delays physical dispatch. + forecastTrackerSvc := &forecastTracker{refreshIdentity: refreshForecastIdentity, configMu: &forecastConfigMu, store: st, tele: tel, pv: pvSvc, load: loadSvc, + site: func() forecastSite { + site := forecastSettings.Snapshot() + if pvSvc != nil { + model := pvSvc.Model() + site.HasPVScale = site.HasPVScale || model.InferredScaleKnown || model.InferredScaleW > 0 + } + return site + }, + curtailed: func(time.Time) bool { return forecastCurtail.Active() }, + } + if calSvc != nil { + forecastTrackerSvc.away = calSvc.IsAwayAt + } + if energyplanSupported(runtime.GOOS, runtime.GOARCH) { + if candidate, err := newRustForecast(st, resolveEnergyplanBinary()); err != nil { + slog.Warn("forecast candidate unavailable", "err", err) + } else { + forecastTrackerSvc.candidate = candidate + } + } + if err := forecastTrackerSvc.Start(ctx); err != nil { + slog.Warn("forecast archive unavailable", "err", err) + if forecastTrackerSvc.candidate != nil { + _ = forecastTrackerSvc.candidate.Close() + } + forecastTrackerSvc = nil + } else { + defer forecastTrackerSvc.Stop() + } + + // A small live-identity poll also protects legacy learners when MPC is off. + // Config/schema/script work stays in Configure; this only reads host identity. + identityCtx, stopIdentity := context.WithCancel(ctx) + identityDone := make(chan struct{}) + go func() { + defer close(identityDone) + tick := time.NewTicker(time.Second) + defer tick.Stop() + for { + select { + case <-identityCtx.Done(): + return + case <-tick.C: + refreshForecastIdentity() + } + } + }() + defer func() { stopIdentity(); <-identityDone }() + // ---- Start MPC planner (optional) ---- mpcSvc = buildMPC(cfg, st, tel, capacities) if mpcSvc != nil { @@ -1459,12 +1533,10 @@ func main() { // the fuse from the start (instead of producing plans that // dispatch later has to scale via the joint allocator). mpcSvc.FuseMaxW = cfg.Fuse.MaxPowerW() - mpcSvc.LoadMaxW = cfg.Fuse.MaxPowerW() - if forecastSvc != nil { - mpcSvc.PVNameplateW = forecast.NameplateW(forecastSvc.RatedPVW, forecastSvc.Arrays) - } else if ratedPVW > 0 { - mpcSvc.PVNameplateW = ratedPVW - } + // Grid limits remain on grid flow. Neither a DC nameplate nor an + // inferred PV scale proves an inverter's hard AC limit. + mpcSvc.LoadMaxW = 0 + mpcSvc.PVNameplateW = 0 // Cap planned export below the fuse when the operator set a site // export ceiling, so the DP never schedules a discharge that would // over-export and trip an inverter (the Ferroamp 0x8030 fault). @@ -1717,6 +1789,9 @@ func main() { return st.SaveDiagnostic(d.ComputedAtMs, reason, d.Zone, d.TotalCostOre, d.Horizon, string(js)) } + if forecastTrackerSvc != nil { + mpcSvc.ForecastSnapshot = forecastTrackerSvc.Snapshot + } mpcSvc.Start(ctx) defer mpcSvc.Stop() // Inject plan → control.State. Both callbacks are wired: @@ -2646,6 +2721,10 @@ func main() { sigc := make(chan os.Signal, 1) signal.Notify(sigc, os.Interrupt, syscall.SIGTERM) + if watcher != nil { + watcher.Start() + } + ticker := time.NewTicker(controlInterval) defer ticker.Stop() var saveCount uint64 @@ -2784,7 +2863,9 @@ func main() { siteMeterDriver := ctrl.SiteMeterDriver siteFuseAmps := ctrl.SiteFuseAmps siteFusePhases := ctrl.SiteFusePhases + forecastIntent := forecastCurtailmentActive(ctrl, tickNow) ctrlMu.Unlock() + forecastCurtail.ObserveIntent(forecastIntent) freshness := evaluateSiteDispatchFreshnessAt( tel, siteMeterDriver, siteFuseAmps, siteFusePhases, watchdogTimeout, tickNow, ) @@ -2848,7 +2929,7 @@ func main() { // ctrl, so the stored tick has to show the hold already // released rather than one the blocked tick never executed. clearBatteryManualHoldForDispatchBlock(ctrl, ctrlMu) - sampleCount, err := persistTelemetryTick(st, tel, ctrl, nowMs, watchdogTimeout) + sampleCount, err := persistTelemetryTick(st, tel, ctrl, nowMs, watchdogTimeout, forecastSettings.Snapshot().Options) if err != nil { slog.Warn("tick persistence failed", "samples", sampleCount, "err", err) } @@ -2989,12 +3070,19 @@ func main() { // either a `curtail` command (limit > 0) or a one-shot // `curtail_disable` when a previously-curtailed driver // drops out of the active set. + pendingPV := forecastCurtail.PendingDrivers(reg.Names()) ctrlMu.Lock() + for _, name := range pendingPV { + if ctrl.LastCurtailedDrivers == nil { + ctrl.LastCurtailedDrivers = make(map[string]bool) + } + ctrl.LastCurtailedDrivers[name] = true + } curtailTargets := control.ComputePVCurtail(ctrl, tel) ctrlMu.Unlock() // The cap is a dispatch command and its outcome is counted; the // release is not. See pv_curtail_dispatch.go. - dispatchPVCurtail(ctx, reg, actuation, curtailTargets, driverCmdTimeout, tickNow) + dispatchPVCurtail(ctx, forecastCurtail, actuation, curtailTargets, driverCmdTimeout, tickNow) // ---- Solar-surplus feed dispatch ---- // Per-tick hint to drivers whose operator armed a `solar_pv` @@ -3096,7 +3184,7 @@ func main() { // ---- Persist the tick: history snapshot + flushed metrics ---- // One transaction for both — separate commits doubled the WAL // commit rate for no isolation benefit (SD-card wear). - sampleCount, err := persistTelemetryTick(st, tel, ctrl, nowMs, watchdogTimeout) + sampleCount, err := persistTelemetryTick(st, tel, ctrl, nowMs, watchdogTimeout, forecastSettings.Snapshot().Options) if err != nil { slog.Warn("tick persistence failed", "samples", sampleCount, "err", err) } @@ -3372,7 +3460,8 @@ func sendDriverDefault(ctx context.Context, srv *api.Server, name, reason string } cmdCtx, cancel := context.WithTimeout(ctx, driverDefaultTimeout) defer cancel() - if err := srv.SendDriverDefault(cmdCtx, name); err != nil { + err := srv.SendDriverDefault(cmdCtx, name) + if err != nil { slog.Warn("driver default command failed", "name", name, "reason", reason, "timeout", driverDefaultTimeout, "err", err) } @@ -3948,8 +4037,8 @@ func isConfigMissing(err error) bool { return strings.Contains(err.Error(), "no such file") } -func persistTelemetryTick(st *state.Store, tel *telemetry.Store, ctrl *control.State, nowMs int64, historyMaxAge time.Duration) (int, error) { - hp, historyAvailable := buildHistoryPoint(tel, ctrl, nowMs, historyMaxAge) +func persistTelemetryTick(st *state.Store, tel *telemetry.Store, ctrl *control.State, nowMs int64, historyMaxAge time.Duration, options ...telemetry.ForecastOptions) (int, error) { + hp, historyAvailable := buildHistoryPoint(tel, ctrl, nowMs, historyMaxAge, options...) samples := tel.FlushSamples() stSamples := make([]state.Sample, len(samples)) for i, sm := range samples { @@ -3961,8 +4050,7 @@ func persistTelemetryTick(st *state.Store, tel *telemetry.Store, ctrl *control.S energyObservations := buildEnergyObservations(st, tel, ctrl, hp) filtered := energyObservations[:0] for _, observation := range energyObservations { - if !historyAvailable && (observation.AssetKind == state.AssetGridMeter || - observation.AssetKind == state.AssetObservedConsumer) { + if !historyAvailable && observation.AssetKind == state.AssetObservedConsumer { continue } if observation.AssetKind != state.AssetObservedConsumer { @@ -3988,26 +4076,26 @@ func persistTelemetryTick(st *state.Store, tel *telemetry.Store, ctrl *control.S return len(samples), st.RecordTickWithOptionalHistory(historyPoint, stSamples, energyObservations) } -func buildHistoryPoint(tel *telemetry.Store, ctrl *control.State, nowMs int64, historyMaxAge time.Duration) (state.HistoryPoint, bool) { +func buildHistoryPoint(tel *telemetry.Store, ctrl *control.State, nowMs int64, historyMaxAge time.Duration, options ...telemetry.ForecastOptions) (state.HistoryPoint, bool) { unavailable := state.HistoryPoint{TsMs: nowMs} if tel == nil || ctrl == nil || ctrl.SiteMeterDriver == "" { return unavailable, false } - meterHealth := tel.DriverHealth(ctrl.SiteMeterDriver) - if meterHealth == nil || meterHealth.Status == telemetry.StatusOffline { - return unavailable, false - } - meter := tel.Get(ctrl.SiteMeterDriver, telemetry.DerMeter) - if meter == nil { - return unavailable, false + opts := telemetry.ForecastOptions{MaxAge: historyMaxAge} + if len(options) > 0 { + opts = options[0] + opts.MaxAge = historyMaxAge } - if historyMaxAge > 0 && time.UnixMilli(nowMs).Sub(meter.UpdatedAt) > historyMaxAge { + now := time.UnixMilli(nowMs).Add(time.Millisecond - time.Nanosecond) + balance := tel.ForecastMeasurement(now, ctrl.SiteMeterDriver, opts) + if !balance.Valid { return unavailable, false } - now := time.UnixMilli(nowMs) + gridW, pvW, batW := balance.GridW, balance.PVW, balance.BatteryW + evW, v2xW, loadW := balance.EVW, balance.V2XW, balance.HouseholdW readingUsable := func(driver string, updatedAt time.Time) bool { h := tel.DriverHealth(driver) - if h == nil || h.Status == telemetry.StatusOffline { + if !h.TelemetryLive() || updatedAt.After(now) { return false } maxAge := historyMaxAge @@ -4016,50 +4104,17 @@ func buildHistoryPoint(tel *telemetry.Store, ctrl *control.State, nowMs int64, h } return maxAge <= 0 || now.Sub(updatedAt) <= maxAge } - gridW := meter.SmoothedW - var pvW, batW, sumSoC float64 + var avgSoC, sumSoC float64 var socCount int - for _, r := range tel.ReadingsByType(telemetry.DerPV) { - if !readingUsable(r.Driver, r.UpdatedAt) { - continue - } - pvW += r.SmoothedW - } for _, r := range tel.ReadingsByType(telemetry.DerBattery) { - if !readingUsable(r.Driver, r.UpdatedAt) { - continue - } - batW += r.SmoothedW - if r.SoC != nil { + if readingUsable(r.Driver, r.UpdatedAt) && r.SoC != nil { sumSoC += *r.SoC socCount++ } } - avgSoC := 0.0 if socCount > 0 { avgSoC = sumSoC / float64(socCount) } - var evW, v2xW float64 - for _, r := range tel.ReadingsByType(telemetry.DerEV) { - if readingUsable(r.Driver, r.UpdatedAt) { - evW += r.SmoothedW - } - } - for _, r := range tel.ReadingsByType(telemetry.DerV2X) { - if readingUsable(r.Driver, r.UpdatedAt) { - v2xW += r.SmoothedW - } - } - if evW > -1 && evW < 1 { - evW = 0 - } - if v2xW > -1 && v2xW < 1 { - v2xW = 0 - } - loadW := gridW - batW - pvW - evW - v2xW - if loadW < 0 { - loadW = 0 - } // Per-driver detail packed into the JSON column. The schema is // schema-less by design — UI code reads what it understands and @@ -4105,11 +4160,12 @@ func buildHistoryPoint(tel *telemetry.Store, ctrl *control.State, nowMs int64, h targets[t.Driver] = t.TargetW } jsonBlob, _ := json.Marshal(map[string]any{ - "drivers": perDriver, - "targets": targets, - "ev_w": evW, - "v2x_w": v2xW, - "load_house_w": loadW, + "drivers": perDriver, + "targets": targets, + "ev_w": evW, + "v2x_w": v2xW, + "load_house_w": loadW, + "forecast_measurement_quality": "complete_instantaneous_balance_v1", }) return state.HistoryPoint{ TsMs: nowMs, GridW: gridW, PVW: pvW, BatW: batW, LoadW: loadW, BatSoC: avgSoC, diff --git a/go/internal/api/api_ev_replan_ack_test.go b/go/internal/api/api_ev_replan_ack_test.go index 3b868ae0..6cb81e94 100644 --- a/go/internal/api/api_ev_replan_ack_test.go +++ b/go/internal/api/api_ev_replan_ack_test.go @@ -10,6 +10,7 @@ import ( "time" "github.com/srcfl/ftw/go/internal/loadpoint" + "github.com/srcfl/ftw/go/internal/state" ) func TestEVSettingsAcknowledgeWhilePlanIsBlocked(t *testing.T) { @@ -21,6 +22,12 @@ func TestEVSettingsAcknowledgeWhilePlanIsBlocked(t *testing.T) { } { t.Run(tc.name, func(t *testing.T) { srv, mgr, svc := newScheduleServer(t) + now := time.Now().UTC().Truncate(15 * time.Minute) + cloud := 0.0 + if err := svc.Store.SaveForecasts([]state.ForecastPoint{{SlotTsMs: now.UnixMilli(), SlotLenMin: 60, + CloudCoverPct: &cloud, Source: "test", FetchedAtMs: now.UnixMilli()}}); err != nil { + t.Fatal(err) + } mgr.SetSchedule("garage", loadpoint.Schedule{SoC: .7, TimeOfDayMinUTC: 360}) mgr.SetSurplusOnly("garage", true) entered, release := make(chan struct{}), make(chan struct{}) diff --git a/go/internal/config/config.go b/go/internal/config/config.go index 061094a0..96e2c23c 100644 --- a/go/internal/config/config.go +++ b/go/internal/config/config.go @@ -1382,11 +1382,9 @@ type Weather struct { Longitude float64 `yaml:"longitude" json:"longitude"` APIKey string `yaml:"api_key,omitempty" json:"api_key,omitempty"` - // PVRatedW is the system's nameplate PV output (W) — used as the - // initial twin prior AND the ceiling for naive PV estimates. If 0, - // we fall back to a heuristic (sum of battery_capacity_wh / 3), - // which is only roughly right for homes where PV and storage were - // sized together. Set explicitly for accurate day-1 forecasts. + // PVRatedW is an optional DC nameplate prior for weather conversion and + // cold start. Zero leaves scale unknown until telemetry establishes it. + // It is not a verified inverter AC limit. PVRatedW float64 `yaml:"pv_rated_w,omitempty" json:"pv_rated_w,omitempty"` // PVTiltDeg / PVAzimuthDeg describe the physical orientation of a diff --git a/go/internal/control/forecast_scenarios_test.go b/go/internal/control/forecast_scenarios_test.go index a689ab0c..8894200c 100644 --- a/go/internal/control/forecast_scenarios_test.go +++ b/go/internal/control/forecast_scenarios_test.go @@ -16,14 +16,17 @@ package control // Run: go test -run TestForecastScenarios -v ./go/internal/control import ( + "context" "fmt" "math" + "path/filepath" "strings" "testing" "time" "github.com/srcfl/ftw/go/internal/loadmodel" "github.com/srcfl/ftw/go/internal/mpc" + "github.com/srcfl/ftw/go/internal/state" "github.com/srcfl/ftw/go/internal/telemetry" ) @@ -32,10 +35,10 @@ import ( // makeSeedStore builds a telemetry.Store with a site meter and N batteries. // The battery slice uses a named struct for clarity at call sites. type batterySetup struct { - name string - currentW float64 - soc float64 - online bool // if false: only Update is called, health.SetOffline() + name string + currentW float64 + soc float64 + online bool // if false: only Update is called, health.SetOffline() } func makeSeedStore(gridW float64, pvW float64, batteries []batterySetup) *telemetry.Store { @@ -372,97 +375,69 @@ func TestScenario_B12_StalePlan_FallsBackToSelfConsumption(t *testing.T) { assertSign(t, "B12", targets, "discharge") } -// ---- C. PV forecast cap (T33 scenarios) --------------------------------- -// -// These are pure unit tests of selectPlannerPVW which is unexported. We test -// the visible property: the scenarios that exercise the cap logic used by -// buildSlots. Since selectPlannerPVW is package-private inside mpc, we -// exercise it indirectly by verifying the published constants and then -// confirming the arithmetic as in the existing mpc package tests. The -// scenarios below are purposely duplicated here in a condensed form to anchor -// the dispatch-boundary tests in case mpc internals move. - -// C13. NWP forecast 5× twin + twin>50 W → cap activates (T33 core regression). -// Verify the arithmetic matches: capped = 3×twin, result = 0.7×capped + 0.3×twin. -func TestScenario_C13_ForecastCap_ActivatesWhenNWP5xTwin(t *testing.T) { - forecast := 2002.0 - twin := 290.0 - got := selectPlannerPVW(forecast, twin, true) - - cappedForecast := mpc.PlannerForecastCapRatio * twin - want := (1-mpc.PlannerRadiationWeight)*cappedForecast + mpc.PlannerRadiationWeight*twin - if math.Abs(got-want) > 0.5 { - t.Errorf("C13: selectPlannerPVW(%.0f, %.0f, true) = %.1f, want %.1f (capped at 3×twin)", - forecast, twin, got, want) - } - // Capped result must be materially less than uncapped. - uncapped := (1-mpc.PlannerRadiationWeight)*forecast + mpc.PlannerRadiationWeight*twin - if got >= uncapped { - t.Errorf("C13: capped %.1f should be < uncapped %.1f", got, uncapped) - } -} - -// C14. NWP forecast 2× twin + twin>50 W → cap does NOT activate. -func TestScenario_C14_ForecastCap_InactiveWhenRatioOK(t *testing.T) { - forecast := 4000.0 - twin := 2000.0 // 2× — below cap threshold of 3× - got := selectPlannerPVW(forecast, twin, true) - want := (1-mpc.PlannerRadiationWeight)*forecast + mpc.PlannerRadiationWeight*twin - if math.Abs(got-want) > 0.01 { - t.Errorf("C14: cap must be inactive when forecast/twin=2×; got %.2f want %.2f", got, want) - } -} - -// C15. NWP forecast 5× twin + twin=10 W (low signal) → cap does NOT activate. -func TestScenario_C15_ForecastCap_InactiveWhenTwinNearZero(t *testing.T) { - forecast := 300.0 - twin := 10.0 // below 50 W threshold - got := selectPlannerPVW(forecast, twin, true) - want := (1-mpc.PlannerRadiationWeight)*forecast + mpc.PlannerRadiationWeight*twin - if math.Abs(got-want) > 0.01 { - t.Errorf("C15: cap must be inactive when twin < 50 W; got %.2f want %.2f", got, want) - } -} - -// C16. NWP forecast=0 (night) + radiation flag → falls through, twin used. -func TestScenario_C16_ForecastCap_NightForecastZero_TwinPassesThrough(t *testing.T) { - // Per the implementation: forecast < 200 threshold → use twin directly. - forecast := 0.0 - twin := 300.0 // twin (probably garbage at night, but illustrates the logic) - got := selectPlannerPVW(forecast, twin, true) - if got != twin { - t.Errorf("C16: night forecast=0 should fall through to twin=%g, got %.2f", twin, got) - } -} - -// selectPlannerPVW is wired into mpc.Service.buildSlots. Since it is -// package-private in mpc, we reach it via the exported test adapter below -// which wraps the same arithmetic. The control package only needs to verify -// the constants are stable and the three dispatch tests above. The full -// matrix of selectPlannerPVW edge cases lives in mpc/service_test.go. -func selectPlannerPVW(forecastPVW, predictedPVW float64, radiationBacked bool) float64 { - // Mirror of mpc.selectPlannerPVW for use in this package's tests. - // Kept in sync via constants from the mpc package. - if math.IsNaN(predictedPVW) || math.IsInf(predictedPVW, 0) || predictedPVW < 0 { - if math.IsNaN(forecastPVW) || math.IsInf(forecastPVW, 0) { - return 0 - } - return forecastPVW +// ---- C. PV forecast trust ---------------------------------------------- +// Exercise the published planner path. The dispatch scenarios above retain +// their live power and fuse checks independently of forecast quality. + +func TestScenario_C13_ForecastTrust_ColdModelCannotCapProvider(t *testing.T) { + got := scenarioPlannerPV(t, 2002, 290, 0) + if math.Abs(got-2002) > 0.01 { + t.Fatalf("untrusted model capped provider: got %.2fW", got) } - if !radiationBacked { - if math.IsNaN(forecastPVW) || math.IsInf(forecastPVW, 0) || forecastPVW < 200 { - return predictedPVW - } - return predictedPVW + got = scenarioPlannerPV(t, 2002, 290, mpc.PlannerRadiationWeight) + if math.Abs(got-1488.4) > 0.01 { + t.Fatalf("trusted model blend = %.2fW, want 1488.4W", got) + } +} + +func TestScenario_C14_ForecastTrust_ContinuousAcrossFormerCap(t *testing.T) { + below := scenarioPlannerPV(t, 6000, 1999, mpc.PlannerRadiationWeight) + above := scenarioPlannerPV(t, 6000, 2001, mpc.PlannerRadiationWeight) + if math.Abs((above-below)-0.6) > 0.01 { + t.Fatalf("two model watts caused a forecast jump: %.2f -> %.2f", below, above) + } +} + +func TestScenario_C15_ForecastTrust_LowOutputStillBlends(t *testing.T) { + got := scenarioPlannerPV(t, 300, 10, mpc.PlannerRadiationWeight) + if math.Abs(got-213) > 0.01 { + t.Fatalf("low output blend = %.2fW, want 213W", got) + } +} + +func TestScenario_C16_ForecastTrust_RadiationZeroStaysZero(t *testing.T) { + got := scenarioPlannerPV(t, 0, 300, mpc.PlannerRadiationWeight) + if got != 0 { + t.Fatalf("zero radiation forecast created %.2fW generation", got) + } +} + +func scenarioPlannerPV(t *testing.T, providerW, learnedW, weight float64) float64 { + t.Helper() + st, err := state.Open(filepath.Join(t.TempDir(), "forecast.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + now := time.Now() + start := now.Truncate(15 * time.Minute).Add(15 * time.Minute) + if err = st.SavePrices([]state.PricePoint{{Zone: "test", SlotTsMs: start.UnixMilli(), SlotLenMin: 15, SpotOreKwh: 100, TotalOreKwh: 100, FetchedAtMs: now.UnixMilli()}}); err != nil { + t.Fatal(err) } - if math.IsNaN(forecastPVW) || math.IsInf(forecastPVW, 0) || forecastPVW < 200 { - return predictedPVW + radiation := 500.0 + weather := []state.ForecastPoint{{SlotTsMs: start.UnixMilli(), SlotLenMin: 15, PVWEstimated: &providerW, SolarWm2: &radiation, Source: "test", FetchedAtMs: now.UnixMilli()}} + tel := makeSeedStore(0, 0, []batterySetup{{name: "battery", soc: .5, online: true}}) + params := mpc.Params{Mode: mpc.ModeSelfConsumption, SoCLevels: 11, CapacityWh: 10000, SoCMin: .1, SoCMax: .9, InitialSoC: .5, ActionLevels: 11, MaxChargeW: 3000, MaxDischargeW: 3000, ChargeEfficiency: .95, DischargeEfficiency: .95} + svc := mpc.New(st, tel, "test", params) + svc.Horizon = time.Hour + var built []mpc.Slot + svc.ForecastSnapshot = func(time.Time, []state.ForecastPoint) mpc.ForecastInputs { + return mpc.ForecastInputs{Weather: weather, PV: func(time.Time, float64) float64 { return learnedW }, PVWeight: func(time.Time) float64 { return weight }, Load: func(time.Time) float64 { return 1000 }, Record: func(base, planning []mpc.Slot, _ string, _ int64) { built = append([]mpc.Slot(nil), base...) }} } - cappedForecast := forecastPVW - if predictedPVW > 50 && forecastPVW > mpc.PlannerForecastCapRatio*predictedPVW { - cappedForecast = mpc.PlannerForecastCapRatio * predictedPVW + if svc.Replan(context.Background()) == nil || len(built) != 1 { + t.Fatalf("planner did not publish one forecast slot: %d", len(built)) } - return (1-mpc.PlannerRadiationWeight)*cappedForecast + mpc.PlannerRadiationWeight*predictedPVW + return -built[0].PVW } // ---- D. Load model bucket repair (T32 scenarios) ----------------------- @@ -573,9 +548,8 @@ func TestScenario_D20_LoadModel_HealthyBucket_Preserved_UnderColdTraining(t *tes } // D21. Bucket above floor (mean = prior×0.50) must not be repaired. -// Verifies the 25% floor is conservative — only truly poisoned buckets are reset. -// We simulate this by poisoning to 30% (above floor) and verifying the prediction -// stays at the poisoned level rather than resetting. +// Check the bucket itself: a cold prediction also includes the prior until +// independent training days earn trust. func TestScenario_D21_LoadModel_AboveFloor_NotRepaired(t *testing.T) { m := loadmodel.NewModel(5000) now := time.Date(2026, 3, 12, 6, 0, 0, 0, time.UTC) @@ -595,14 +569,11 @@ func TestScenario_D21_LoadModel_AboveFloor_NotRepaired(t *testing.T) { if pred > prior*1.1 { t.Errorf("D21: prediction %.0f > prior %.0f — something auto-reset the bucket it shouldn't have", pred, prior) } - // After a couple of normal warm-weather samples the EMA moves toward real load - // rather than snapping to the prior. This distinguishes "not repaired" from - // "repaired to prior". + // A matching warm sample must preserve the observed baseline. Minute sample + // count alone does not earn prediction trust under the day-weighted model. m.Update(now.AddDate(0, 0, 7), prior*0.50, loadmodel.HeatingReferenceC) - postPred := m.Predict(now, loadmodel.HeatingReferenceC) - // postPred should be in the neighborhood of the 50% value, not at full prior. - if postPred > prior*0.85 { - t.Errorf("D21: bucket at 50%% prior should not snap to full prior after one sample; got %.0f, prior %.0f", postPred, prior) + if got := m.Bucket[idx].Mean; math.Abs(got-prior*0.5) > 0.01 { + t.Errorf("D21: matching sample changed half-prior baseline to %.0f, prior %.0f", got, prior) } } @@ -882,11 +853,11 @@ func TestForecastScenarios(t *testing.T) { {"B10_ChargeMode_NearFull_ClampedAtSoC", TestScenario_B10_ChargeMode_NearFull_ClampedAtSoC}, {"B11_PlannerSelf_EmptyBattery_NoDischarge", TestScenario_B11_PlannerSelf_EmptyBattery_NoDischarge}, {"B12_StalePlan_FallsBackToSelfConsumption", TestScenario_B12_StalePlan_FallsBackToSelfConsumption}, - // C. PV forecast cap - {"C13_ForecastCap_Activates", TestScenario_C13_ForecastCap_ActivatesWhenNWP5xTwin}, - {"C14_ForecastCap_InactiveRatioOK", TestScenario_C14_ForecastCap_InactiveWhenRatioOK}, - {"C15_ForecastCap_InactiveTwinNearZero", TestScenario_C15_ForecastCap_InactiveWhenTwinNearZero}, - {"C16_ForecastCap_Night", TestScenario_C16_ForecastCap_NightForecastZero_TwinPassesThrough}, + // C. PV forecast trust + {"C13_ForecastTrust_ColdModel", TestScenario_C13_ForecastTrust_ColdModelCannotCapProvider}, + {"C14_ForecastTrust_Continuous", TestScenario_C14_ForecastTrust_ContinuousAcrossFormerCap}, + {"C15_ForecastTrust_LowOutput", TestScenario_C15_ForecastTrust_LowOutputStillBlends}, + {"C16_ForecastTrust_RadiationZero", TestScenario_C16_ForecastTrust_RadiationZeroStaysZero}, // D. Load model bucket repair {"D17_LoadModel_HeatGtLoad_NoBucketUpdate", TestScenario_D17_LoadModel_HeatGtLoad_BucketNotUpdated}, {"D18_LoadModel_HeatLtLoad_BucketUpdated", TestScenario_D18_LoadModel_HeatLtLoad_BucketUpdated}, diff --git a/go/internal/energyforecast/client.go b/go/internal/energyforecast/client.go new file mode 100644 index 00000000..d334c312 --- /dev/null +++ b/go/internal/energyforecast/client.go @@ -0,0 +1,437 @@ +package energyforecast + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "math" + "strings" + "time" + "unicode" +) + +const DefaultTimeout = 5 * time.Second +const MaxTimeout = 30 * time.Second + +type Client struct { + transport RoundTripper + // Timeout may be set at construction. Calls always enforce MaxTimeout. + Timeout time.Duration +} + +func NewClient(transport RoundTripper) *Client { + return &Client{transport: transport, Timeout: DefaultTimeout} +} + +type workerError struct{ detail string } + +func (e workerError) Error() string { return "forecast worker rejected request: " + e.detail } + +func (c *Client) Update(ctx context.Context, request UpdateRequest) (UpdateReply, error) { + var reply UpdateReply + if err := validateContext(request.RequestContext); err != nil { + return reply, err + } + if len(request.Observations) > MaxObservations { + return reply, errors.New("forecast update accepts at most 4096 observations") + } + if request.Observations == nil { + request.Observations = []Observation{} + } + var previousEnd int64 + for i, o := range request.Observations { + if err := validateInterval(o.Interval); err != nil { + return reply, fmt.Errorf("observation %d: %w", i, err) + } + if o.ValidEndMs-o.ValidStartMs != 900000 { + return reply, errors.New("forecast observation must cover a complete quarter-hour") + } + if i > 0 && o.ValidStartMs < previousEnd { + return reply, errors.New("forecast observations overlap or are out of order") + } + previousEnd = o.ValidEndMs + if o.AvailableAtMs < o.ValidEndMs || o.AvailableAtMs > request.OriginMs { + return reply, errors.New("forecast observation was not available at origin") + } + if err := validateFeatures(o.Features, request.OriginMs); err != nil { + return reply, fmt.Errorf("observation %d: %w", i, err) + } + for _, signal := range []struct { + value *float64 + quality ObservationQuality + }{{o.PVAvailableW, o.PVQuality}, {o.HouseholdLoadW, o.LoadQuality}} { + if !validObservationQuality(signal.quality) { + return reply, errors.New("forecast observation needs explicit quality") + } + if signal.value != nil && (!finite(*signal.value) || *signal.value < 0) { + return reply, errors.New("forecast observation power must be finite and nonnegative") + } + if signal.value == nil && (signal.quality == QualityGood || signal.quality == QualityClipped) { + return reply, errors.New("good forecast observation has no measured power") + } + } + } + payload := struct { + Op string `json:"op"` + Version int `json:"version"` + Action string `json:"action"` + UpdateRequest + }{"forecast", ProtocolVersion, "update", request} + if err := c.call(ctx, payload, request.RequestContext, "update", &reply); err != nil { + return UpdateReply{}, err + } + if err := validateState(reply.State, true); err != nil { + return UpdateReply{}, err + } + if err := validateCounts(reply.Updates.PV, request.Config.PV != nil, len(request.Observations)); err != nil { + return UpdateReply{}, err + } + if err := validateCounts(reply.Updates.Load, request.Config.Load != nil, len(request.Observations)); err != nil { + return UpdateReply{}, err + } + return reply, nil +} + +func (c *Client) Predict(ctx context.Context, request PredictRequest) (PredictReply, error) { + var reply PredictReply + if err := validateContext(request.RequestContext); err != nil { + return reply, err + } + if len(request.Horizon) == 0 || len(request.Horizon) > MaxHorizon { + return reply, errors.New("forecast predict needs 1..512 intervals") + } + var previousEnd int64 + for i, slot := range request.Horizon { + if err := validateInterval(slot.Interval); err != nil { + return reply, fmt.Errorf("horizon %d: %w", i, err) + } + if slot.ValidStartMs < request.OriginMs || (i > 0 && slot.ValidStartMs < previousEnd) { + return reply, errors.New("forecast horizon is past, overlapping or out of order") + } + previousEnd = slot.ValidEndMs + if err := validateFeatures(slot.Features, request.OriginMs); err != nil { + return reply, fmt.Errorf("horizon %d: %w", i, err) + } + } + payload := struct { + Op string `json:"op"` + Version int `json:"version"` + Action string `json:"action"` + PredictRequest + }{"forecast", ProtocolVersion, "predict", request} + if err := c.call(ctx, payload, request.RequestContext, "predict", &reply); err != nil { + return PredictReply{}, err + } + for _, latest := range []*int64{reply.LatestTrainingMs.PV, reply.LatestTrainingMs.Load} { + if latest != nil && (*latest < 0 || *latest > request.OriginMs) { + return PredictReply{}, errors.New("forecast reply contains future training") + } + } + if len(reply.Predictions) != len(request.Horizon) { + return PredictReply{}, errors.New("forecast reply has wrong interval count") + } + for _, latest := range []*int64{reply.LatestInputMs.PV, reply.LatestInputMs.Load} { + if latest != nil && (*latest < 0 || *latest > request.OriginMs) { + return PredictReply{}, errors.New("forecast reply contains future model inputs") + } + } + for i, p := range reply.Predictions { + if p.Interval != request.Horizon[i].Interval { + return PredictReply{}, fmt.Errorf("forecast reply interval %d does not match request", i) + } + if (p.PV != nil) != (request.Config.PV != nil) || (p.Load != nil) != (request.Config.Load != nil) { + return PredictReply{}, errors.New("forecast reply changed requested model set") + } + if err := validateEstimate(p.PV); err != nil { + return PredictReply{}, fmt.Errorf("PV interval %d: %w", i, err) + } + if err := validateEstimate(p.Load); err != nil { + return PredictReply{}, fmt.Errorf("load interval %d: %w", i, err) + } + } + return reply, nil +} + +func (c *Client) call(ctx context.Context, request any, expected RequestContext, action string, reply any) error { + if c == nil || c.transport == nil { + return errors.New("forecast worker unavailable") + } + payload, err := json.Marshal(request) + if err != nil { + return fmt.Errorf("encode forecast request: %w", err) + } + if len(payload)+1 > MaxPayloadBytes { + return errors.New("forecast request exceeds 2 MiB") + } + timeout := c.Timeout + if timeout <= 0 { + timeout = DefaultTimeout + } + if timeout > MaxTimeout { + timeout = MaxTimeout + } + bounded, cancel := context.WithTimeout(ctx, timeout) + defer cancel() + if err := bounded.Err(); err != nil { + return err + } + line, err := c.transport.RoundTrip(bounded, payload) + if err != nil { + return fmt.Errorf("forecast worker exchange: %w", err) + } + if err := bounded.Err(); err != nil { + return err + } + if len(line) > MaxPayloadBytes { + return errors.New("forecast reply exceeds 2 MiB") + } + var fields map[string]json.RawMessage + if err := json.Unmarshal(line, &fields); err != nil { + return fmt.Errorf("decode forecast reply: %w", err) + } + for _, name := range []string{"op", "version", "action", "request_id", "site_id", "config_revision", "origin_ms", "ok"} { + if raw, ok := fields[name]; !ok || bytes.Equal(raw, []byte("null")) { + return fmt.Errorf("forecast reply missing %s", name) + } + } + var echo ReplyContext + if err := json.Unmarshal(line, &echo); err != nil { + return fmt.Errorf("decode forecast reply: %w", err) + } + if echo.Op != "forecast" || echo.Version != ProtocolVersion || echo.Action != action || echo.RequestID != expected.RequestID || echo.SiteID != expected.SiteID || echo.ConfigRevision != expected.ConfigRevision || echo.OriginMs != expected.OriginMs { + return errors.New("forecast reply identity does not match request") + } + if !echo.OK { + detail := string(echo.Error) + if len(detail) > 512 { + detail = detail[:512] + } + if detail == "" || detail == "null" { + detail = "unspecified error" + } + return workerError{detail} + } + if raw, ok := fields["model_revision"]; !ok || bytes.Equal(raw, []byte("null")) { + return errors.New("forecast reply lacks a model revision") + } + if len(echo.Error) > 0 && !bytes.Equal(echo.Error, []byte("null")) { + return errors.New("successful forecast reply also has an error") + } + if action == "predict" { + for _, name := range []string{"state", "updates"} { + if _, ok := fields[name]; ok { + return fmt.Errorf("predict reply unexpectedly contains %s", name) + } + } + } else if _, ok := fields["predictions"]; ok { + return errors.New("update reply unexpectedly contains predictions") + } + for _, name := range []string{"latest_input_ms", "latest_training_ms", "latest_available_at_ms"} { + raw, ok := fields[name] + if !ok || bytes.Equal(raw, []byte("null")) { + return fmt.Errorf("forecast reply missing %s", name) + } + var clocks map[string]json.RawMessage + if err := json.Unmarshal(raw, &clocks); err != nil { + return fmt.Errorf("forecast reply invalid %s", name) + } + for signal, enabled := range map[string]bool{"pv": expected.Config.PV != nil, "load": expected.Config.Load != nil} { + if enabled { + if _, ok := clocks[signal]; !ok { + return fmt.Errorf("forecast reply missing %s.%s", name, signal) + } + } + } + } + for _, pair := range [][3]*int64{{echo.LatestInputMs.PV, echo.LatestAvailableAtMs.PV, echo.LatestTrainingMs.PV}, {echo.LatestInputMs.Load, echo.LatestAvailableAtMs.Load, echo.LatestTrainingMs.Load}} { + for _, latest := range pair { + if latest != nil && (*latest < 0 || *latest > expected.OriginMs) { + return errors.New("forecast reply contains future model inputs") + } + } + if pair[0] != nil && pair[1] != nil && *pair[1] < *pair[0] { + return errors.New("model availability precedes latest input") + } + if (pair[0] == nil) != (pair[1] == nil) { + return errors.New("model input and availability metadata disagree") + } + if pair[2] != nil && (pair[0] == nil || *pair[2] > *pair[0]) { + return errors.New("model training exceeds latest input") + } + } + if expected.Config.PV == nil && (echo.LatestInputMs.PV != nil || echo.LatestAvailableAtMs.PV != nil || echo.LatestTrainingMs.PV != nil) { + return errors.New("forecast reply includes unrequested PV metadata") + } + if expected.Config.Load == nil && (echo.LatestInputMs.Load != nil || echo.LatestAvailableAtMs.Load != nil || echo.LatestTrainingMs.Load != nil) { + return errors.New("forecast reply includes unrequested load metadata") + } + if action == "predict" { + for _, name := range []string{"predictions"} { + if _, ok := fields[name]; !ok { + return fmt.Errorf("forecast reply missing %s", name) + } + } + } + if err := json.Unmarshal(line, reply); err != nil { + return fmt.Errorf("decode forecast payload: %w", err) + } + return nil +} + +func finite(x float64) bool { return !math.IsNaN(x) && !math.IsInf(x, 0) } + +func validID(s string) bool { + return strings.TrimSpace(s) != "" && len(s) <= 128 && strings.IndexFunc(s, unicode.IsControl) < 0 +} + +func validateContext(r RequestContext) error { + if !validID(r.RequestID) || !validID(r.SiteID) || !validID(r.ConfigRevision) || r.OriginMs < 0 { + return errors.New("forecast request needs bounded site, revision, request ID and valid origin") + } + + if r.Config.PV == nil && r.Config.Load == nil { + return errors.New("forecast request has no configured model") + } + if p := r.Config.PV; p != nil { + if !finite(p.LatitudeDeg) || math.Abs(p.LatitudeDeg) > 90 || !finite(p.LongitudeDeg) || math.Abs(p.LongitudeDeg) > 180 || (p.ACLimitW != nil && (!finite(*p.ACLimitW) || *p.ACLimitW <= 0)) { + return errors.New("forecast PV config has invalid coordinates or AC limit") + } + } + return validateState(r.State, false) +} + +func validateState(state json.RawMessage, required bool) error { + if len(state) == 0 { + if required { + return errors.New("forecast update reply has no state") + } + return nil + } + if len(state) > MaxStateBytes || !json.Valid(state) { + return errors.New("forecast state is invalid or exceeds 1 MiB") + } + s := bytes.TrimSpace(state) + if len(s) == 0 || s[0] != '{' { + return errors.New("forecast state must be an opaque JSON object") + } + return nil +} + +func validateInterval(i Interval) error { + if i.ValidStartMs < 0 || i.ValidEndMs <= i.ValidStartMs || i.ValidEndMs-i.ValidStartMs != 900000 || i.ValidStartMs%900000 != 0 { + return errors.New("invalid forecast interval") + } + return nil +} + +func validateFeatures(f Features, origin int64) error { + if f.LocalDay < -1 || f.LocalDay > 3000000 || f.LocalWeekday < 0 || f.LocalWeekday > 6 || f.LocalMinute < 0 || f.LocalMinute >= 1440 || f.LocalMinute%15 != 0 || int((f.LocalDay+3)%7) != f.LocalWeekday { + return errors.New("invalid local calendar features") + } + weather := f.GHIWm2 != nil || f.CloudPct != nil || f.TempC != nil + if weather && f.WeatherAvailableAtMs == nil { + return errors.New("weather input lacks availability time") + } + if f.WeatherAvailableAtMs != nil && (*f.WeatherAvailableAtMs < 0 || *f.WeatherAvailableAtMs > origin) { + return errors.New("weather was not available at forecast origin") + } + if f.GHIWm2 != nil && (!finite(*f.GHIWm2) || *f.GHIWm2 < 0 || *f.GHIWm2 > 3000) { + return errors.New("invalid GHI") + } + if f.CloudPct != nil && (!finite(*f.CloudPct) || *f.CloudPct < 0 || *f.CloudPct > 100) { + return errors.New("invalid cloud cover") + } + if f.TempC != nil && (!finite(*f.TempC) || *f.TempC < -100 || *f.TempC > 80) { + return errors.New("invalid temperature") + } + return nil +} + +func validObservationQuality(q ObservationQuality) bool { + switch q { + case QualityGood, QualityMissing, QualityStale, QualityIncomplete, QualityCurtailed, QualityClipped: + return true + } + return false +} + +func validateCounts(c *UpdateCount, enabled bool, total int) error { + if (c != nil) != enabled { + return errors.New("forecast update changed requested model set") + } + if c != nil && (c.Applied < 0 || c.Skipped < 0 || c.Applied > total || c.Skipped > total || c.Applied+c.Skipped != total) { + return errors.New("forecast update returned invalid counts") + } + return nil +} + +func (c *UpdateCount) UnmarshalJSON(data []byte) error { + type plain UpdateCount + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + for _, name := range []string{"applied", "skipped"} { + if raw, ok := fields[name]; !ok || bytes.Equal(raw, []byte("null")) { + return fmt.Errorf("forecast update missing %s count", name) + } + } + return json.Unmarshal(data, (*plain)(c)) +} + +func (e *Estimate) UnmarshalJSON(data []byte) error { + type plain Estimate + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + for _, name := range []string{"known", "quality", "uncertainty", "coverage"} { + if raw, ok := fields[name]; !ok || bytes.Equal(raw, []byte("null")) { + return fmt.Errorf("forecast estimate missing %s", name) + } + } + return json.Unmarshal(data, (*plain)(e)) +} + +func validateEstimate(e *Estimate) error { + if e == nil { + return nil + } + if !finite(e.Coverage) || e.Coverage < 0 || e.Coverage > 1 { + return errors.New("invalid forecast coverage") + } + switch e.Quality { + case "unknown", "cold_start", "learning", "ready": + default: + return errors.New("invalid forecast quality") + } + if e.Uncertainty != "unavailable" && e.Uncertainty != "provisional" { + return errors.New("forecast uncertainty is not supported") + } + for _, p := range []*float64{e.PointW, e.LowerW, e.UpperW} { + if p != nil && (!finite(*p) || *p < 0) { + return errors.New("forecast power must be finite and nonnegative") + } + } + if !e.Known { + if e.PointW != nil || e.LowerW != nil || e.UpperW != nil || e.Uncertainty != "unavailable" || (e.Quality != "unknown" && e.Quality != "cold_start") { + return errors.New("unknown forecast contains a point or claimed uncertainty") + } + return nil + } + if e.PointW == nil || e.Quality == "unknown" { + return errors.New("known forecast has no point") + } + if (e.LowerW == nil) != (e.UpperW == nil) { + return errors.New("incomplete forecast bounds") + } + if e.Uncertainty == "provisional" && e.LowerW == nil { + return errors.New("provisional forecast lacks bounds") + } + if e.LowerW != nil && (*e.LowerW > *e.PointW || *e.PointW > *e.UpperW || e.Uncertainty != "provisional") { + return errors.New("invalid forecast bounds") + } + return nil +} diff --git a/go/internal/energyforecast/client_test.go b/go/internal/energyforecast/client_test.go new file mode 100644 index 00000000..f0856629 --- /dev/null +++ b/go/internal/energyforecast/client_test.go @@ -0,0 +1,284 @@ +package energyforecast + +import ( + "context" + "encoding/json" + "errors" + "math" + "strings" + "testing" + "time" +) + +type exchangeFunc func(context.Context, []byte) ([]byte, error) + +func (f exchangeFunc) RoundTrip(ctx context.Context, payload []byte) ([]byte, error) { + return f(ctx, payload) +} +func ptr[T any](v T) *T { return &v } + +func requestContext() RequestContext { + return RequestContext{RequestID: "pv-1", SiteID: "site-1", ConfigRevision: "config-1", OriginMs: 1700000100000, Config: Config{PV: &PVConfig{LatitudeDeg: 57, LongitudeDeg: 15}, Load: &LoadConfig{}}} +} + +func predictionRequest() PredictRequest { + r := requestContext() + return PredictRequest{RequestContext: r, Horizon: []HorizonSlot{{Interval: Interval{r.OriginMs, r.OriginMs + 900000}, Features: Features{LocalDay: 0, LocalWeekday: 3, LocalMinute: 12 * 60, GHIWm2: ptr(500.0), WeatherAvailableAtMs: ptr(r.OriginMs - 3600000)}}}} +} + +func updateRequest() UpdateRequest { + r := requestContext() + return UpdateRequest{RequestContext: r, Observations: []Observation{{Interval: Interval{r.OriginMs - 900000, r.OriginMs}, Features: Features{LocalDay: 0, LocalWeekday: 3, LocalMinute: 12 * 60, GHIWm2: ptr(500.0), WeatherAvailableAtMs: ptr(r.OriginMs - 3600000)}, AvailableAtMs: r.OriginMs, HouseholdLoadW: ptr(1000.0), PVAvailableW: ptr(8000.0), LoadQuality: QualityGood, PVQuality: QualityGood}}} +} + +func goodReply(payload []byte) map[string]any { + var request map[string]any + _ = json.Unmarshal(payload, &request) + reply := map[string]any{"ok": true, "model_revision": 1, "latest_input_ms": map[string]any{"pv": nil, "load": nil}, "latest_training_ms": map[string]any{"pv": nil, "load": nil}, "latest_available_at_ms": map[string]any{"pv": nil, "load": nil}} + for _, key := range []string{"op", "version", "action", "request_id", "site_id", "config_revision", "origin_ms"} { + reply[key] = request[key] + } + if request["action"] == "update" { + reply["state"] = map[string]any{"opaque": "rust-state"} + n := len(request["observations"].([]any)) + reply["updates"] = map[string]any{"pv": map[string]any{"applied": n, "skipped": 0}, "load": map[string]any{"applied": n, "skipped": 0}} + } else { + var predictions []any + for _, raw := range request["horizon"].([]any) { + slot := raw.(map[string]any) + predictions = append(predictions, map[string]any{"valid_start_ms": slot["valid_start_ms"], "valid_end_ms": slot["valid_end_ms"], "pv": map[string]any{"known": false, "quality": "unknown", "uncertainty": "unavailable", "coverage": 0}, "load": map[string]any{"known": true, "point_w": 500, "lower_w": 100, "upper_w": 900, "quality": "cold_start", "uncertainty": "provisional", "coverage": 0}}) + } + reply["predictions"] = predictions + } + return reply +} + +func replying(mutate func(map[string]any)) *Client { + return NewClient(exchangeFunc(func(_ context.Context, payload []byte) ([]byte, error) { + r := goodReply(payload) + if mutate != nil { + mutate(r) + } + return json.Marshal(r) + })) +} + +func firstEstimate(r map[string]any, signal string) map[string]any { + return r["predictions"].([]any)[0].(map[string]any)[signal].(map[string]any) +} + +func TestClientPreservesUnknownAndProvisional(t *testing.T) { + reply, err := replying(nil).Predict(context.Background(), predictionRequest()) + if err != nil { + t.Fatal(err) + } + if reply.Predictions[0].PV.Known || reply.Predictions[0].PV.PointW != nil { + t.Fatal("unknown became zero") + } + if reply.Predictions[0].Load.Uncertainty != "provisional" || reply.Predictions[0].Load.Quality != "cold_start" { + t.Fatal("provisional bounds changed meaning") + } + if reply.ModelRevision != 1 { + t.Fatal("numeric model revision lost") + } +} + +func TestClientRejectsWrongReplyIdentity(t *testing.T) { + for _, key := range []string{"op", "version", "action", "request_id", "site_id", "config_revision", "origin_ms", "ok"} { + t.Run(key, func(t *testing.T) { + for _, drop := range []bool{false, true} { + c := replying(func(r map[string]any) { + if drop { + delete(r, key) + } else { + switch key { + case "version", "origin_ms": + r[key] = 999 + case "ok": + r[key] = false + default: + r[key] = "wrong" + } + } + }) + if _, err := c.Predict(context.Background(), predictionRequest()); err == nil { + t.Fatalf("invalid %s accepted, dropped=%v", key, drop) + } + } + }) + } +} + +func TestClientRejectsMalformedForecast(t *testing.T) { + for name, mutate := range map[string]func(map[string]any){ + "missing_slot": func(r map[string]any) { r["predictions"] = []any{} }, + "wrong_interval": func(r map[string]any) { r["predictions"].([]any)[0].(map[string]any)["valid_end_ms"] = 1 }, + "missing_model": func(r map[string]any) { delete(r["predictions"].([]any)[0].(map[string]any), "pv") }, + "negative_point": func(r map[string]any) { firstEstimate(r, "load")["point_w"] = -1 }, + "crossed_bounds": func(r map[string]any) { firstEstimate(r, "load")["lower_w"] = 600 }, + "missing_point": func(r map[string]any) { delete(firstEstimate(r, "load"), "point_w") }, + "missing_known": func(r map[string]any) { delete(firstEstimate(r, "pv"), "known") }, + "unknown_point": func(r map[string]any) { firstEstimate(r, "pv")["point_w"] = 0 }, + "unknown_quality": func(r map[string]any) { firstEstimate(r, "load")["quality"] = "excellent" }, + "fake_quantiles": func(r map[string]any) { firstEstimate(r, "load")["uncertainty"] = "calibrated_p10_p90" }, + "wrong_coverage": func(r map[string]any) { firstEstimate(r, "load")["coverage"] = 1.1 }, + "future_input": func(r map[string]any) { r["latest_input_ms"] = map[string]any{"pv": requestContext().OriginMs + 1} }, + "future_availability": func(r map[string]any) { + r["latest_available_at_ms"] = map[string]any{"pv": requestContext().OriginMs + 1} + }, + "future_training": func(r map[string]any) { + r["latest_training_ms"] = map[string]any{"pv": requestContext().OriginMs + 1, "load": nil} + }, + "missing_clock": func(r map[string]any) { r["latest_input_ms"] = map[string]any{} }, + "predict_has_state": func(r map[string]any) { r["state"] = map[string]any{} }, + "input_without_availability": func(r map[string]any) { + r["latest_input_ms"] = map[string]any{"pv": requestContext().OriginMs, "load": nil} + }, + "missing_revision": func(r map[string]any) { delete(r, "model_revision") }, + "string_revision": func(r map[string]any) { r["model_revision"] = "1" }, + "contradictory_error": func(r map[string]any) { r["error"] = map[string]any{"code": "broken"} }, + } { + t.Run(name, func(t *testing.T) { + if _, err := replying(mutate).Predict(context.Background(), predictionRequest()); err == nil { + t.Fatal("malformed forecast accepted") + } + }) + } +} + +func TestClientUpdateStateIsExplicitAndReplayable(t *testing.T) { + var seen []json.RawMessage + c := NewClient(exchangeFunc(func(_ context.Context, payload []byte) ([]byte, error) { + var r struct{ State json.RawMessage } + _ = json.Unmarshal(payload, &r) + seen = append(seen, append(json.RawMessage(nil), r.State...)) + return json.Marshal(goodReply(payload)) + })) + updated, err := c.Update(context.Background(), updateRequest()) + if err != nil { + t.Fatal(err) + } + if updated.Updates.PV.Applied != 1 || len(updated.State) == 0 { + t.Fatal("lost update state") + } + r := predictionRequest() + r.State = updated.State + first, err := c.Predict(context.Background(), r) + if err != nil { + t.Fatal(err) + } + second, err := c.Predict(context.Background(), r) + if err != nil { + t.Fatal(err) + } + if string(seen[1]) != string(seen[2]) || first.ModelRevision != second.ModelRevision { + t.Fatal("predict mutated supplied state") + } + if len(seen[0]) != 0 { + t.Fatal("client invented initial state") + } +} + +func TestClientRejectsInvalidUpdateReply(t *testing.T) { + for name, mutate := range map[string]func(map[string]any){ + "state_missing": func(r map[string]any) { delete(r, "state") }, + "state_array": func(r map[string]any) { r["state"] = []any{1} }, + "counts_missing": func(r map[string]any) { delete(r, "updates") }, + "counts_negative": func(r map[string]any) { + r["updates"].(map[string]any)["pv"] = map[string]any{"applied": -1, "skipped": 2} + }, + "counts_wrong": func(r map[string]any) { + r["updates"].(map[string]any)["pv"] = map[string]any{"applied": 2, "skipped": 0} + }, + "future_training": func(r map[string]any) { + r["latest_training_ms"] = map[string]any{"pv": requestContext().OriginMs + 1, "load": nil} + }, + } { + t.Run(name, func(t *testing.T) { + if _, err := replying(mutate).Update(context.Background(), updateRequest()); err == nil { + t.Fatal("invalid update accepted") + } + }) + } +} + +func TestClientRejectsUnavailableWeatherAndInvalidObservationsBeforeIO(t *testing.T) { + calls := 0 + c := NewClient(exchangeFunc(func(context.Context, []byte) ([]byte, error) { calls++; return nil, nil })) + for _, mutate := range []func(*PredictRequest){ + func(r *PredictRequest) { r.Horizon[0].WeatherAvailableAtMs = ptr(r.OriginMs + 1) }, + func(r *PredictRequest) { r.Horizon[0].WeatherAvailableAtMs = nil }, + func(r *PredictRequest) { r.Horizon[0].GHIWm2 = ptr(math.NaN()) }, + func(r *PredictRequest) { r.Horizon[0].LocalWeekday = 0 }, + func(r *PredictRequest) { r.Horizon[0].ValidStartMs = r.OriginMs - 1 }, + } { + r := predictionRequest() + mutate(&r) + if _, err := c.Predict(context.Background(), r); err == nil { + t.Fatal("invalid forecast request accepted") + } + } + for _, mutate := range []func(*UpdateRequest){ + func(r *UpdateRequest) { r.Observations[0].AvailableAtMs = r.OriginMs + 1 }, + func(r *UpdateRequest) { r.Observations[0].PVAvailableW = ptr(-1.0) }, + func(r *UpdateRequest) { r.Observations[0].ValidStartMs++ }, + func(r *UpdateRequest) { r.Observations[0].PVAvailableW = nil }, + func(r *UpdateRequest) { r.Observations = append(r.Observations, r.Observations[0]) }, + } { + r := updateRequest() + mutate(&r) + if _, err := c.Update(context.Background(), r); err == nil { + t.Fatal("invalid observation accepted") + } + } + if calls != 0 { + t.Fatal("invalid request reached worker") + } +} + +func TestClientBoundsAndTimeout(t *testing.T) { + t.Run("timeout", func(t *testing.T) { + c := NewClient(exchangeFunc(func(ctx context.Context, _ []byte) ([]byte, error) { <-ctx.Done(); return nil, ctx.Err() })) + c.Timeout = 10 * time.Millisecond + start := time.Now() + _, err := c.Predict(context.Background(), predictionRequest()) + if !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > time.Second { + t.Fatalf("timeout failed: %v", err) + } + }) + t.Run("oversize_reply", func(t *testing.T) { + c := NewClient(exchangeFunc(func(context.Context, []byte) ([]byte, error) { + return []byte(strings.Repeat(" ", MaxPayloadBytes+1)), nil + })) + if _, err := c.Predict(context.Background(), predictionRequest()); err == nil { + t.Fatal("oversize reply accepted") + } + }) + t.Run("invalid_json", func(t *testing.T) { + c := NewClient(exchangeFunc(func(context.Context, []byte) ([]byte, error) { return []byte(`{} {}`), nil })) + if _, err := c.Predict(context.Background(), predictionRequest()); err == nil { + t.Fatal("multiple replies accepted") + } + }) + t.Run("oversize_state", func(t *testing.T) { + r := predictionRequest() + r.State = json.RawMessage(`{"padding":"` + strings.Repeat("x", MaxStateBytes) + `"}`) + if _, err := replying(nil).Predict(context.Background(), r); err == nil { + t.Fatal("oversize state accepted") + } + }) + t.Run("too_many_slots", func(t *testing.T) { + r := predictionRequest() + r.Horizon = make([]HorizonSlot, MaxHorizon+1) + if _, err := replying(nil).Predict(context.Background(), r); err == nil { + t.Fatal("oversize horizon accepted") + } + }) + t.Run("empty_update", func(t *testing.T) { + r := updateRequest() + r.Observations = nil + if _, err := replying(nil).Update(context.Background(), r); err != nil { + t.Fatal(err) + } + }) +} diff --git a/go/internal/energyforecast/native_test.go b/go/internal/energyforecast/native_test.go new file mode 100644 index 00000000..103900b6 --- /dev/null +++ b/go/internal/energyforecast/native_test.go @@ -0,0 +1,88 @@ +package energyforecast_test + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/energyforecast" + "github.com/srcfl/ftw/go/internal/mpc" +) + +func TestNativeForecastStateReplay(t *testing.T) { + binary := os.Getenv("FTW_FORECAST_WORKER") + if binary == "" { + t.Skip("set FTW_FORECAST_WORKER to an Energyplan worker with forecast protocol v1") + } + newClient := func() (*energyforecast.Client, *mpc.ProcessTransport) { + transport, err := mpc.NewProcessTransport(mpc.ProcessTransportConfig{Command: []string{binary}, ModuleDir: filepath.Dir(binary)}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = transport.Close() }) + return energyforecast.NewClient(transport), transport + } + c, transport := newClient() + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + end := start.Add(15 * time.Minute) + features := func(at time.Time) energyforecast.Features { + ghi := 500.0 + available := start.UnixMilli() + return energyforecast.Features{LocalDay: at.Unix() / 86400, LocalWeekday: (int(at.Weekday()) + 6) % 7, LocalMinute: at.Hour()*60 + at.Minute(), GHIWm2: &ghi, WeatherAvailableAtMs: &available} + } + meta := energyforecast.RequestContext{RequestID: "native-pv-update", SiteID: "native-geometry-free", ConfigRevision: "v1", OriginMs: end.UnixMilli(), Config: energyforecast.Config{PV: &energyforecast.PVConfig{LatitudeDeg: 57, LongitudeDeg: 15}, Load: &energyforecast.LoadConfig{}}} + pv, load := 8000.0, 1000.0 + update, err := c.Update(context.Background(), energyforecast.UpdateRequest{RequestContext: meta, Observations: []energyforecast.Observation{{Interval: energyforecast.Interval{ValidStartMs: start.UnixMilli(), ValidEndMs: end.UnixMilli()}, Features: features(start), AvailableAtMs: end.UnixMilli(), PVAvailableW: &pv, HouseholdLoadW: &load, PVQuality: energyforecast.QualityGood, LoadQuality: energyforecast.QualityGood}}}) + if err != nil { + t.Fatal(err) + } + if len(update.State) == 0 || update.ModelRevision == 0 { + t.Fatal("native update did not return versioned state") + } + meta.RequestID = "native-pv-predict" + meta.State = update.State + request := energyforecast.PredictRequest{RequestContext: meta, Horizon: []energyforecast.HorizonSlot{{Interval: energyforecast.Interval{ValidStartMs: end.UnixMilli(), ValidEndMs: end.Add(15 * time.Minute).UnixMilli()}, Features: features(end)}}} + first, err := c.Predict(context.Background(), request) + if err != nil { + t.Fatal(err) + } + second, err := c.Predict(context.Background(), request) + if err != nil { + t.Fatal(err) + } + encode := func(r energyforecast.PredictReply) string { + b, err := json.Marshal(r) + if err != nil { + t.Fatal(err) + } + return string(b) + } + if encode(first) != encode(second) { + t.Fatal("immutable native predict changed state") + } + if err := transport.Close(); err != nil { + t.Fatal(err) + } + restarted, _ := newClient() + replay, err := restarted.Predict(context.Background(), request) + if err != nil { + t.Fatal(err) + } + if encode(first) != encode(replay) { + t.Fatal("native state did not survive process restart") + } + for _, change := range []func(*energyforecast.PredictRequest){ + func(r *energyforecast.PredictRequest) { r.SiteID = "another-site" }, + func(r *energyforecast.PredictRequest) { r.ConfigRevision = "v2" }, + func(r *energyforecast.PredictRequest) { r.OriginMs = start.UnixMilli() }, + } { + bad := request + change(&bad) + if _, err := restarted.Predict(context.Background(), bad); err == nil { + t.Fatal("native worker accepted wrong site/config or future state") + } + } +} diff --git a/go/internal/energyforecast/types.go b/go/internal/energyforecast/types.go new file mode 100644 index 00000000..9d58ae48 --- /dev/null +++ b/go/internal/energyforecast/types.go @@ -0,0 +1,154 @@ +// Package energyforecast adapts Core's observations and issued weather to the +// versioned Energyplan forecast worker. All learned model code stays in Rust. +package energyforecast + +import ( + "context" + "encoding/json" +) + +const ProtocolVersion = 1 +const MaxPayloadBytes = 2 * 1024 * 1024 +const MaxStateBytes = 1024 * 1024 +const MaxObservations = 4096 +const MaxHorizon = 512 + +// RoundTripper must stop I/O when the context expires. The existing MPC +// ProcessTransport satisfies this interface without a package dependency. +type RoundTripper interface { + RoundTrip(context.Context, []byte) ([]byte, error) +} + +type PVConfig struct { + LatitudeDeg float64 `json:"latitude_deg"` + LongitudeDeg float64 `json:"longitude_deg"` + ACLimitW *float64 `json:"ac_limit_w,omitempty"` +} + +type LoadConfig struct{} + +type Config struct { + PV *PVConfig `json:"pv,omitempty"` + Load *LoadConfig `json:"load,omitempty"` +} + +type RequestContext struct { + RequestID string `json:"request_id"` + SiteID string `json:"site_id"` + ConfigRevision string `json:"config_revision"` + OriginMs int64 `json:"origin_ms"` + Config Config `json:"config"` + State json.RawMessage `json:"state,omitempty"` +} + +type Interval struct { + ValidStartMs int64 `json:"valid_start_ms"` + ValidEndMs int64 `json:"valid_end_ms"` +} + +// Features describe the civil schedule and the weather available at origin. +// LocalDay counts civil dates since 1970; Monday is weekday zero. +type Features struct { + LocalDay int64 `json:"local_day"` + LocalWeekday int `json:"local_weekday"` + LocalMinute int `json:"local_minute"` + Home *bool `json:"home,omitempty"` + GHIWm2 *float64 `json:"ghi_w_m2,omitempty"` + CloudPct *float64 `json:"cloud_pct,omitempty"` + TempC *float64 `json:"temp_c,omitempty"` + WeatherAvailableAtMs *int64 `json:"weather_available_at_ms,omitempty"` +} + +type ObservationQuality string + +const ( + QualityGood ObservationQuality = "good" + QualityMissing ObservationQuality = "missing" + QualityStale ObservationQuality = "stale" + QualityIncomplete ObservationQuality = "incomplete" + QualityCurtailed ObservationQuality = "curtailed" + QualityClipped ObservationQuality = "clipped" +) + +// Observation uses interval-mean, generation-positive PV watts. Core converts +// its site-sign PV before this boundary. Missing power stays absent, not zero. +// Ordinary inverter AC clipping is Good; Clipped means a censored sensor reading. +type Observation struct { + Interval + Features + AvailableAtMs int64 `json:"available_at_ms"` + HouseholdLoadW *float64 `json:"household_load_w,omitempty"` + PVAvailableW *float64 `json:"pv_available_w,omitempty"` + LoadQuality ObservationQuality `json:"load_quality"` + PVQuality ObservationQuality `json:"pv_quality"` +} + +type HorizonSlot struct { + Interval + Features +} + +type UpdateRequest struct { + RequestContext + Observations []Observation `json:"observations"` +} +type PredictRequest struct { + RequestContext + Horizon []HorizonSlot `json:"horizon"` +} + +type ReplyContext struct { + Op string `json:"op"` + Version int `json:"version"` + Action string `json:"action"` + RequestID string `json:"request_id"` + SiteID string `json:"site_id"` + ConfigRevision string `json:"config_revision"` + OriginMs int64 `json:"origin_ms"` + OK bool `json:"ok"` + Error json.RawMessage `json:"error,omitempty"` + ModelRevision uint64 `json:"model_revision"` + LatestTrainingMs LatestInput `json:"latest_training_ms"` + LatestInputMs LatestInput `json:"latest_input_ms"` + LatestAvailableAtMs LatestInput `json:"latest_available_at_ms"` +} + +type UpdateCount struct { + Applied int `json:"applied"` + Skipped int `json:"skipped"` +} +type UpdateCounts struct { + PV *UpdateCount `json:"pv,omitempty"` + Load *UpdateCount `json:"load,omitempty"` +} +type UpdateReply struct { + ReplyContext + State json.RawMessage `json:"state"` + Updates UpdateCounts `json:"updates"` +} +type LatestInput struct { + PV *int64 `json:"pv,omitempty"` + Load *int64 `json:"load,omitempty"` +} + +// Estimate bounds are provisional model output, not calibrated quantiles. +// Unknown is explicit and cannot turn into a zero-watt forecast on decode. +type Estimate struct { + Known bool `json:"known"` + PointW *float64 `json:"point_w,omitempty"` + LowerW *float64 `json:"lower_w,omitempty"` + UpperW *float64 `json:"upper_w,omitempty"` + Quality string `json:"quality"` + Uncertainty string `json:"uncertainty"` + Coverage float64 `json:"coverage"` +} + +type Prediction struct { + Interval + PV *Estimate `json:"pv,omitempty"` + Load *Estimate `json:"load,omitempty"` +} +type PredictReply struct { + ReplyContext + Predictions []Prediction `json:"predictions"` +} diff --git a/go/internal/forecast/forecast.go b/go/internal/forecast/forecast.go index acefbc77..cfd0f298 100644 --- a/go/internal/forecast/forecast.go +++ b/go/internal/forecast/forecast.go @@ -25,6 +25,7 @@ import ( "log/slog" "math" "net/http" + "sync" "time" "github.com/srcfl/ftw/go/internal/config" @@ -260,10 +261,14 @@ func EstimatePVW(lat, lon float64, t time.Time, cloudPct *float64, ratedW float6 // Service wraps a provider + store + scheduler for forecasts. type Service struct { - Provider Provider - Store *state.Store - Lat, Lon float64 - RatedPVW float64 // total rated PV across all arrays (used for estimate) + mu sync.RWMutex + generation uint64 + refresh chan struct{} + ACLimitW float64 // verified inverter AC limit; zero means unknown + Provider Provider + Store *state.Store + Lat, Lon float64 + RatedPVW float64 // total rated PV across all arrays (used for estimate) // Arrays holds per-plane geometry (tilt/azimuth/kWp) mirrored from the // weather config. When set, a radiation-bearing provider's horizontal @@ -324,6 +329,7 @@ func FromConfig(cfg *config.Weather, ratedPVW float64, st *state.Store, userAgen Lat: cfg.Latitude, Lon: cfg.Longitude, RatedPVW: ratedPVW, Arrays: arrays, + refresh: make(chan struct{}, 1), stop: make(chan struct{}), done: make(chan struct{}), } @@ -340,35 +346,76 @@ func (s *Service) Stop() { <-s.done } +// Reconfigure invalidates cached forecasts and in-flight fetches from the old +// location or provider. The replacement becomes visible as one generation. +func (s *Service) Reconfigure(cfg *config.Weather, ratedPVW float64, userAgent string) { + next := FromConfig(cfg, ratedPVW, s.Store, userAgent) + s.mu.Lock() + s.generation++ + if next == nil { + s.Provider = nil + } else { + s.Provider, s.Lat, s.Lon = next.Provider, next.Lat, next.Lon + s.RatedPVW, s.Arrays = next.RatedPVW, next.Arrays + } + if err := s.Store.InvalidateWeatherForecasts(); err != nil { + slog.Warn("forecast cache invalidation failed", "err", err) + } + s.mu.Unlock() + select { + case s.refresh <- struct{}{}: + default: + } +} + func (s *Service) loop(ctx context.Context) { defer close(s.done) - s.fetchAndStore(ctx) - t := time.NewTicker(3 * time.Hour) - defer t.Stop() + retry := time.Minute for { + delay := 3 * time.Hour + if !s.fetchAndStore(ctx) { + delay = retry + retry = min(15*time.Minute, 2*retry) + } else { + retry = time.Minute + } + timer := time.NewTimer(delay) select { case <-s.stop: + timer.Stop() return case <-ctx.Done(): + timer.Stop() return - case <-t.C: - s.fetchAndStore(ctx) + case <-s.refresh: + timer.Stop() + case <-timer.C: } } } -func (s *Service) fetchAndStore(ctx context.Context) { - rows, err := s.Provider.Fetch(ctx, s.Lat, s.Lon) +func (s *Service) fetchAndStore(ctx context.Context) bool { + s.mu.RLock() + provider, lat, lon, rated, acLimit, generation := s.Provider, s.Lat, s.Lon, s.RatedPVW, s.ACLimitW, s.generation + arrays := append([]Array(nil), s.Arrays...) + s.mu.RUnlock() + if provider == nil { + return true + } + rows, err := provider.Fetch(ctx, lat, lon) if err != nil { - slog.Warn("forecast fetch failed", "err", err, "provider", s.Provider.Name()) - return + slog.Warn("forecast fetch failed", "err", err, "provider", provider.Name()) + return false } if len(rows) == 0 { - return + return false } nowMs := time.Now().UnixMilli() points := make([]state.ForecastPoint, 0, len(rows)) for _, r := range rows { + r.PVWEstimated = validWeatherNumber(r.PVWEstimated, 0, math.Inf(1)) + r.CloudCoverPct = validWeatherNumber(r.CloudCoverPct, 0, 100) + r.TempC = validWeatherNumber(r.TempC, -100, 80) // A negative irradiance is not physical; retain the row with a // zero signal. Non-finite values are invalid provider data and must // not reach SQLite, where they can become NULL silently. @@ -376,7 +423,7 @@ func (s *Service) fetchAndStore(ctx context.Context) { if r.SolarWm2 != nil { ghi, ok := normalizeIrradiance(*r.SolarWm2) if !ok { - slog.Warn("forecast row skipped", "reason", "non-finite irradiance", "provider", s.Provider.Name(), "slot", r.HourStart) + slog.Warn("forecast row skipped", "reason", "non-finite irradiance", "provider", provider.Name(), "slot", r.HourStart) continue } solarWm2 = &ghi @@ -391,30 +438,35 @@ func (s *Service) fetchAndStore(ctx context.Context) { pvW = *r.PVWEstimated case solarWm2 != nil: var ok bool - pvW, ok = pvWFromGHI(s.Lat, s.Lon, r.HourStart, *solarWm2, s.RatedPVW, s.Arrays) + pvW, ok = pvWFromGHI(lat, lon, r.HourStart.Add(30*time.Minute), *solarWm2, rated, arrays) if !ok { - slog.Warn("forecast row skipped", "reason", "non-finite irradiance", "provider", s.Provider.Name(), "slot", r.HourStart) + slog.Warn("forecast row skipped", "reason", "non-finite irradiance", "provider", provider.Name(), "slot", r.HourStart) continue } default: - pvW = EstimatePVW(s.Lat, s.Lon, r.HourStart, r.CloudCoverPct, s.RatedPVW) + pvW = EstimatePVW(lat, lon, r.HourStart.Add(30*time.Minute), r.CloudCoverPct, rated) } if math.IsNaN(pvW) || math.IsInf(pvW, 0) { - slog.Warn("forecast row skipped", "reason", "non-finite PV estimate", "provider", s.Provider.Name(), "slot", r.HourStart) + slog.Warn("forecast row skipped", "reason", "non-finite PV estimate", "provider", provider.Name(), "slot", r.HourStart) continue } if pvW < 0 { pvW = 0 } - if capW := s.nameplateW(); capW > 0 { + if capW := acLimit; capW > 0 { if capped, ok := clampPVToNameplate(pvW, capW); ok { - slog.Warn("forecast PV capped to nameplate", - "provider", s.Provider.Name(), "slot", r.HourStart, + slog.Warn("forecast PV capped to verified AC limit", + "provider", provider.Name(), "slot", r.HourStart, "raw_w", pvW, "capped_w", capped, "nameplate_w", capW) pvW = capped } } pvPtr := &pvW + // Missing capacity or weather is unknown, even when EstimatePVW's + // numeric fallback is zero. Direct production forecasts stand alone. + if r.PVWEstimated == nil && (NameplateW(rated, arrays) <= 0 || (solarWm2 == nil && r.CloudCoverPct == nil)) { + pvPtr = nil + } points = append(points, state.ForecastPoint{ SlotTsMs: r.HourStart.UnixMilli(), SlotLenMin: 60, @@ -422,15 +474,21 @@ func (s *Service) fetchAndStore(ctx context.Context) { TempC: r.TempC, SolarWm2: solarWm2, PVWEstimated: pvPtr, - Source: s.Provider.Name(), + Source: provider.Name(), FetchedAtMs: nowMs, }) } + s.mu.RLock() + defer s.mu.RUnlock() + if generation != s.generation { + return false + } if err := s.Store.SaveForecasts(points); err != nil { slog.Warn("forecast save failed", "err", err) - return + return false } - slog.Info("forecast fetched", "count", len(points), "provider", s.Provider.Name()) + slog.Info("forecast fetched", "count", len(points), "provider", provider.Name()) + return len(points) > 0 } func arrayFromConfig(a config.PVArray) (Array, bool) { @@ -445,7 +503,7 @@ func (s *Service) nameplateW() float64 { return NameplateW(s.RatedPVW, s.Arrays) } -// NameplateW is the site PV ceiling. Arrays store rated watts; the +// NameplateW is the configured DC scale, not a verified AC limit. The // sum of those is the nameplate. pv_rated_w is the fallback when no // complete array geometry exists. func NameplateW(ratedPVW float64, arrays []Array) float64 { @@ -479,7 +537,7 @@ func clampPVToNameplate(pvW, nameplateW float64) (float64, bool) { } func normalizeIrradiance(ghiWm2 float64) (float64, bool) { - if math.IsNaN(ghiWm2) || math.IsInf(ghiWm2, 0) { + if math.IsNaN(ghiWm2) || math.IsInf(ghiWm2, 0) || ghiWm2 > 3000 { return 0, false } if ghiWm2 < 0 { @@ -524,14 +582,17 @@ func poaPVWattsFromGHI(lat, lon float64, t time.Time, ghiWm2 float64, arrays []A return total } -// Load returns forecasts in [sinceMs, untilMs]. A last-resort -// nameplate gate still clips a stored row that exceeds the roof. +// Load returns forecasts in [sinceMs, untilMs], bounded by a verified AC +// limit when one is known. A configured DC rating is only a prior. func (s *Service) Load(sinceMs, untilMs int64) ([]state.ForecastPoint, error) { rows, err := s.Store.LoadForecasts(sinceMs, untilMs) if err != nil { return rows, err } - return ClampForecasts(rows, s.nameplateW()), nil + s.mu.RLock() + limit := s.ACLimitW + s.mu.RUnlock() + return ClampForecasts(rows, limit), nil } // ClampForecasts copies any estimate above nameplate down onto that @@ -551,3 +612,11 @@ func ClampForecasts(rows []state.ForecastPoint, nameplateW float64) []state.Fore } return rows } + +func validWeatherNumber(v *float64, low, high float64) *float64 { + if v == nil || math.IsNaN(*v) || math.IsInf(*v, 0) || *v < low || *v > high { + return nil + } + x := *v + return &x +} diff --git a/go/internal/forecast/forecast_solar.go b/go/internal/forecast/forecast_solar.go index fc6cd1cb..f1af8c5c 100644 --- a/go/internal/forecast/forecast_solar.go +++ b/go/internal/forecast/forecast_solar.go @@ -5,7 +5,9 @@ import ( "encoding/json" "fmt" "io" + "math" "net/http" + "sort" "time" "github.com/srcfl/ftw/go/internal/units" @@ -34,9 +36,8 @@ import ( // downstream code falls back to whatever it uses when these are // absent (pvmodel: neutral 50%, fuse/thermal: no-op). // - The response is per-timestamp at irregular intervals (typically -// minutely around dawn/dusk, larger during the flat part of the -// day). We bucket to UTC hours by picking the sample closest to -// each hour's start. +// minutely around dawn/dusk, then hourly). We split each preceding +// period's energy across UTC hours. type ForecastSolarProvider struct { Client *http.Client BaseURL string @@ -87,15 +88,24 @@ func (f *ForecastSolarProvider) Fetch(ctx context.Context, lat, lon float64) ([] return nil, fmt.Errorf("forecast.solar: at least one array required") } for i, a := range f.Arrays { - if a.RatedW <= 0 { - return nil, fmt.Errorf("forecast.solar: array %d rated_w must be > 0 (got %f W)", i, a.RatedW) + if math.IsNaN(a.RatedW) || math.IsInf(a.RatedW, 0) || a.RatedW <= 0 { + return nil, fmt.Errorf("forecast.solar: array %d rated_w must be finite and > 0 (got %f W)", i, a.RatedW) + } + if math.IsNaN(a.TiltDeg) || math.IsInf(a.TiltDeg, 0) || a.TiltDeg < 0 || a.TiltDeg > 90 { + return nil, fmt.Errorf("forecast.solar: array %d tilt_deg must be within 0..90 (got %f)", i, a.TiltDeg) + } + if math.IsNaN(a.AzimuthDeg) || math.IsInf(a.AzimuthDeg, 0) || a.AzimuthDeg < 0 || a.AzimuthDeg > 360 { + return nil, fmt.Errorf("forecast.solar: array %d azimuth_deg must be within 0..360 (got %f)", i, a.AzimuthDeg) } } // Multi-plane URL syntax: /estimate/lat/lon/tilt1/az1/kwp1/tilt2/az2/kwp2/... // kWp is this vendor's unit — convert at this door only. var planes string for _, a := range f.Arrays { - planes += fmt.Sprintf("/%.1f/%.1f/%.2f", a.TiltDeg, a.AzimuthDeg, units.KWpFromWatts(a.RatedW)) + // FTW uses compass headings (north=0, east=90, south=180, + // west=270). forecast.solar uses south=0, east=-90, west=90. + vendorAzimuth := a.AzimuthDeg - 180 + planes += fmt.Sprintf("/%.1f/%.1f/%.2f", a.TiltDeg, vendorAzimuth, units.KWpFromWatts(a.RatedW)) } url := fmt.Sprintf("%s/estimate/%.4f/%.4f%s?time=utc", f.BaseURL, lat, lon, planes) req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil) @@ -118,57 +128,77 @@ func (f *ForecastSolarProvider) Fetch(ctx context.Context, lat, lon float64) ([] } var doc struct { Result struct { - Watts map[string]float64 `json:"watts"` + Watts map[string]json.RawMessage `json:"watts"` } `json:"result"` } if err := json.NewDecoder(resp.Body).Decode(&doc); err != nil { return nil, fmt.Errorf("forecast.solar: decode: %w", err) } - // Bucket to UTC hours. The API returns timestamps like - // "2026-04-17 12:00:00" (UTC when time=utc); we pick the first - // sample whose timestamp falls inside each hour-aligned bucket and - // use its watts value for the whole hour. Fine-grained dawn/dusk - // transitions get smoothed to the hour, which is what the downstream - // schema (SlotLenMin=60) expects anyway. - buckets := make(map[int64]float64, len(doc.Result.Watts)) - for tsStr, w := range doc.Result.Watts { - t, err := time.Parse("2006-01-02 15:04:05", tsStr) + // Each watts value is the mean for the period from the previous + // timestamp to its own timestamp. Split that energy by overlap with UTC + // hours, then divide by one hour to produce energy-preserving hourly + // means. This also handles the short periods around sunrise and sunset. + type sample struct { + at time.Time + watts *float64 + } + samples := make([]sample, 0, len(doc.Result.Watts)) + for tsStr, raw := range doc.Result.Watts { + t, err := parseForecastSolarTime(tsStr) if err != nil { continue } - // The API documents "local time unless ?time=utc"; we sent - // ?time=utc so treat the string as UTC. - t = t.UTC() - hour := t.Truncate(time.Hour) - hourMs := hour.UnixMilli() - // Keep the MAX within the hour so a brief peak (e.g. sunrise - // crossing the first minute) isn't washed out by the zero - // timestamps the API emits right before dawn. - if cur, ok := buckets[hourMs]; !ok || w > cur { - buckets[hourMs] = w + var value *float64 + if json.Unmarshal(raw, &value) != nil || value == nil || math.IsNaN(*value) || math.IsInf(*value, 0) || *value < 0 { + value = nil } + samples = append(samples, sample{at: t, watts: value}) } - out := make([]RawForecast, 0, len(buckets)) - for hourMs, watts := range buckets { - w := watts + sort.Slice(samples, func(i, j int) bool { return samples[i].at.Before(samples[j].at) }) + + energyWh := make(map[int64]float64, len(samples)) + for i := 1; i < len(samples); i++ { + start, end := samples[i-1].at, samples[i].at + if !end.After(start) || end.Sub(start) > 32*24*time.Hour || samples[i].watts == nil { + continue + } + for cursor := start; cursor.Before(end); { + hourStart := cursor.Truncate(time.Hour) + overlapEnd := hourStart.Add(time.Hour) + if end.Before(overlapEnd) { + overlapEnd = end + } + energyWh[hourStart.UnixMilli()] += *samples[i].watts * overlapEnd.Sub(cursor).Hours() + cursor = overlapEnd + } + } + + hours := make([]int64, 0, len(energyWh)) + for hourMs := range energyWh { + hours = append(hours, hourMs) + } + sort.Slice(hours, func(i, j int) bool { return hours[i] < hours[j] }) + out := make([]RawForecast, 0, len(hours)) + for _, hourMs := range hours { + w := energyWh[hourMs] out = append(out, RawForecast{ HourStart: time.UnixMilli(hourMs).UTC(), PVWEstimated: &w, }) } - // Sort by HourStart so consumers (state.SaveForecasts, the MPC - // lookup) see monotone timestamps. - sortByHour(out) return out, nil } -func sortByHour(rows []RawForecast) { - // Insertion sort — the list is ~200 rows for 8 days at hourly - // resolution, not worth importing sort.Slice. - for i := 1; i < len(rows); i++ { - for j := i; j > 0 && rows[j-1].HourStart.After(rows[j].HourStart); j-- { - rows[j-1], rows[j] = rows[j], rows[j-1] - } +func parseForecastSolarTime(value string) (time.Time, error) { + if t, err := time.Parse(time.RFC3339, value); err == nil { + return t.UTC(), nil + } + // Keep support for time_tz=0 and older fixture responses. The request + // asks for UTC, so these offset-free timestamps are UTC too. + t, err := time.Parse("2006-01-02 15:04:05", value) + if err != nil { + return time.Time{}, err } + return t.UTC(), nil } diff --git a/go/internal/forecast/forecast_solar_test.go b/go/internal/forecast/forecast_solar_test.go index ae23f901..4e985eb0 100644 --- a/go/internal/forecast/forecast_solar_test.go +++ b/go/internal/forecast/forecast_solar_test.go @@ -3,6 +3,7 @@ package forecast import ( "context" "fmt" + "math" "net/http" "net/http/httptest" "strings" @@ -11,20 +12,16 @@ import ( ) // Stub server returns a canned Forecast.Solar response. Verifies that -// per-timestamp watts get bucketed to UTC hours and materialised on -// PVWEstimated. We don't assert exact hour-count because the API's -// dawn/dusk sampling is irregular; we assert the peak-hour value is -// preserved and cloud/temp are not fabricated. -func TestForecastSolar_BucketsToHours(t *testing.T) { +// per-period mean watts get split into energy-preserving UTC hours and +// materialised on PVWEstimated. +func TestForecastSolar_SunriseIntervalsPreserveEnergy(t *testing.T) { body := `{ "result": { "watts": { - "2026-04-17 06:53:38": 0.0, - "2026-04-17 07:00:00": 150.0, - "2026-04-17 07:30:00": 450.0, - "2026-04-17 12:00:00": 8200.0, - "2026-04-17 12:30:00": 8450.0, - "2026-04-17 13:00:00": 8100.0 + "2026-04-17T06:30:00+00:00": 0.0, + "2026-04-17T07:00:00+00:00": 600.0, + "2026-04-17T07:30:00+00:00": 1200.0, + "2026-04-17T08:00:00+00:00": 0.0 } }, "message": {"code": 0, "type": "success"} @@ -49,19 +46,14 @@ func TestForecastSolar_BucketsToHours(t *testing.T) { if err != nil { t.Fatal(err) } - // Buckets: 06:53:38 → 06; 07:00 + 07:30 → 07; 12:00 + 12:30 → 12; 13:00 → 13. - if len(rows) != 4 { - t.Errorf("want 4 hour buckets (06/07/12/13), got %d", len(rows)) + if len(rows) != 2 { + t.Fatalf("want hour buckets 06 and 07, got %d", len(rows)) } - // Find the 12:00 UTC bucket — its max in-hour sample is 8450. - var noonPV *float64 - for _, r := range rows { - if r.HourStart.Hour() == 12 { - noonPV = r.PVWEstimated - } + if rows[0].HourStart.Hour() != 6 || rows[0].PVWEstimated == nil || *rows[0].PVWEstimated != 300 { + t.Errorf("06:00 bucket = %+v, want 300 W (300 Wh)", rows[0]) } - if noonPV == nil || *noonPV != 8450.0 { - t.Errorf("12:00 bucket PV = %v, want 8450 (max-in-hour)", noonPV) + if rows[1].HourStart.Hour() != 7 || rows[1].PVWEstimated == nil || *rows[1].PVWEstimated != 600 { + t.Errorf("07:00 bucket = %+v, want 600 W (600 Wh)", rows[1]) } // No fabrication of cloud/temp. for _, r := range rows { @@ -105,6 +97,51 @@ func TestForecastSolar_RejectsZeroKWp(t *testing.T) { } } +func TestForecastSolar_RejectsInvalidGeometry(t *testing.T) { + for name, array := range map[string]Array{ + "negative tilt": {TiltDeg: -1, AzimuthDeg: 180, RatedW: 1000}, + "large tilt": {TiltDeg: 91, AzimuthDeg: 180, RatedW: 1000}, + "negative az": {TiltDeg: 30, AzimuthDeg: -1, RatedW: 1000}, + "large az": {TiltDeg: 30, AzimuthDeg: 361, RatedW: 1000}, + "non-finite": {TiltDeg: 30, AzimuthDeg: 180, RatedW: math.Inf(1)}, + } { + t.Run(name, func(t *testing.T) { + fs := NewForecastSolarMulti([]Array{array}) + if _, err := fs.Fetch(context.Background(), 0, 0); err == nil { + t.Fatal("expected geometry error") + } + }) + } +} + +func TestForecastSolar_ConvertsCompassAzimuth(t *testing.T) { + for name, tc := range map[string]struct { + compass float64 + vendor string + }{ + "north": {compass: 0, vendor: "-180.0"}, + "east": {compass: 90, vendor: "-90.0"}, + "south": {compass: 180, vendor: "0.0"}, + "west": {compass: 270, vendor: "90.0"}, + } { + t.Run(name, func(t *testing.T) { + var path string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path = r.URL.Path + fmt.Fprint(w, `{"result":{"watts":{}}}`) + })) + defer srv.Close() + fs := &ForecastSolarProvider{Client: srv.Client(), BaseURL: srv.URL, Arrays: []Array{{TiltDeg: 35, AzimuthDeg: tc.compass, RatedW: 10000}}} + if _, err := fs.Fetch(context.Background(), 0, 0); err != nil { + t.Fatal(err) + } + if want := "/35.0/" + tc.vendor + "/10.00"; !strings.HasSuffix(path, want) { + t.Errorf("path=%q, want suffix %q", path, want) + } + }) + } +} + // Multi-plane URL: two arrays → URL has two (tilt/azimuth/kwp) // triplets back-to-back, same syntax forecast.solar documents. Verifies // the URL path is constructed correctly when the site has more than @@ -127,26 +164,88 @@ func TestForecastSolar_MultiPlaneURL(t *testing.T) { t.Fatal(err) } // Expect path to contain all six geometry components in order. - for _, frag := range []string{"/35.0/180.0/6.00", "/30.0/90.0/4.00"} { + for _, frag := range []string{"/35.0/0.0/6.00", "/30.0/-90.0/4.00"} { if !strings.Contains(seen, frag) { t.Errorf("URL missing %q; got %q", frag, seen) } } } -// Verifies sortByHour stays stable even with already-sorted input. -func TestForecastSolarSortByHour(t *testing.T) { - base := time.Date(2026, 4, 17, 10, 0, 0, 0, time.UTC) - rows := []RawForecast{ - {HourStart: base.Add(2 * time.Hour)}, - {HourStart: base}, - {HourStart: base.Add(time.Hour)}, - } - sortByHour(rows) - if !rows[0].HourStart.Equal(base) { - t.Errorf("first row = %v, want %v", rows[0].HourStart, base) - } - if !rows[2].HourStart.Equal(base.Add(2*time.Hour)) { - t.Errorf("last row = %v, want %v", rows[2].HourStart, base.Add(2*time.Hour)) +func TestForecastSolar_UnequalIntervalsConserveEnergy(t *testing.T) { + body := `{"result":{"watts":{"2026-04-17T10:10:00+00:00":0,"2026-04-17T10:40:00+00:00":1200,"2026-04-17T11:20:00+00:00":600}}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + fs := &ForecastSolarProvider{Client: srv.Client(), BaseURL: srv.URL, Arrays: []Array{{TiltDeg: 35, AzimuthDeg: 180, RatedW: 10000}}} + rows, err := fs.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 { + t.Fatalf("rows=%d, want 2", len(rows)) + } + if got := *rows[0].PVWEstimated; got != 800 { + t.Errorf("10:00 mean=%g W, want 800 W", got) + } + if got := *rows[1].PVWEstimated; got != 200 { + t.Errorf("11:00 mean=%g W, want 200 W", got) + } + var totalWh float64 + for _, row := range rows { + totalWh += *row.PVWEstimated + } + if totalWh != 1000 { + t.Errorf("hour buckets contain %g Wh, source periods contain 1000 Wh", totalWh) + } +} + +func TestForecastSolar_ExactHourUsesPrecedingPeriod(t *testing.T) { + body := `{"result":{"watts":{"2026-04-17T12:00:00+00:00":0,"2026-04-17T13:00:00+00:00":750}}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + fs := &ForecastSolarProvider{Client: srv.Client(), BaseURL: srv.URL, Arrays: []Array{{TiltDeg: 35, AzimuthDeg: 180, RatedW: 10000}}} + rows, err := fs.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + want := time.Date(2026, 4, 17, 12, 0, 0, 0, time.UTC) + if len(rows) != 1 || !rows[0].HourStart.Equal(want) || rows[0].PVWEstimated == nil || *rows[0].PVWEstimated != 750 { + t.Fatalf("preceding 12:00-13:00 period mapped as %+v, want one 12:00 row at 750 W", rows) + } +} + +func TestForecastSolar_InvalidPeriodDoesNotBridgeGap(t *testing.T) { + body := `{"result":{"watts":{"2026-04-17T10:00:00+00:00":0,"2026-04-17T10:30:00+00:00":-500,"2026-04-17T11:00:00+00:00":1000,"2026-04-17T12:00:00+00:00":1e309,"2026-04-17T13:00:00+00:00":2000}}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + fs := &ForecastSolarProvider{Client: srv.Client(), BaseURL: srv.URL, Arrays: []Array{{TiltDeg: 35, AzimuthDeg: 180, RatedW: 10000}}} + rows, err := fs.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 { + t.Fatalf("rows=%+v, want valid 10:00 and 12:00 periods only", rows) + } + if rows[0].HourStart.Hour() != 10 || *rows[0].PVWEstimated != 500 { + t.Errorf("first valid bucket=%+v, want 10:00 at 500 W", rows[0]) + } + if rows[1].HourStart.Hour() != 12 || *rows[1].PVWEstimated != 2000 { + t.Errorf("second valid bucket=%+v, want 12:00 at 2000 W", rows[1]) + } +} + +func TestForecastSolar_UTCDoesNotSkipDSTHour(t *testing.T) { + body := `{"result":{"watts":{"2026-03-29T00:30:00+00:00":0,"2026-03-29T01:30:00+00:00":600}}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + fs := &ForecastSolarProvider{Client: srv.Client(), BaseURL: srv.URL, Arrays: []Array{{TiltDeg: 35, AzimuthDeg: 180, RatedW: 10000}}} + rows, err := fs.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 || rows[0].HourStart.Hour() != 0 || rows[1].HourStart.Hour() != 1 { + t.Fatalf("UTC hours across European DST change: %+v", rows) + } + if *rows[0].PVWEstimated != 300 || *rows[1].PVWEstimated != 300 { + t.Errorf("split UTC energy = %g, %g; want 300, 300 Wh", *rows[0].PVWEstimated, *rows[1].PVWEstimated) } } diff --git a/go/internal/forecast/forecast_test.go b/go/internal/forecast/forecast_test.go index 9c6567c7..fb16ac5b 100644 --- a/go/internal/forecast/forecast_test.go +++ b/go/internal/forecast/forecast_test.go @@ -111,7 +111,9 @@ func TestEstimatePVWCloudReduction(t *testing.T) { func TestEstimatePVWNilCloudIsMid(t *testing.T) { tt := time.Date(2026, 6, 21, 11, 0, 0, 0, time.UTC) pv := EstimatePVW(59.3293, 18.0686, tt, nil, 10000) - if pv == 0 { t.Error("nil cloud should default to mid-range, not zero") } + if pv == 0 { + t.Error("nil cloud should default to mid-range, not zero") + } } // ---- met.no HTTP ---- @@ -130,7 +132,7 @@ func TestMetNoFetchParses(t *testing.T) { "instant": map[string]any{ "details": map[string]any{ "cloud_area_fraction": 75.0, - "air_temperature": 8.5, + "air_temperature": 8.5, }, }, }, @@ -141,7 +143,7 @@ func TestMetNoFetchParses(t *testing.T) { "instant": map[string]any{ "details": map[string]any{ "cloud_area_fraction": 20.0, - "air_temperature": 7.2, + "air_temperature": 7.2, }, }, }, @@ -156,8 +158,12 @@ func TestMetNoFetchParses(t *testing.T) { p := NewMetNo("test-ua") p.BaseURL = srv.URL rows, err := p.Fetch(context.Background(), 59.3, 18.1) - if err != nil { t.Fatal(err) } - if len(rows) != 2 { t.Fatalf("got %d rows, want 2", len(rows)) } + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 { + t.Fatalf("got %d rows, want 2", len(rows)) + } if rows[0].CloudCoverPct == nil || *rows[0].CloudCoverPct != 75 { t.Errorf("cloud cover: %+v", rows[0].CloudCoverPct) } @@ -174,7 +180,9 @@ func TestMetNoErrorsOn500(t *testing.T) { p := NewMetNo("test") p.BaseURL = srv.URL _, err := p.Fetch(context.Background(), 59, 18) - if err == nil { t.Error("expected error on 500") } + if err == nil { + t.Error("expected error on 500") + } } // ---- OpenWeather HTTP ---- @@ -193,16 +201,26 @@ func TestOpenWeatherFetchParses(t *testing.T) { p := NewOpenWeather("test-key") p.BaseURL = srv.URL rows, err := p.Fetch(context.Background(), 59, 18) - if err != nil { t.Fatal(err) } - if len(rows) != 2 { t.Fatalf("got %d", len(rows)) } - if *rows[0].CloudCoverPct != 40 { t.Errorf("cloud: %f", *rows[0].CloudCoverPct) } - if *rows[1].TempC != 10.5 { t.Errorf("temp: %f", *rows[1].TempC) } + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 { + t.Fatalf("got %d", len(rows)) + } + if *rows[0].CloudCoverPct != 40 { + t.Errorf("cloud: %f", *rows[0].CloudCoverPct) + } + if *rows[1].TempC != 10.5 { + t.Errorf("temp: %f", *rows[1].TempC) + } } func TestOpenWeatherRequiresKey(t *testing.T) { p := NewOpenWeather("") _, err := p.Fetch(context.Background(), 59, 18) - if err == nil { t.Error("expected API key error") } + if err == nil { + t.Error("expected API key error") + } } // ---- Service integration ---- @@ -241,8 +259,12 @@ func TestServiceFetchesAndStoresWithPVEstimate(t *testing.T) { // Load back tt := time.Date(2026, 6, 21, 11, 0, 0, 0, time.UTC) rows, err := st.LoadForecasts(tt.UnixMilli(), tt.Add(time.Hour).UnixMilli()) - if err != nil { t.Fatal(err) } - if len(rows) != 1 { t.Fatalf("got %d forecasts", len(rows)) } + if err != nil { + t.Fatal(err) + } + if len(rows) != 1 { + t.Fatalf("got %d forecasts", len(rows)) + } // Stockholm summer clear-ish sky at noon with 10kW array should give ~4-8 kW estimate if rows[0].PVWEstimated == nil || *rows[0].PVWEstimated < 1000 { t.Errorf("PV estimate should be substantial for clear summer, got %+v", rows[0].PVWEstimated) @@ -253,18 +275,30 @@ func TestServiceFetchesAndStoresWithPVEstimate(t *testing.T) { // ---- FromConfig ---- func TestFromConfigNilWhenDisabled(t *testing.T) { - if FromConfig(nil, 10000, nil, "") != nil { t.Error("nil cfg → nil svc") } - if FromConfig(&config.Weather{Provider: "none"}, 10000, nil, "") != nil { t.Error("none → nil svc") } - if FromConfig(&config.Weather{Provider: ""}, 10000, nil, "") != nil { t.Error("empty → nil svc") } + if FromConfig(nil, 10000, nil, "") != nil { + t.Error("nil cfg → nil svc") + } + if FromConfig(&config.Weather{Provider: "none"}, 10000, nil, "") != nil { + t.Error("none → nil svc") + } + if FromConfig(&config.Weather{Provider: ""}, 10000, nil, "") != nil { + t.Error("empty → nil svc") + } } func TestFromConfigBuildsMetNo(t *testing.T) { st, _ := state.Open(filepath.Join(t.TempDir(), "t.db")) defer st.Close() s := FromConfig(&config.Weather{Provider: "met_no", Latitude: 59, Longitude: 18}, 10000, st, "ua") - if s == nil { t.Fatal("expected service") } - if s.Lat != 59 { t.Errorf("lat: %f", s.Lat) } - if s.RatedPVW != 10000 { t.Errorf("rated: %f", s.RatedPVW) } + if s == nil { + t.Fatal("expected service") + } + if s.Lat != 59 { + t.Errorf("lat: %f", s.Lat) + } + if s.RatedPVW != 10000 { + t.Errorf("rated: %f", s.RatedPVW) + } } func TestFromConfigPopulatesArrays(t *testing.T) { @@ -279,7 +313,9 @@ func TestFromConfigPopulatesArrays(t *testing.T) { }, } s := FromConfig(cfg, 10000, st, "ua") - if s == nil { t.Fatal("expected service") } + if s == nil { + t.Fatal("expected service") + } if len(s.Arrays) != 2 { t.Fatalf("expected 2 arrays (kWp>0 only), got %d", len(s.Arrays)) } @@ -430,7 +466,7 @@ func TestServicePOAPathDiffersFromFlat(t *testing.T) { } s.fetchAndStore(context.Background()) - tt := time.Date(2026, 6, 21, 11, 0, 0, 0, time.UTC) + tt := time.Date(2026, 6, 21, 10, 0, 0, 0, time.UTC) rows, err := st.LoadForecasts(tt.UnixMilli(), tt.Add(time.Hour).UnixMilli()) if err != nil { t.Fatal(err) @@ -440,7 +476,7 @@ func TestServicePOAPathDiffersFromFlat(t *testing.T) { } got := *rows[0].PVWEstimated flat := 10000 * 700.0 / 1000.0 // orientation-blind estimate = 7000 W - want := poaPVWattsFromGHI(59.3293, 18.0686, tt, 700, s.Arrays) + want := poaPVWattsFromGHI(59.3293, 18.0686, tt.Add(30*time.Minute), 700, s.Arrays) if math.Abs(got-want) > 1.0 { t.Errorf("service should use POA path: got %.1f want %.1f", got, want) } @@ -588,7 +624,7 @@ func TestBjorn18960WTooltipIsPastedKWpNotDisplayScale(t *testing.T) { } } -func TestLoadClampsStoredMegawattForecast(t *testing.T) { +func TestLoadUsesVerifiedACLimit(t *testing.T) { st, err := state.Open(filepath.Join(t.TempDir(), "t.db")) if err != nil { t.Fatal(err) @@ -604,6 +640,7 @@ func TestLoadClampsStoredMegawattForecast(t *testing.T) { s := &Service{ Store: st, RatedPVW: 10000, + ACLimitW: 10000, Arrays: []Array{{TiltDeg: 35, AzimuthDeg: 180, RatedW: 10000}}, } rows, err := s.Load(ts, ts+3600*1000) diff --git a/go/internal/forecast/open_meteo.go b/go/internal/forecast/open_meteo.go index ba9d9ce2..6a1dde15 100644 --- a/go/internal/forecast/open_meteo.go +++ b/go/internal/forecast/open_meteo.go @@ -5,7 +5,9 @@ import ( "encoding/json" "fmt" "io" + "math" "net/http" + "sort" "time" ) @@ -62,36 +64,94 @@ func (o *OpenMeteoProvider) Fetch(ctx context.Context, lat, lon float64) ([]RawF } var doc struct { Hourly struct { - Time []string `json:"time"` - ShortwaveRadiation []*float64 `json:"shortwave_radiation"` // W/m² - CloudCover []*float64 `json:"cloud_cover"` // % - Temperature2m []*float64 `json:"temperature_2m"` // °C + Time []string `json:"time"` + ShortwaveRadiation []json.RawMessage `json:"shortwave_radiation"` // W/m² + CloudCover []json.RawMessage `json:"cloud_cover"` // % + Temperature2m []json.RawMessage `json:"temperature_2m"` // °C } `json:"hourly"` } if err := json.NewDecoder(resp.Body).Decode(&doc); err != nil { return nil, fmt.Errorf("open-meteo: decode: %w", err) } - n := len(doc.Hourly.Time) - out := make([]RawForecast, 0, n) - for i := 0; i < n; i++ { + type sample struct { + at time.Time + radiation *float64 + cloudCover *float64 + tempC *float64 + } + samples := make([]sample, 0, len(doc.Hourly.Time)) + for i, ts := range doc.Hourly.Time { // Open-Meteo returns naive local times per the &timezone= param; // with &timezone=UTC they're UTC-zoned ISO8601 without offset. - t, err := time.Parse("2006-01-02T15:04", doc.Hourly.Time[i]) + t, err := parseOpenMeteoTime(ts) if err != nil { continue } - t = t.UTC() - row := RawForecast{HourStart: t} + s := sample{at: t} + if i < len(doc.Hourly.ShortwaveRadiation) { + s.radiation = parseOpenMeteoNumber(doc.Hourly.ShortwaveRadiation[i], func(v float64) bool { return v >= 0 }) + } if i < len(doc.Hourly.CloudCover) { - row.CloudCoverPct = doc.Hourly.CloudCover[i] + s.cloudCover = parseOpenMeteoNumber(doc.Hourly.CloudCover[i], func(v float64) bool { return v >= 0 && v <= 100 }) } if i < len(doc.Hourly.Temperature2m) { - row.TempC = doc.Hourly.Temperature2m[i] + s.tempC = parseOpenMeteoNumber(doc.Hourly.Temperature2m[i], func(float64) bool { return true }) } - if i < len(doc.Hourly.ShortwaveRadiation) { - row.SolarWm2 = doc.Hourly.ShortwaveRadiation[i] + samples = append(samples, s) + } + sort.Slice(samples, func(i, j int) bool { return samples[i].at.Before(samples[j].at) }) + + // Open-Meteo timestamps shortwave_radiation at the end of the hour it + // averages. Normalize it to that interval's start. Cloud cover and air + // temperature are instantaneous, so align them to the same hour with a + // trapezoidal mean of the two endpoints. If an endpoint is absent, leave + // that field absent instead of moving one instant to another hour. + out := make([]RawForecast, 0, len(samples)) + byTime := make(map[int64]sample, len(samples)) + for _, s := range samples { + byTime[s.at.UnixMilli()] = s + } + for _, end := range samples { + startTime := end.at.Add(-time.Hour) + row := RawForecast{HourStart: startTime} + row.SolarWm2 = end.radiation + if start, ok := byTime[startTime.UnixMilli()]; ok { + row.CloudCoverPct = meanOpenMeteoEndpoints(start.cloudCover, end.cloudCover) + row.TempC = meanOpenMeteoEndpoints(start.tempC, end.tempC) + } + if row.SolarWm2 != nil || row.CloudCoverPct != nil || row.TempC != nil { + out = append(out, row) } - out = append(out, row) } return out, nil } + +func parseOpenMeteoTime(value string) (time.Time, error) { + if t, err := time.Parse("2006-01-02T15:04", value); err == nil { + return t.UTC(), nil + } + t, err := time.Parse(time.RFC3339, value) + if err != nil { + return time.Time{}, err + } + return t.UTC(), nil +} + +func parseOpenMeteoNumber(raw json.RawMessage, valid func(float64) bool) *float64 { + var value *float64 + if len(raw) == 0 || json.Unmarshal(raw, &value) != nil || value == nil || math.IsNaN(*value) || math.IsInf(*value, 0) || !valid(*value) { + return nil + } + return value +} + +func meanOpenMeteoEndpoints(start, end *float64) *float64 { + if start == nil || end == nil { + return nil + } + mean := (*start + *end) / 2 + if math.IsNaN(mean) || math.IsInf(mean, 0) { + return nil + } + return &mean +} diff --git a/go/internal/forecast/open_meteo_test.go b/go/internal/forecast/open_meteo_test.go index 6a150416..0e385ebd 100644 --- a/go/internal/forecast/open_meteo_test.go +++ b/go/internal/forecast/open_meteo_test.go @@ -7,6 +7,7 @@ import ( "net/http/httptest" "strings" "testing" + "time" ) // Stub server returns a canned Open-Meteo response. Verifies that @@ -37,14 +38,20 @@ func TestOpenMeteo_ParsesRadiationAndCloud(t *testing.T) { if len(rows) != 3 { t.Fatalf("got %d rows, want 3", len(rows)) } + if want := time.Date(2026, 4, 17, 11, 0, 0, 0, time.UTC); !rows[0].HourStart.Equal(want) { + t.Errorf("first interval starts at %s, want %s", rows[0].HourStart, want) + } if rows[0].SolarWm2 == nil || *rows[0].SolarWm2 != 712.5 { - t.Errorf("SolarWm2 at 12:00 = %v, want 712.5", rows[0].SolarWm2) + t.Errorf("SolarWm2 for 11:00-12:00 = %v, want 712.5", rows[0].SolarWm2) + } + if rows[0].CloudCoverPct != nil || rows[0].TempC != nil { + t.Errorf("first interval lacks instant values at its start: cloud=%v temp=%v", rows[0].CloudCoverPct, rows[0].TempC) } - if rows[0].CloudCoverPct == nil || *rows[0].CloudCoverPct != 10.0 { - t.Errorf("CloudCoverPct = %v, want 10", rows[0].CloudCoverPct) + if rows[1].CloudCoverPct == nil || *rows[1].CloudCoverPct != 15 { + t.Errorf("CloudCoverPct for 12:00-13:00 = %v, want endpoint mean 15", rows[1].CloudCoverPct) } - if rows[2].TempC == nil || *rows[2].TempC != 15.9 { - t.Errorf("TempC[2] = %v, want 15.9", rows[2].TempC) + if rows[2].TempC == nil || *rows[2].TempC != 16.85 { + t.Errorf("TempC for 13:00-14:00 = %v, want endpoint mean 16.85", rows[2].TempC) } // PVWEstimated must be nil — this provider only emits radiation; // fetchAndStore derives PV from that. @@ -62,10 +69,10 @@ func TestOpenMeteo_ParsesRadiationAndCloud(t *testing.T) { func TestOpenMeteo_HandlesNullFields(t *testing.T) { body := `{ "hourly": { - "time": ["2026-04-17T12:00"], - "shortwave_radiation": [null], - "cloud_cover": [50.0], - "temperature_2m": [10.0] + "time": ["2026-04-17T12:00", "2026-04-17T13:00"], + "shortwave_radiation": [null, null], + "cloud_cover": [40.0, 60.0], + "temperature_2m": [10.0, 12.0] } }` srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { @@ -86,6 +93,72 @@ func TestOpenMeteo_HandlesNullFields(t *testing.T) { if rows[0].CloudCoverPct == nil || *rows[0].CloudCoverPct != 50 { t.Errorf("CloudCoverPct = %v, want 50", rows[0].CloudCoverPct) } + if rows[0].TempC == nil || *rows[0].TempC != 11 { + t.Errorf("TempC = %v, want 11", rows[0].TempC) + } +} + +func TestOpenMeteo_DoesNotMoveInstantValuesAcrossSparseGap(t *testing.T) { + body := `{"hourly":{"time":["2026-04-17T10:00","2026-04-17T12:00"],"shortwave_radiation":[100,300],"cloud_cover":[10,90],"temperature_2m":[5,25]}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + om := &OpenMeteoProvider{Client: srv.Client(), BaseURL: srv.URL} + rows, err := om.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 { + t.Fatalf("rows=%d, want 2 radiation intervals", len(rows)) + } + if want := time.Date(2026, 4, 17, 11, 0, 0, 0, time.UTC); !rows[1].HourStart.Equal(want) { + t.Fatalf("second interval starts %s, want %s", rows[1].HourStart, want) + } + if rows[1].CloudCoverPct != nil || rows[1].TempC != nil { + t.Errorf("sparse instants must not be averaged across two hours: cloud=%v temp=%v", rows[1].CloudCoverPct, rows[1].TempC) + } +} + +func TestOpenMeteo_InvalidNumbersStayMissing(t *testing.T) { + body := `{"hourly":{"time":["2026-04-17T10:00","2026-04-17T11:00","2026-04-17T12:00"],"shortwave_radiation":[0,-1,400],"cloud_cover":[20,120,40],"temperature_2m":[-10,-6,-2]}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + om := &OpenMeteoProvider{Client: srv.Client(), BaseURL: srv.URL} + rows, err := om.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + if len(rows) != 3 { + t.Fatalf("rows=%d, want 3", len(rows)) + } + if rows[1].SolarWm2 != nil || rows[1].CloudCoverPct != nil { + t.Errorf("negative radiation and out-of-range cloud must stay missing: %+v", rows[1]) + } + if rows[1].TempC == nil || *rows[1].TempC != -8 { + t.Errorf("negative air temperature is valid; got %v, want -8", rows[1].TempC) + } + if rows[2].CloudCoverPct != nil { + t.Errorf("one bad cloud endpoint must not manufacture an average: %v", rows[2].CloudCoverPct) + } +} + +func TestOpenMeteo_OverflowInOneFieldDoesNotLoseOtherFields(t *testing.T) { + body := `{"hourly":{"time":["2026-04-17T10:00","2026-04-17T11:00"],"shortwave_radiation":[0,1e309],"cloud_cover":[20,40],"temperature_2m":[10,12]}}` + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { fmt.Fprint(w, body) })) + defer srv.Close() + om := &OpenMeteoProvider{Client: srv.Client(), BaseURL: srv.URL} + rows, err := om.Fetch(context.Background(), 0, 0) + if err != nil { + t.Fatal(err) + } + if len(rows) != 2 { + t.Fatalf("rows=%d, want 2", len(rows)) + } + if rows[1].SolarWm2 != nil { + t.Errorf("overflowed radiation must stay missing: %v", rows[1].SolarWm2) + } + if rows[1].CloudCoverPct == nil || *rows[1].CloudCoverPct != 30 || rows[1].TempC == nil || *rows[1].TempC != 11 { + t.Errorf("valid fields beside bad radiation were lost: %+v", rows[1]) + } } // Non-200 responses are surfaced as errors — no silent fallback to empty diff --git a/go/internal/forecast/reliability_test.go b/go/internal/forecast/reliability_test.go new file mode 100644 index 00000000..a56a90c1 --- /dev/null +++ b/go/internal/forecast/reliability_test.go @@ -0,0 +1,62 @@ +package forecast + +import ( + "context" + "math" + "path/filepath" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/state" +) + +func TestInvalidDirectPVPreservesIndependentWeather(t *testing.T) { + for _, invalid := range []float64{-1, math.NaN(), math.Inf(1)} { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + temp := 10.0 + at := time.Now().UTC().Truncate(time.Hour) + s := &Service{Store: st, RatedPVW: 10000, Provider: staticForecastProvider{rows: []RawForecast{{HourStart: at, PVWEstimated: &invalid, TempC: &temp}}}} + if !s.fetchAndStore(context.Background()) { + t.Fatal("valid temperature row was discarded") + } + rows, err := st.LoadForecasts(at.UnixMilli(), at.Add(time.Hour).UnixMilli()) + if err != nil { + t.Fatal(err) + } + if len(rows) != 1 || rows[0].PVWEstimated != nil || rows[0].TempC == nil || *rows[0].TempC != 10 { + t.Fatalf("invalid PV became a measured zero or lost temperature: %+v", rows) + } + _ = st.Close() + } +} + +func TestUnknownPVScaleAndDCNameplateAreNotACLimits(t *testing.T) { + st, err := state.Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + defer st.Close() + at := time.Now().UTC().Truncate(time.Hour) + ghi := 1200.0 + s := &Service{Store: st, Provider: staticForecastProvider{rows: []RawForecast{{HourStart: at, SolarWm2: &ghi}}}} + s.fetchAndStore(context.Background()) + rows, _ := s.Load(at.UnixMilli(), at.Add(time.Hour).UnixMilli()) + if len(rows) != 1 || rows[0].PVWEstimated != nil { + t.Fatalf("unknown scale became a zero forecast: %+v", rows) + } + s.RatedPVW = 10000 + s.fetchAndStore(context.Background()) + rows, _ = s.Load(at.UnixMilli(), at.Add(time.Hour).UnixMilli()) + if rows[0].PVWEstimated == nil || math.Abs(*rows[0].PVWEstimated-12000) > 1e-6 { + t.Fatal("DC prior imposed an AC cap") + } + s.ACLimitW = 9000 + s.fetchAndStore(context.Background()) + rows, _ = s.Load(at.UnixMilli(), at.Add(time.Hour).UnixMilli()) + if rows[0].PVWEstimated == nil || *rows[0].PVWEstimated != 9000 { + t.Fatal("verified AC cap was ignored") + } +} diff --git a/go/internal/forecasting/contract.go b/go/internal/forecasting/contract.go new file mode 100644 index 00000000..8cf9cce7 --- /dev/null +++ b/go/internal/forecasting/contract.go @@ -0,0 +1,307 @@ +// Package forecasting defines portable forecast records and causal evaluation. +// It has no clock, telemetry, database, network or planner dependencies. +package forecasting + +import ( + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "math" + "time" +) + +const ( + Schema = 1 + MaxPoints = 192 + MaxSeries = 8 + MaxPayloadBytes = 1 << 20 + MaxModelStateBytes = 1 << 20 + + BandMethodColdStart = "cold_start_prior" + BandMethodEmpirical = "empirical" + + ModelQualityColdStart = "cold_start" + ModelQualityLearning = "learning" + ModelQualityReady = "ready" + ModelQualityWarm = "warm" +) + +// Band is an empirical central 80% prediction interval. Prior bands are +// explicitly uncalibrated; zero history never claims certainty. +type Band struct { + LowW float64 `json:"low_w"` + HighW float64 `json:"high_w"` + Method string `json:"method"` + Samples int `json:"samples"` + Days int `json:"days"` +} + +// ModelEstimateEvidence preserves a model's own provisional range. It stays +// separate from Band because it has not earned empirical coverage yet. +type ModelEstimateEvidence struct { + LowerW float64 `json:"lower_w"` + UpperW float64 `json:"upper_w"` + Uncertainty string `json:"uncertainty"` + Coverage float64 `json:"coverage"` +} + +// Point contains interval mean power in W. PV is available AC generation, +// positive here; Load excludes independently planned EV and battery flows. +// Net load is LoadW-PVW. This contract never contains hardware commands. +type Point struct { + StartMS int64 `json:"valid_start_ms"` + EndMS int64 `json:"valid_end_ms"` + PVW float64 `json:"pv_available_w"` + LoadW float64 `json:"household_load_w"` + PVKnown bool `json:"pv_known"` + LoadKnown bool `json:"load_known"` + PVQuality string `json:"pv_quality"` + LoadQuality string `json:"load_quality"` + PVBand Band `json:"pv_band"` + LoadBand Band `json:"load_band"` + NetBand Band `json:"net_band"` + ModelPV *ModelEstimateEvidence `json:"model_pv,omitempty"` + ModelLoad *ModelEstimateEvidence `json:"model_load,omitempty"` +} + +type Series struct { + Name string `json:"name"` + ModelVersion string `json:"model_version"` + Points []Point `json:"points"` +} + +type Weather struct { + StartMS int64 `json:"valid_start_ms"` + EndMS int64 `json:"valid_end_ms"` + AvailableAtMS int64 `json:"available_at_ms"` + Source string `json:"source"` + GHIWm2 *float64 `json:"ghi_w_m2,omitempty"` + DirectPVW *float64 `json:"direct_pv_w,omitempty"` + EstimatedPVW *float64 `json:"estimated_pv_w,omitempty"` + CloudPct *float64 `json:"cloud_pct,omitempty"` + TempC *float64 `json:"temp_c,omitempty"` +} + +type ModelState struct { + Name string `json:"name"` + Version string `json:"version"` + Quality string `json:"quality"` + UpdatedAtMS int64 `json:"updated_at_ms"` + StateID string `json:"state_id,omitempty"` + State json.RawMessage `json:"state,omitempty"` +} + +// SiteContext preserves the site inputs needed to replay an issued horizon. +// LearningRevision identifies the physical boundary independently of code builds. +type SiteContext struct { + SiteID string `json:"site_id"` + LearningRevision string `json:"learning_revision"` + Timezone string `json:"timezone"` + HasLocation bool `json:"has_location"` + Latitude float64 `json:"latitude"` + Longitude float64 `json:"longitude"` +} + +// Occupancy freezes one quarter's household profile as known at issue time. +// It is an input feature, not a later observation of whether anyone was home. +type Occupancy struct { + StartMS int64 `json:"valid_start_ms"` + EndMS int64 `json:"valid_end_ms"` + AvailableAtMS int64 `json:"available_at_ms"` + Home bool `json:"home"` +} + +// ValidateOccupancy bounds portable model features and rejects future knowledge. +// Empty features remain valid for historical issues that did not record them. +func ValidateOccupancy(rows []Occupancy, originMS int64) error { + if len(rows) > 512 { + return errors.New("occupancy exceeds bounded horizon") + } + var end int64 + for _, row := range rows { + if row.StartMS <= 0 || row.StartMS%900000 != 0 || row.EndMS-row.StartMS != 900000 || row.StartMS < end || row.AvailableAtMS <= 0 || row.AvailableAtMS > originMS { + return errors.New("invalid or unavailable occupancy feature") + } + end = row.EndMS + } + return nil +} + +func (s SiteContext) Validate() error { + if s.SiteID == "" || len(s.SiteID) > 128 || s.LearningRevision == "" || len(s.LearningRevision) > 128 || s.Timezone == "" || len(s.Timezone) > 128 || s.Timezone == "Local" { + return errors.New("invalid forecast site identity or timezone") + } + if _, err := time.LoadLocation(s.Timezone); err != nil { + return errors.New("invalid forecast site timezone") + } + if !finite(s.Latitude) || !finite(s.Longitude) || (s.HasLocation && (math.Abs(s.Latitude) > 90 || math.Abs(s.Longitude) > 180)) { + return errors.New("invalid forecast site location") + } + return nil +} + +// Issue freezes the inputs known at OriginMS. IssuedAtMS is when the complete +// forecast became available. A later issue never replaces this one. +type Issue struct { + Schema int `json:"schema"` + Site *SiteContext `json:"site,omitempty"` + ID string `json:"id"` + DecisionID string `json:"decision_id"` + OriginMS int64 `json:"origin_ms"` + IssuedAtMS int64 `json:"issued_at_ms"` + LatestInputMS int64 `json:"latest_input_ms"` + ConfigVersion string `json:"config_version"` + Models []ModelState `json:"models,omitempty"` + Weather []Weather `json:"weather,omitempty"` + Occupancy []Occupancy `json:"occupancy,omitempty"` + Series []Series `json:"series"` +} + +// Observation records a fully covered interval from valid, aligned readings. +// Available PV is unknown during commanded curtailment, although load may +// remain measurable. Historical rows without this evidence are not labels. +type Observation struct { + StartMS int64 `json:"valid_start_ms"` + EndMS int64 `json:"valid_end_ms"` + AvailableAtMS int64 `json:"available_at_ms"` + PVW float64 `json:"pv_available_w"` + LoadW float64 `json:"household_load_w"` + PVKnown bool `json:"pv_known"` + LoadKnown bool `json:"load_known"` + Quality string `json:"quality"` + ConfigVersion string `json:"config_version"` +} + +func finite(v float64) bool { return !math.IsNaN(v) && !math.IsInf(v, 0) } + +func validInterval(start, end int64) bool { + return start > 0 && end > start && end-start <= int64(time.Hour/time.Millisecond) +} + +func validBand(b Band) bool { + if !finite(b.LowW) || !finite(b.HighW) || b.LowW > b.HighW || b.Samples < 0 || b.Days < 0 || b.Days > b.Samples { + return false + } + switch b.Method { + case BandMethodColdStart: + return true + case BandMethodEmpirical: + return b.Samples >= 48 && b.Days >= 7 + default: + return false + } +} + +func validPoint(p Point) bool { + return validInterval(p.StartMS, p.EndMS) && + finite(p.PVW) && finite(p.LoadW) && p.PVW >= 0 && p.LoadW >= 0 && + p.PVQuality != "" && p.LoadQuality != "" && + validBand(p.PVBand) && validBand(p.LoadBand) && validBand(p.NetBand) && + validModelEstimate(p.ModelPV) && validModelEstimate(p.ModelLoad) +} + +func validModelEstimate(e *ModelEstimateEvidence) bool { + return e == nil || (finite(e.LowerW) && finite(e.UpperW) && e.LowerW >= 0 && e.LowerW <= e.UpperW && + e.Uncertainty == "provisional" && finite(e.Coverage) && e.Coverage >= 0 && e.Coverage <= 1) +} + +func (r Issue) Validate() error { + if err := ValidateOccupancy(r.Occupancy, r.OriginMS); err != nil { + return err + } + if r.Site != nil { + if err := r.Site.Validate(); err != nil { + return err + } + } + if r.Schema != Schema || r.ID == "" || len(r.ID) > 128 || len(r.DecisionID) > 128 || + r.ConfigVersion == "" || len(r.ConfigVersion) > 128 || r.OriginMS <= 0 || + r.IssuedAtMS < r.OriginMS || r.LatestInputMS < 0 || r.LatestInputMS > r.OriginMS { + return errors.New("invalid forecast issue identity or availability") + } + if len(r.Series) == 0 || len(r.Series) > MaxSeries || len(r.Weather) > MaxPoints || len(r.Models) > 8 { + return errors.New("forecast issue exceeds bounded horizon") + } + names := map[string]bool{} + for _, s := range r.Series { + if s.Name == "" || len(s.Name) > 80 || s.ModelVersion == "" || len(s.ModelVersion) > 128 || + names[s.Name] || len(s.Points) == 0 || len(s.Points) > MaxPoints { + return errors.New("invalid forecast series") + } + names[s.Name] = true + var end int64 + for _, p := range s.Points { + if !validPoint(p) || p.StartMS < end { + return fmt.Errorf("invalid interval in %s", s.Name) + } + end = p.EndMS + } + } + var weatherEnd int64 + for _, w := range r.Weather { + if !validInterval(w.StartMS, w.EndMS) || w.AvailableAtMS <= 0 || w.AvailableAtMS > r.OriginMS || + w.StartMS < weatherEnd || w.Source == "" || len(w.Source) > 128 { + return errors.New("weather unavailable at forecast origin") + } + weatherEnd = w.EndMS + if w.GHIWm2 != nil && (!finite(*w.GHIWm2) || *w.GHIWm2 < 0) { + return errors.New("invalid weather irradiance") + } + if w.DirectPVW != nil && (!finite(*w.DirectPVW) || *w.DirectPVW < 0) { + return errors.New("invalid direct provider PV") + } + if w.EstimatedPVW != nil && (!finite(*w.EstimatedPVW) || *w.EstimatedPVW < 0) { + return errors.New("invalid estimated PV") + } + if w.CloudPct != nil && (!finite(*w.CloudPct) || *w.CloudPct < 0 || *w.CloudPct > 100) { + return errors.New("invalid weather cloud cover") + } + if w.TempC != nil && !finite(*w.TempC) { + return errors.New("nonfinite weather temperature") + } + } + modelNames := map[string]bool{} + for _, m := range r.Models { + if m.Name == "" || len(m.Name) > 80 || m.Version == "" || len(m.Version) > 128 || + modelNames[m.Name] || len(m.State) > MaxModelStateBytes { + return errors.New("invalid model state") + } + modelNames[m.Name] = true + hasState := len(m.State) > 0 + hasReference := m.StateID != "" + if (hasState && !json.Valid(m.State)) || (hasReference && !validStateID(m.StateID)) || (hasState && hasReference) { + return errors.New("model state payload or SHA-256 reference is invalid") + } + switch m.Quality { + case ModelQualityColdStart: + if m.UpdatedAtMS != 0 { + return errors.New("cold-start model has learned state time") + } + case ModelQualityWarm, ModelQualityLearning, ModelQualityReady: + if m.UpdatedAtMS <= 0 || m.UpdatedAtMS > r.OriginMS || (!hasState && !hasReference) { + return errors.New("warm model state is unavailable at forecast origin") + } + default: + return errors.New("invalid model state quality") + } + } + return nil +} + +func validStateID(id string) bool { + if len(id) != 64 { + return false + } + decoded, err := hex.DecodeString(id) + return err == nil && len(decoded) == 32 +} + +func (o Observation) Validate() error { + if !validInterval(o.StartMS, o.EndMS) || o.AvailableAtMS < o.EndMS || + !finite(o.PVW) || !finite(o.LoadW) || o.PVW < 0 || o.LoadW < 0 || + o.Quality == "" || len(o.Quality) > 80 || o.ConfigVersion == "" || len(o.ConfigVersion) > 128 { + return errors.New("invalid forecast observation") + } + return nil +} diff --git a/go/internal/forecasting/contract_test.go b/go/internal/forecasting/contract_test.go new file mode 100644 index 00000000..8570e0ca --- /dev/null +++ b/go/internal/forecasting/contract_test.go @@ -0,0 +1,155 @@ +package forecasting + +import ( + "encoding/json" + "math" + "strings" + "testing" + "time" +) + +func testBand() Band { + return Band{LowW: 0, HighW: 5000, Method: BandMethodColdStart} +} + +func testPoint(start, end int64, pv, load float64) Point { + return Point{ + StartMS: start, EndMS: end, PVW: pv, LoadW: load, PVKnown: true, LoadKnown: true, + PVQuality: "measured", LoadQuality: "measured", PVBand: testBand(), LoadBand: testBand(), NetBand: testBand(), + } +} + +func testIssue(id, config, series string, origin, issued int64, points []Point) Issue { + return Issue{ + Schema: Schema, ID: id, OriginMS: origin, IssuedAtMS: issued, LatestInputMS: origin, + ConfigVersion: config, Series: []Series{{Name: series, ModelVersion: "v1", Points: points}}, + } +} + +func TestIssueRejectsUnknownOrFutureWeatherAvailability(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + issue := testIssue("i", "cfg", "champion", start-hourMS, start-hourMS, []Point{testPoint(start, start+hourMS, 100, 1000)}) + ghi, cloud, temp := 500.0, 40.0, 15.0 + issue.Weather = []Weather{{StartMS: start, EndMS: start + hourMS, AvailableAtMS: 0, Source: "open_meteo", GHIWm2: &ghi, CloudPct: &cloud, TempC: &temp}} + if err := issue.Validate(); err == nil { + t.Fatal("unknown weather receipt time must not be eligible") + } + issue.Weather[0].AvailableAtMS = issue.OriginMS + 1 + if err := issue.Validate(); err == nil { + t.Fatal("future weather receipt time must not be eligible") + } + issue.Weather[0].AvailableAtMS = issue.OriginMS + if err := issue.Validate(); err != nil { + t.Fatalf("valid weather rejected: %v", err) + } + badCloud := 101.0 + issue.Weather[0].CloudPct = &badCloud + if err := issue.Validate(); err == nil { + t.Fatal("cloud cover above 100 must be rejected") + } + issue.Weather[0].CloudPct = &cloud + badGHI := -1.0 + issue.Weather[0].GHIWm2 = &badGHI + if err := issue.Validate(); err == nil { + t.Fatal("negative irradiance must be rejected") + } + issue.Weather[0].GHIWm2 = &ghi + badPV := math.Inf(1) + issue.Weather[0].DirectPVW = &badPV + if err := issue.Validate(); err == nil { + t.Fatal("nonfinite direct provider PV must be rejected") + } +} + +func TestIssueModelStateQualityControlsTime(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + issue := testIssue("i", "cfg", "champion", start-hourMS, start-hourMS, []Point{testPoint(start, start+hourMS, 100, 1000)}) + issue.Models = []ModelState{{Name: "pv", Version: "v1", Quality: ModelQualityColdStart, State: json.RawMessage(`{}`)}} + if err := issue.Validate(); err != nil { + t.Fatalf("cold-start state rejected: %v", err) + } + issue.Models[0].State = nil + if err := issue.Validate(); err != nil { + t.Fatalf("empty cold-start model rejected: %v", err) + } + issue.Models[0].State = json.RawMessage(`{}`) + issue.Models[0].UpdatedAtMS = issue.OriginMS + if err := issue.Validate(); err == nil { + t.Fatal("cold-start state must have zero update time") + } + issue.Models[0].Quality = ModelQualityWarm + if err := issue.Validate(); err != nil { + t.Fatalf("warm state at origin rejected: %v", err) + } + issue.Models[0].UpdatedAtMS = 0 + if err := issue.Validate(); err == nil { + t.Fatal("warm state must have a positive update time") + } + issue.Models[0].UpdatedAtMS = issue.OriginMS + issue.Models[0].State = nil + issue.Models[0].StateID = strings.Repeat("a", 64) + if err := issue.Validate(); err != nil { + t.Fatalf("valid state reference rejected: %v", err) + } + issue.Models[0].State = json.RawMessage(`{}`) + if err := issue.Validate(); err == nil { + t.Fatal("payload and reference together must be rejected") + } +} + +func TestIssueRejectsUntrustedEmpiricalBand(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + point := testPoint(start, start+hourMS, 100, 1000) + point.PVBand = Band{LowW: 0, HighW: 1000, Method: BandMethodEmpirical, Samples: 47, Days: 7} + issue := testIssue("i", "cfg", "champion", start-hourMS, start-hourMS, []Point{point}) + if err := issue.Validate(); err == nil { + t.Fatal("empirical band below the sample floor must be rejected") + } + point.PVBand = Band{LowW: 0, HighW: 1000, Method: BandMethodEmpirical, Samples: 48, Days: 6} + issue.Series[0].Points[0] = point + if err := issue.Validate(); err == nil { + t.Fatal("empirical band below the independent-day floor must be rejected") + } + point.PVBand = Band{LowW: 0, HighW: math.Inf(1), Method: BandMethodColdStart} + issue.Series[0].Points[0] = point + if err := issue.Validate(); err == nil { + t.Fatal("nonfinite band must be rejected") + } +} + +func TestIssueKeepsProvisionalModelEvidenceDistinct(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + point := testPoint(start, start+hourMS, 100, 1000) + point.ModelPV = &ModelEstimateEvidence{LowerW: 50, UpperW: 180, Uncertainty: "provisional", Coverage: .75} + point.ModelLoad = &ModelEstimateEvidence{LowerW: 800, UpperW: 1200, Uncertainty: "provisional", Coverage: .5} + issue := testIssue("i", "cfg", "champion", start-hourMS, start-hourMS, []Point{point}) + if err := issue.Validate(); err != nil { + t.Fatalf("valid model evidence rejected: %v", err) + } + data, err := json.Marshal(point) + if err != nil { + t.Fatal(err) + } + text := string(data) + if !strings.Contains(text, `"model_pv"`) || !strings.Contains(text, `"model_load"`) || + !strings.Contains(text, `"pv_band"`) || !strings.Contains(text, `"load_band"`) { + t.Fatalf("model evidence and empirical bands are not distinct: %s", text) + } + point.ModelPV.Coverage = 1.01 + issue.Series[0].Points[0] = point + if err := issue.Validate(); err == nil { + t.Fatal("coverage above one must be rejected") + } + point.ModelPV.Coverage = .75 + point.ModelPV.LowerW = -1 + issue.Series[0].Points[0] = point + if err := issue.Validate(); err == nil { + t.Fatal("negative model range must be rejected") + } + point.ModelPV.LowerW = 50 + point.ModelPV.Uncertainty = "empirical" + issue.Series[0].Points[0] = point + if err := issue.Validate(); err == nil { + t.Fatal("model-native range must remain provisional") + } +} diff --git a/go/internal/forecasting/evaluate.go b/go/internal/forecasting/evaluate.go new file mode 100644 index 00000000..1d4ee806 --- /dev/null +++ b/go/internal/forecasting/evaluate.go @@ -0,0 +1,768 @@ +package forecasting + +import ( + "errors" + "math" + "sort" + "time" + + "github.com/srcfl/ftw/go/internal/sunpos" +) + +const hourMS = int64(time.Hour / time.Millisecond) + +var cumulativeHours = [...]int{1, 3, 6, 12, 24} + +// LeadBucket separates the dominant short-term and weather horizons. +func LeadBucket(origin, start int64) int { + h := float64(start-origin) / float64(hourMS) + switch { + case h < 1: + return 0 + case h < 3: + return 1 + case h < 6: + return 2 + case h < 12: + return 3 + case h < 24: + return 4 + default: + return 5 + } +} + +type ErrorSample struct { + Series string `json:"series"` + ConfigVersion string `json:"config_version"` + IssueID string `json:"issue_id"` + OriginMS int64 `json:"origin_ms"` + IssuedAtMS int64 `json:"issued_at_ms"` + StartMS int64 `json:"start_ms"` + EndMS int64 `json:"end_ms"` + AvailableAtMS int64 `json:"available_at_ms"` + Lead int `json:"lead_bucket"` + PVErrorW float64 `json:"pv_error_w"` + LoadErrorW float64 `json:"load_error_w"` + PVKnown bool `json:"pv_known"` + Daylight bool `json:"daylight"` + LoadKnown bool `json:"load_known"` + Prediction Point `json:"prediction"` +} + +func (e ErrorSample) Validate() error { + if e.Series == "" || len(e.Series) > 80 || e.ConfigVersion == "" || len(e.ConfigVersion) > 128 || + e.IssueID == "" || len(e.IssueID) > 128 || e.OriginMS <= 0 || e.IssuedAtMS < e.OriginMS || + e.IssuedAtMS > e.StartMS || !validInterval(e.StartMS, e.EndMS) || e.AvailableAtMS < e.EndMS || + e.Lead != LeadBucket(e.OriginMS, e.StartMS) || !finite(e.PVErrorW) || !finite(e.LoadErrorW) || + !validPoint(e.Prediction) || e.Prediction.StartMS != e.StartMS || e.Prediction.EndMS != e.EndMS { + return errors.New("invalid forecast error sample") + } + return nil +} + +type observationIndex map[string]map[int64][]Observation + +func indexObservations(observations []Observation, asOf int64) observationIndex { + index := make(observationIndex) + for _, o := range observations { + if o.Validate() != nil || o.AvailableAtMS > asOf { + continue + } + byStart := index[o.ConfigVersion] + if byStart == nil { + byStart = make(map[int64][]Observation) + index[o.ConfigVersion] = byStart + } + byStart[o.StartMS] = append(byStart[o.StartMS], o) + } + for _, byStart := range index { + for start := range byStart { + sort.Slice(byStart[start], func(i, j int) bool { + a, b := byStart[start][i], byStart[start][j] + if a.EndMS != b.EndMS { + return a.EndMS < b.EndMS + } + if a.AvailableAtMS != b.AvailableAtMS { + return a.AvailableAtMS < b.AvailableAtMS + } + if a.PVW != b.PVW { + return a.PVW < b.PVW + } + return a.LoadW < b.LoadW + }) + } + } + return index +} + +type coveredObservation struct { + pvWeighted float64 + loadWeighted float64 + pvKnown bool + loadKnown bool + available int64 +} + +func coverPoint(index observationIndex, config string, point Point) (coveredObservation, bool) { + byStart := index[config] + if byStart == nil { + return coveredObservation{}, false + } + type result struct { + coverage coveredObservation + ok bool + } + memo := make(map[int64]result) + var cover func(int64) result + cover = func(cursor int64) result { + if cursor == point.EndMS { + return result{coverage: coveredObservation{pvKnown: true, loadKnown: true}, ok: true} + } + if cached, ok := memo[cursor]; ok { + return cached + } + for _, o := range byStart[cursor] { + if o.EndMS > point.EndMS { + continue + } + tail := cover(o.EndMS) + if !tail.ok { + continue + } + duration := float64(o.EndMS - o.StartMS) + coverage := tail.coverage + coverage.pvWeighted += o.PVW * duration + coverage.loadWeighted += o.LoadW * duration + coverage.pvKnown = coverage.pvKnown && o.PVKnown + coverage.loadKnown = coverage.loadKnown && o.LoadKnown + coverage.available = max(coverage.available, o.AvailableAtMS) + memo[cursor] = result{coverage: coverage, ok: true} + return memo[cursor] + } + memo[cursor] = result{} + return memo[cursor] + } + r := cover(point.StartMS) + return r.coverage, r.ok +} + +func scoreAll(issues []Issue, observations []Observation, asOf int64) []ErrorSample { + index := indexObservations(observations, asOf) + out := make([]ErrorSample, 0) + for _, issue := range issues { + if issue.IssuedAtMS > asOf || issue.Validate() != nil { + continue + } + for _, series := range issue.Series { + for _, p := range series.Points { + if p.StartMS < issue.IssuedAtMS || p.EndMS > asOf { + continue + } + coverage, ok := coverPoint(index, issue.ConfigVersion, p) + if !ok { + continue + } + duration := float64(p.EndMS - p.StartMS) + pvKnown := p.PVKnown && coverage.pvKnown + loadKnown := p.LoadKnown && coverage.loadKnown + if !pvKnown && !loadKnown { + continue + } + e := ErrorSample{ + Series: series.Name, + ConfigVersion: issue.ConfigVersion, + IssueID: issue.ID, + OriginMS: issue.OriginMS, + IssuedAtMS: issue.IssuedAtMS, + StartMS: p.StartMS, + EndMS: p.EndMS, + AvailableAtMS: coverage.available, + Lead: LeadBucket(issue.OriginMS, p.StartMS), + PVErrorW: coverage.pvWeighted/duration - p.PVW, + LoadErrorW: coverage.loadWeighted/duration - p.LoadW, + PVKnown: pvKnown, + Daylight: intervalDaylight(issue, p.StartMS, p.EndMS), + LoadKnown: loadKnown, + Prediction: p, + } + if e.Validate() == nil { + out = append(out, e) + } + } + } + } + return out +} + +// intervalDaylight never uses the forecast or observed PV power to choose +// evaluation rows: a daytime zero forecast must still count as an error. +func intervalDaylight(issue Issue, start, end int64) bool { + midpoint := start + (end-start)/2 + if site := issue.Site; site != nil && site.HasLocation { + return sunpos.At(time.UnixMilli(midpoint), site.Latitude, site.Longitude).ZenithDeg < 90 + } + for _, w := range issue.Weather { + if midpoint >= w.StartMS && midpoint < w.EndMS && w.GHIWm2 != nil && *w.GHIWm2 > 20 { + return true + } + } + return false +} + +func laterIssue(a, b ErrorSample) bool { + if a.OriginMS != b.OriginMS { + return a.OriginMS > b.OriginMS + } + if a.IssuedAtMS != b.IssuedAtMS { + return a.IssuedAtMS > b.IssuedAtMS + } + return a.IssueID > b.IssueID +} + +// Errors scores only forecasts available before the entire target interval, +// and outcomes available by asOf. Partial or gapped truth is not interpolated. +// Per target/lead bucket, the latest eligible issue wins: repeated replans +// cannot create independent evidence from the same outcome. +func Errors(issues []Issue, observations []Observation, asOf int64) []ErrorSample { + type key struct { + series, config string + start, end int64 + lead int + } + chosen := make(map[key]ErrorSample) + for _, e := range scoreAll(issues, observations, asOf) { + k := key{e.Series, e.ConfigVersion, e.StartMS, e.EndMS, e.Lead} + if old, ok := chosen[k]; !ok || laterIssue(e, old) { + chosen[k] = e + } + } + out := make([]ErrorSample, 0, len(chosen)) + for _, e := range chosen { + out = append(out, e) + } + sort.Slice(out, func(i, j int) bool { + a, b := out[i], out[j] + if a.StartMS != b.StartMS { + return a.StartMS < b.StartMS + } + if a.Series != b.Series { + return a.Series < b.Series + } + if a.ConfigVersion != b.ConfigVersion { + return a.ConfigVersion < b.ConfigVersion + } + if a.Lead != b.Lead { + return a.Lead < b.Lead + } + return a.IssueID < b.IssueID + }) + return out +} + +type Metric struct { + Series string `json:"series"` + Signal string `json:"signal"` + Lead int `json:"lead_bucket"` + Samples int `json:"samples"` + Days int `json:"days"` + MAEW float64 `json:"mae_w"` + BiasW float64 `json:"bias_w"` + EnergyMAEWh float64 `json:"interval_energy_mae_wh"` + BandSamples int `json:"band_samples"` + Coverage80 float64 `json:"coverage_80"` + Pinball80 float64 `json:"pinball_10_90"` +} + +func pinball(err, q float64) float64 { + if err >= 0 { + return q * err + } + return (q - 1) * err +} + +func signalError(e ErrorSample, signal string) (err float64, known bool, band Band, prediction float64) { + switch signal { + case "pv": + return e.PVErrorW, e.PVKnown, e.Prediction.PVBand, e.Prediction.PVW + case "pv_daylight": + return e.PVErrorW, e.PVKnown && e.Daylight, e.Prediction.PVBand, e.Prediction.PVW + case "load": + return e.LoadErrorW, e.LoadKnown, e.Prediction.LoadBand, e.Prediction.LoadW + case "net": + return e.LoadErrorW - e.PVErrorW, e.LoadKnown && e.PVKnown, e.Prediction.NetBand, e.Prediction.LoadW - e.Prediction.PVW + default: + return 0, false, Band{}, 0 + } +} + +func Metrics(samples []ErrorSample) []Metric { + type accumulator struct { + metric Metric + days map[int64]bool + } + all := make(map[string]*accumulator) + for _, e := range samples { + if e.Validate() != nil { + continue + } + for _, signal := range []string{"pv", "pv_daylight", "load", "net"} { + err, known, band, prediction := signalError(e, signal) + if !known { + continue + } + key := e.Series + "/" + signal + "/" + string(rune('0'+e.Lead)) + a := all[key] + if a == nil { + a = &accumulator{metric: Metric{Series: e.Series, Signal: signal, Lead: e.Lead}, days: map[int64]bool{}} + all[key] = a + } + m := &a.metric + m.Samples++ + m.MAEW += math.Abs(err) + m.BiasW += err + m.EnergyMAEWh += math.Abs(err) * float64(e.EndMS-e.StartMS) / 3.6e6 + a.days[e.StartMS/(24*hourMS)] = true + if band.Method == BandMethodEmpirical { + m.BandSamples++ + actual := prediction + err + if actual >= band.LowW && actual <= band.HighW { + m.Coverage80++ + } + m.Pinball80 += pinball(actual-band.LowW, .1) + pinball(actual-band.HighW, .9) + } + } + } + keys := make([]string, 0, len(all)) + for k := range all { + keys = append(keys, k) + } + sort.Strings(keys) + out := make([]Metric, 0, len(keys)) + for _, k := range keys { + a := all[k] + m := a.metric + n := float64(m.Samples) + m.MAEW /= n + m.BiasW /= n + m.EnergyMAEWh /= n + m.Days = len(a.days) + if m.BandSamples > 0 { + m.Coverage80 /= float64(m.BandSamples) + m.Pinball80 /= float64(m.BandSamples) + } + out = append(out, m) + } + return out +} + +type calibrationKey struct { + series string + lead int + duration int64 + signal string +} + +type calibrationCell struct { + values []float64 + samples int + days int +} + +// Calibrator is an immutable, bounded snapshot of the residuals that were +// available at one forecast origin. Band lookups do not scan or sort history. +type Calibrator struct { + origin int64 + cells map[calibrationKey]calibrationCell +} + +// NewCalibrator keeps at most eight recently active series and 256 +// hour-aligned targets per series, lead, duration and signal. Replans for one +// target count once. Different interval lengths have separate error spreads. +func NewCalibrator(history []ErrorSample, config string, origin int64) *Calibrator { + type targetKey struct { + series string + lead int + duration int64 + start int64 + } + byTarget := make(map[targetKey]ErrorSample) + lastBySeries := make(map[string]int64) + for _, e := range history { + if e.Validate() != nil || e.ConfigVersion != config || e.AvailableAtMS > origin || + e.EndMS > origin || e.StartMS%hourMS != 0 { + continue + } + key := targetKey{e.Series, e.Lead, e.EndMS - e.StartMS, e.StartMS} + if old, ok := byTarget[key]; !ok || laterIssue(e, old) { + byTarget[key] = e + } + if e.StartMS > lastBySeries[e.Series] { + lastBySeries[e.Series] = e.StartMS + } + } + series := make([]string, 0, len(lastBySeries)) + for name := range lastBySeries { + series = append(series, name) + } + sort.Slice(series, func(i, j int) bool { + if lastBySeries[series[i]] != lastBySeries[series[j]] { + return lastBySeries[series[i]] > lastBySeries[series[j]] + } + return series[i] < series[j] + }) + if len(series) > MaxSeries { + series = series[:MaxSeries] + } + allowed := make(map[string]bool, len(series)) + for _, name := range series { + allowed[name] = true + } + type residual struct { + start int64 + value float64 + } + residuals := make(map[calibrationKey][]residual) + for key, e := range byTarget { + if !allowed[key.series] { + continue + } + for _, signal := range []string{"pv", "load", "net"} { + value, known, _, _ := signalError(e, signal) + if known { + cellKey := calibrationKey{key.series, key.lead, key.duration, signal} + residuals[cellKey] = append(residuals[cellKey], residual{key.start, value}) + } + } + } + cells := make(map[calibrationKey]calibrationCell, len(residuals)) + for key, values := range residuals { + sort.Slice(values, func(i, j int) bool { return values[i].start > values[j].start }) + if len(values) > 256 { + values = values[:256] + } + days := make(map[int64]bool) + sortedValues := make([]float64, len(values)) + for i, value := range values { + days[value.start/(24*hourMS)] = true + sortedValues[i] = value.value + } + sort.Float64s(sortedValues) + cells[key] = calibrationCell{values: sortedValues, samples: len(sortedValues), days: len(days)} + } + return &Calibrator{origin: origin, cells: cells} +} + +// Band is the one-hour compatibility form of BandForInterval. +func (c *Calibrator) Band(series, signal string, start int64, prediction float64) Band { + return c.BandForInterval(series, signal, start, start+hourMS, prediction) +} + +// BandForInterval returns a calibrated band for one target interval. The +// cold-start width still depends on this target's prediction and lead time. +func (c *Calibrator) BandForInterval(series, signal string, start, end int64, prediction float64) Band { + lead := LeadBucket(c.origin, start) + cell := c.cells[calibrationKey{series, lead, end - start, signal}] + b := Band{Samples: cell.samples, Days: cell.days} + if cell.samples < 48 || cell.days < 7 { + width := math.Max(250, math.Abs(prediction)*(.35+.05*float64(lead))) + b.LowW = prediction - width + b.HighW = prediction + width + b.Method = BandMethodColdStart + } else { + b.LowW = prediction + cell.values[int(math.Floor(.1*float64(cell.samples-1)))] + b.HighW = prediction + cell.values[int(math.Ceil(.9*float64(cell.samples-1)))] + b.Method = BandMethodEmpirical + } + if signal != "net" { + b.LowW = math.Max(0, b.LowW) + b.HighW = math.Max(0, b.HighW) + } + return b +} + +// Calibrate is the compatibility wrapper for one-off callers. Issue creation +// should build one Calibrator and reuse it across all series and slots. +func Calibrate(history []ErrorSample, series, config, signal string, origin, start int64, prediction float64) Band { + return NewCalibrator(history, config, origin).Band(series, signal, start, prediction) +} + +// CumulativeEnergySample is one net-load energy error from a single issue. +// Each interval in the window has complete load and available-PV truth. +type CumulativeEnergySample struct { + Series string `json:"series"` + ConfigVersion string `json:"config_version"` + IssueID string `json:"issue_id"` + OriginMS int64 `json:"origin_ms"` + IssuedAtMS int64 `json:"issued_at_ms"` + StartMS int64 `json:"start_ms"` + EndMS int64 `json:"end_ms"` + AvailableAtMS int64 `json:"available_at_ms"` + Lead int `json:"lead_bucket"` + Hours int `json:"hours"` + NetErrorWh float64 `json:"net_error_wh"` +} + +func (s CumulativeEnergySample) valid() bool { + validHours := false + for _, hours := range cumulativeHours { + validHours = validHours || s.Hours == hours + } + return s.Series != "" && s.ConfigVersion != "" && s.IssueID != "" && s.OriginMS > 0 && + s.IssuedAtMS >= s.OriginMS && s.IssuedAtMS <= s.StartMS && s.AvailableAtMS >= s.EndMS && + s.EndMS-s.StartMS == int64(s.Hours)*hourMS && s.Lead == LeadBucket(s.OriginMS, s.StartMS) && + validHours && finite(s.NetErrorWh) +} + +// CumulativeNetEnergy returns contiguous 1, 3, 6, 12 and 24 hour net-energy +// errors. A window always comes from one issue and starts on a UTC hour. +func CumulativeNetEnergy(issues []Issue, observations []Observation, asOf int64) []CumulativeEnergySample { + type groupKey struct { + issue, series, config string + origin, issued int64 + } + groups := make(map[groupKey][]ErrorSample) + for _, e := range scoreAll(issues, observations, asOf) { + key := groupKey{e.IssueID, e.Series, e.ConfigVersion, e.OriginMS, e.IssuedAtMS} + groups[key] = append(groups[key], e) + } + type windowKey struct { + series, config string + start, end int64 + lead, hours int + } + chosen := make(map[windowKey]CumulativeEnergySample) + for _, group := range groups { + sort.Slice(group, func(i, j int) bool { return group[i].StartMS < group[j].StartMS }) + for i := range group { + first := group[i] + if first.StartMS%hourMS != 0 { + continue + } + for _, hours := range cumulativeHours { + targetEnd := first.StartMS + int64(hours)*hourMS + cursor := first.StartMS + available := int64(0) + errorWh := 0.0 + ok := true + for j := i; cursor < targetEnd; j++ { + if j >= len(group) || group[j].StartMS != cursor || group[j].EndMS > targetEnd || + !group[j].PVKnown || !group[j].LoadKnown { + ok = false + break + } + e := group[j] + errorWh += (e.LoadErrorW - e.PVErrorW) * float64(e.EndMS-e.StartMS) / 3.6e6 + available = max(available, e.AvailableAtMS) + cursor = e.EndMS + } + if !ok || cursor != targetEnd || !finite(errorWh) { + continue + } + sample := CumulativeEnergySample{ + Series: first.Series, ConfigVersion: first.ConfigVersion, IssueID: first.IssueID, + OriginMS: first.OriginMS, IssuedAtMS: first.IssuedAtMS, StartMS: first.StartMS, + EndMS: targetEnd, AvailableAtMS: available, Lead: first.Lead, Hours: hours, NetErrorWh: errorWh, + } + k := windowKey{first.Series, first.ConfigVersion, first.StartMS, targetEnd, first.Lead, hours} + old, exists := chosen[k] + if !exists || sample.OriginMS > old.OriginMS || + (sample.OriginMS == old.OriginMS && (sample.IssuedAtMS > old.IssuedAtMS || + (sample.IssuedAtMS == old.IssuedAtMS && sample.IssueID > old.IssueID))) { + chosen[k] = sample + } + } + } + } + out := make([]CumulativeEnergySample, 0, len(chosen)) + for _, sample := range chosen { + out = append(out, sample) + } + sort.Slice(out, func(i, j int) bool { + a, b := out[i], out[j] + if a.StartMS != b.StartMS { + return a.StartMS < b.StartMS + } + if a.Series != b.Series { + return a.Series < b.Series + } + if a.Hours != b.Hours { + return a.Hours < b.Hours + } + return a.Lead < b.Lead + }) + return out +} + +type CumulativeMetric struct { + Series string `json:"series"` + ConfigVersion string `json:"config_version"` + Lead int `json:"lead_bucket"` + Hours int `json:"hours"` + Samples int `json:"samples"` + Days int `json:"days"` + MAEWh float64 `json:"mae_wh"` + BiasWh float64 `json:"bias_wh"` +} + +// CumulativeMetrics summarizes the matched-origin cumulative samples without +// mixing site config versions, lead buckets or horizons. +func CumulativeMetrics(samples []CumulativeEnergySample) []CumulativeMetric { + type key struct { + series, config string + lead, hours int + } + type accumulator struct { + metric CumulativeMetric + days map[int64]bool + } + all := make(map[key]*accumulator) + for _, sample := range samples { + if !sample.valid() { + continue + } + k := key{sample.Series, sample.ConfigVersion, sample.Lead, sample.Hours} + a := all[k] + if a == nil { + a = &accumulator{metric: CumulativeMetric{ + Series: sample.Series, ConfigVersion: sample.ConfigVersion, Lead: sample.Lead, Hours: sample.Hours, + }, days: map[int64]bool{}} + all[k] = a + } + a.metric.Samples++ + a.metric.MAEWh += math.Abs(sample.NetErrorWh) + a.metric.BiasWh += sample.NetErrorWh + a.days[sample.StartMS/(24*hourMS)] = true + } + keys := make([]key, 0, len(all)) + for k := range all { + keys = append(keys, k) + } + sort.Slice(keys, func(i, j int) bool { + a, b := keys[i], keys[j] + if a.series != b.series { + return a.series < b.series + } + if a.config != b.config { + return a.config < b.config + } + if a.hours != b.hours { + return a.hours < b.hours + } + return a.lead < b.lead + }) + out := make([]CumulativeMetric, 0, len(keys)) + for _, k := range keys { + a := all[k] + n := float64(a.metric.Samples) + a.metric.MAEWh /= n + a.metric.BiasWh /= n + a.metric.Days = len(a.days) + out = append(out, a.metric) + } + return out +} + +type PairMetric struct { + Champion string `json:"champion"` + Candidate string `json:"candidate"` + ConfigVersion string `json:"config_version"` + Signal string `json:"signal"` + Lead int `json:"lead_bucket"` + Samples int `json:"samples"` + Days int `json:"days"` + ChampionMAEW float64 `json:"champion_mae_w"` + CandidateMAEW float64 `json:"candidate_mae_w"` + DeltaMAEW float64 `json:"candidate_minus_champion_mae_w"` + CandidateWinRate float64 `json:"candidate_win_rate"` +} + +func sameActual(a, b ErrorSample, signal string) bool { + aErr, aKnown, _, aPrediction := signalError(a, signal) + bErr, bKnown, _, bPrediction := signalError(b, signal) + if !aKnown || !bKnown { + return false + } + aActual, bActual := aPrediction+aErr, bPrediction+bErr + tolerance := 1e-9 * math.Max(1, math.Max(math.Abs(aActual), math.Abs(bActual))) + return math.Abs(aActual-bActual) <= tolerance +} + +// CompareSeries scores champion and candidate only on common targets with the +// same config and lead bucket. Mismatched outcomes are excluded. +func CompareSeries(samples []ErrorSample, champion, candidate string) []PairMetric { + type targetKey struct { + config string + start, end int64 + lead int + } + championByTarget := make(map[targetKey]ErrorSample) + candidateByTarget := make(map[targetKey]ErrorSample) + for _, e := range samples { + if e.Validate() != nil || (e.Series != champion && e.Series != candidate) { + continue + } + key := targetKey{e.ConfigVersion, e.StartMS, e.EndMS, e.Lead} + target := championByTarget + if e.Series == candidate { + target = candidateByTarget + } + if old, ok := target[key]; !ok || laterIssue(e, old) { + target[key] = e + } + } + type accumulator struct { + metric PairMetric + days map[int64]bool + wins float64 + } + all := make(map[string]*accumulator) + for key, championSample := range championByTarget { + candidateSample, ok := candidateByTarget[key] + if !ok { + continue + } + for _, signal := range []string{"pv", "pv_daylight", "load", "net"} { + if !sameActual(championSample, candidateSample, signal) { + continue + } + championError, _, _, _ := signalError(championSample, signal) + candidateError, _, _, _ := signalError(candidateSample, signal) + accKey := key.config + "/" + signal + "/" + string(rune('0'+key.lead)) + a := all[accKey] + if a == nil { + a = &accumulator{metric: PairMetric{ + Champion: champion, Candidate: candidate, ConfigVersion: key.config, Signal: signal, Lead: key.lead, + }, days: map[int64]bool{}} + all[accKey] = a + } + a.metric.Samples++ + a.metric.ChampionMAEW += math.Abs(championError) + a.metric.CandidateMAEW += math.Abs(candidateError) + a.days[key.start/(24*hourMS)] = true + switch { + case math.Abs(candidateError) < math.Abs(championError): + a.wins++ + case math.Abs(candidateError) == math.Abs(championError): + a.wins += .5 + } + } + } + keys := make([]string, 0, len(all)) + for key := range all { + keys = append(keys, key) + } + sort.Strings(keys) + out := make([]PairMetric, 0, len(keys)) + for _, key := range keys { + a := all[key] + n := float64(a.metric.Samples) + a.metric.ChampionMAEW /= n + a.metric.CandidateMAEW /= n + a.metric.DeltaMAEW = a.metric.CandidateMAEW - a.metric.ChampionMAEW + a.metric.CandidateWinRate = a.wins / n + a.metric.Days = len(a.days) + out = append(out, a.metric) + } + return out +} diff --git a/go/internal/forecasting/evaluate_test.go b/go/internal/forecasting/evaluate_test.go new file mode 100644 index 00000000..c96b2025 --- /dev/null +++ b/go/internal/forecasting/evaluate_test.go @@ -0,0 +1,244 @@ +package forecasting + +import ( + "math" + "sort" + "testing" + "time" +) + +func testObservation(config string, start, end int64, pv, load float64) Observation { + return Observation{ + StartMS: start, EndMS: end, AvailableAtMS: end, PVW: pv, LoadW: load, + PVKnown: true, LoadKnown: true, Quality: "complete", ConfigVersion: config, + } +} + +func testError(series, config, issueID string, start, origin, pvError, loadError float64) ErrorSample { + startMS := int64(start) + originMS := int64(origin) + prediction := testPoint(startMS, startMS+hourMS, 100, 1000) + return ErrorSample{ + Series: series, ConfigVersion: config, IssueID: issueID, OriginMS: originMS, IssuedAtMS: originMS, + StartMS: startMS, EndMS: startMS + hourMS, AvailableAtMS: startMS + hourMS, + Lead: LeadBucket(originMS, startMS), PVErrorW: pvError, LoadErrorW: loadError, + PVKnown: true, LoadKnown: true, Prediction: prediction, + } +} + +func TestErrorsFindsMatchingObservationAmongConfigVersions(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + issue := testIssue("issue", "wanted", "champion", start-2*hourMS, start-hourMS, []Point{testPoint(start, start+hourMS, 100, 900)}) + wrong := testObservation("other", start, start+hourMS, 900, 9000) + wanted := testObservation("wanted", start, start+hourMS, 200, 1000) + for name, observations := range map[string][]Observation{"wrong first": {wrong, wanted}, "wanted first": {wanted, wrong}} { + t.Run(name, func(t *testing.T) { + errors := Errors([]Issue{issue}, observations, start+hourMS) + if len(errors) != 1 || errors[0].PVErrorW != 100 || errors[0].LoadErrorW != 100 { + t.Fatalf("matching truth was not scored: %+v", errors) + } + }) + } +} + +func TestErrorsUsesDeterministicTieBreakForSameOrigin(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + origin := start - 2*hourMS + a := testIssue("a", "cfg", "champion", origin, origin, []Point{testPoint(start, start+hourMS, 100, 900)}) + z := testIssue("z", "cfg", "champion", origin, origin, []Point{testPoint(start, start+hourMS, 300, 1100)}) + observation := testObservation("cfg", start, start+hourMS, 200, 1000) + for _, issues := range [][]Issue{{a, z}, {z, a}} { + errors := Errors(issues, []Observation{observation}, start+hourMS) + if len(errors) != 1 || errors[0].IssueID != "z" || errors[0].PVErrorW != -100 { + t.Fatalf("same-origin tie depends on input order: %+v", errors) + } + } +} + +func TestErrorSampleValidateRejectsCalibrationPoison(t *testing.T) { + start := float64(time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli()) + errorSample := testError("champion", "cfg", "i", start, start-2*float64(hourMS), 10, 20) + if err := errorSample.Validate(); err != nil { + t.Fatalf("valid sample rejected: %v", err) + } + errorSample.PVErrorW = math.NaN() + if err := errorSample.Validate(); err == nil { + t.Fatal("nonfinite error must be rejected") + } + errorSample.PVErrorW = 10 + errorSample.Lead++ + if err := errorSample.Validate(); err == nil { + t.Fatal("wrong lead bucket must be rejected") + } +} + +func TestCalibratorDeduplicatesAndRequiresSevenDays(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + history := make([]ErrorSample, 0, 120) + sixDays := make([]ErrorSample, 0, 96) + for day := 0; day < 7; day++ { + for hour := 0; hour < 8; hour++ { + start := base + int64(day*24+hour)*hourMS + latest := testError("champion", "cfg", "latest", float64(start), float64(start-2*hourMS), float64(day*10+hour), 0) + older := latest + older.IssueID = "older" + older.OriginMS -= hourMS / 2 + older.IssuedAtMS = older.OriginMS + older.Lead = LeadBucket(older.OriginMS, older.StartMS) + history = append(history, latest, older) + if day < 6 { + sixDays = append(sixDays, latest, older) + } + } + } + sort.Slice(history, func(i, j int) bool { return history[i].IssueID > history[j].IssueID }) + origin := base + 8*24*hourMS + calibrator := NewCalibrator(history, "cfg", origin) + band := calibrator.Band("champion", "pv", origin+2*hourMS, 1000) + if band.Method != BandMethodEmpirical || band.Samples != 56 || band.Days != 7 { + t.Fatalf("deduplicated seven-day calibration = %+v", band) + } + before := band + history[0].PVErrorW = 1e9 + if after := calibrator.Band("champion", "pv", origin+2*hourMS, 1000); after != before { + t.Fatalf("calibrator changed after input mutation: before=%+v after=%+v", before, after) + } + cold := NewCalibrator(sixDays, "cfg", origin).Band("champion", "pv", origin+2*hourMS, 1000) + if cold.Method != BandMethodColdStart || cold.Days >= 7 { + t.Fatalf("six dates claimed calibration: %+v", cold) + } +} + +func TestCalibratorKeepsOnlyLatest256HourlyTargets(t *testing.T) { + base := time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + history := make([]ErrorSample, 0, 400) + for i := 0; i < 400; i++ { + start := base + int64(i)*hourMS + history = append(history, testError("champion", "cfg", "i", float64(start), float64(start-2*hourMS), float64(i), 0)) + } + origin := base + 500*hourMS + band := NewCalibrator(history, "cfg", origin).Band("champion", "pv", origin+2*hourMS, 1000) + if band.Samples != 256 || band.Days < 7 { + t.Fatalf("bounded calibration cell = %+v", band) + } +} + +func TestCalibratorCalibratesQuarterHoursWithoutMixingDurations(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + quarterMS := int64(15 * time.Minute / time.Millisecond) + history := make([]ErrorSample, 0, 120) + for day := 0; day < 7; day++ { + for hour := 0; hour < 8; hour++ { + start := base + int64(day*24+hour)*hourMS + quarter := testError("champion", "cfg", "quarter-latest", float64(start), float64(start-2*hourMS), 40, 20) + quarter.EndMS = start + quarterMS + quarter.AvailableAtMS = quarter.EndMS + quarter.Prediction.EndMS = quarter.EndMS + older := quarter + older.IssueID = "quarter-older" + older.OriginMS -= quarterMS + older.IssuedAtMS = older.OriginMS + older.Lead = LeadBucket(older.OriginMS, older.StartMS) + hourly := testError("champion", "cfg", "hour", float64(start), float64(start-2*hourMS), 400, 200) + history = append(history, quarter, older, hourly) + } + } + origin := base + 8*24*hourMS + unknown := history[0] + unknown.StartMS = base + 7*24*hourMS + unknown.EndMS = unknown.StartMS + quarterMS + unknown.OriginMS = unknown.StartMS - 2*hourMS + unknown.IssuedAtMS = unknown.OriginMS + unknown.AvailableAtMS = unknown.EndMS + unknown.Prediction.StartMS, unknown.Prediction.EndMS = unknown.StartMS, unknown.EndMS + unknown.PVKnown = false + unknown.PVErrorW = -900 + unknown.Lead = LeadBucket(unknown.OriginMS, unknown.StartMS) + late := history[0] + late.StartMS = base + 7*24*hourMS + late.EndMS = late.StartMS + quarterMS + late.OriginMS = late.StartMS - 2*hourMS + late.IssuedAtMS = late.OriginMS + late.AvailableAtMS = origin + 1 + late.Prediction.StartMS, late.Prediction.EndMS = late.StartMS, late.EndMS + late.PVErrorW = -800 + late.Lead = LeadBucket(late.OriginMS, late.StartMS) + history = append(history, unknown, late) + + calibrator := NewCalibrator(history, "cfg", origin) + target := origin + 2*hourMS + quarterMS + quarterBand := calibrator.BandForInterval("champion", "pv", target, target+quarterMS, 1000) + if quarterBand.Method != BandMethodEmpirical || quarterBand.Samples != 56 || quarterBand.Days != 7 || + quarterBand.LowW != 1040 || quarterBand.HighW != 1040 { + t.Fatalf("quarter-hour calibration = %+v", quarterBand) + } + hourBand := calibrator.Band("champion", "pv", target, 1000) + if hourBand.Method != BandMethodEmpirical || hourBand.Samples != 56 || hourBand.LowW != 1400 || hourBand.HighW != 1400 { + t.Fatalf("hour calibration mixed with quarter-hour errors: %+v", hourBand) + } +} + +func TestCumulativeNetEnergyUsesOneOriginAndRejectsGaps(t *testing.T) { + start := time.Date(2026, 9, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + pointsA := make([]Point, 24) + pointsZ := make([]Point, 24) + observations := make([]Observation, 24) + for i := 0; i < 24; i++ { + at := start + int64(i)*hourMS + pointsA[i] = testPoint(at, at+hourMS, 100, 1000) + pointsZ[i] = testPoint(at, at+hourMS, 150, 1050) + observations[i] = testObservation("cfg", at, at+hourMS, 200, 1200) + } + older := testIssue("a", "cfg", "champion", start-30*hourMS, start-30*hourMS, pointsA) + later := testIssue("z", "cfg", "champion", start-25*hourMS, start-25*hourMS, pointsZ) + samples := CumulativeNetEnergy([]Issue{older, later}, observations, start+24*hourMS) + var full *CumulativeEnergySample + for i := range samples { + if samples[i].StartMS == start && samples[i].Hours == 24 { + full = &samples[i] + break + } + } + if full == nil || full.IssueID != "z" || full.NetErrorWh != 2400 { + t.Fatalf("24h matched-origin energy error = %+v", full) + } + gapped := append([]Observation(nil), observations[:5]...) + gapped = append(gapped, observations[6:]...) + for _, sample := range CumulativeNetEnergy([]Issue{later}, gapped, start+24*hourMS) { + if sample.StartMS == start && sample.Hours == 24 { + t.Fatal("gapped truth produced a 24h cumulative error") + } + } + censored := append([]Observation(nil), observations...) + censored[5].PVKnown = false + for _, sample := range CumulativeNetEnergy([]Issue{later}, censored, start+24*hourMS) { + if sample.StartMS == start && sample.Hours == 24 { + t.Fatal("censored PV truth produced a 24h net error") + } + } +} + +func TestCompareSeriesUsesOnlyMatchedTruth(t *testing.T) { + start := float64(time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli()) + champion := testError("champion", "cfg", "c", start, start-2*float64(hourMS), 100, 100) + champion.Prediction.LoadW = 900 + candidate := testError("candidate", "cfg", "n", start, start-2*float64(hourMS), -50, 50) + candidate.Prediction.PVW = 250 + candidate.Prediction.LoadW = 950 + metrics := CompareSeries([]ErrorSample{champion, candidate}, "champion", "candidate") + if len(metrics) != 3 { + t.Fatalf("paired metrics=%+v, want pv/load/net", metrics) + } + bySignal := make(map[string]PairMetric) + for _, metric := range metrics { + bySignal[metric.Signal] = metric + } + if bySignal["pv"].CandidateWinRate != 1 || bySignal["load"].CandidateWinRate != 1 || bySignal["net"].CandidateWinRate != 0 { + t.Fatalf("unexpected paired win rates: %+v", bySignal) + } + mismatch := candidate + mismatch.Prediction.PVW = 999 + if got := CompareSeries([]ErrorSample{champion, mismatch}, "champion", "candidate"); len(got) != 1 || got[0].Signal != "load" { + t.Fatalf("mismatched PV/net truth should leave load only, got %+v", got) + } +} diff --git a/go/internal/forecasting/occupancy_test.go b/go/internal/forecasting/occupancy_test.go new file mode 100644 index 00000000..0f8afda9 --- /dev/null +++ b/go/internal/forecasting/occupancy_test.go @@ -0,0 +1,32 @@ +package forecasting + +import "testing" + +func TestOccupancyRequiresBoundedCausalQuarters(t *testing.T) { + const at int64 = 1781524800000 + good := Occupancy{StartMS: at, EndMS: at + 900000, AvailableAtMS: at, Home: false} + if err := ValidateOccupancy([]Occupancy{good}, at); err != nil { + t.Fatal(err) + } + for name, mutate := range map[string]func(*Occupancy){"future": func(r *Occupancy) { r.AvailableAtMS++ }, "unknown availability": func(r *Occupancy) { r.AvailableAtMS = 0 }, "misaligned": func(r *Occupancy) { r.StartMS++; r.EndMS++ }, "wrong duration": func(r *Occupancy) { r.EndMS++ }} { + t.Run(name, func(t *testing.T) { + bad := good + mutate(&bad) + if ValidateOccupancy([]Occupancy{bad}, at) == nil { + t.Fatal("invalid occupancy accepted") + } + }) + } + if ValidateOccupancy([]Occupancy{good, good}, at) == nil { + t.Fatal("overlapping quarters accepted") + } + many := make([]Occupancy, 513) + for i := range many { + many[i] = good + many[i].StartMS += int64(i) * 900000 + many[i].EndMS += int64(i) * 900000 + } + if ValidateOccupancy(many, at) == nil { + t.Fatal("unbounded horizon accepted") + } +} diff --git a/go/internal/forecasting/site_daylight_test.go b/go/internal/forecasting/site_daylight_test.go new file mode 100644 index 00000000..dd58dba3 --- /dev/null +++ b/go/internal/forecasting/site_daylight_test.go @@ -0,0 +1,175 @@ +package forecasting + +import ( + "encoding/json" + "math" + "strings" + "testing" + "time" +) + +func testSiteContext() *SiteContext { + return &SiteContext{SiteID: "site", LearningRevision: "physical-v1", Timezone: "Europe/Stockholm", HasLocation: true, Latitude: 59.3, Longitude: 18.1} +} + +func TestIssueSiteContextAndEstimatedPVSurviveJSON(t *testing.T) { + start := time.Date(2026, 6, 15, 10, 0, 0, 0, time.UTC).UnixMilli() + issue := testIssue("i", "c", "champion", start-hourMS, start-hourMS, []Point{testPoint(start, start+hourMS, 1234, 1000)}) + issue.Site = testSiteContext() + estimated := 1234.0 + issue.Weather = []Weather{{StartMS: start, EndMS: start + hourMS, AvailableAtMS: issue.OriginMS, Source: "open_meteo", EstimatedPVW: &estimated}} + if err := issue.Validate(); err != nil { + t.Fatal(err) + } + data, err := json.Marshal(issue) + if err != nil { + t.Fatal(err) + } + var decoded Issue + if err := json.Unmarshal(data, &decoded); err != nil { + t.Fatal(err) + } + if decoded.Site == nil || *decoded.Site != *issue.Site || decoded.Weather[0].EstimatedPVW == nil || *decoded.Weather[0].EstimatedPVW != estimated { + t.Fatal("replay inputs lost") + } + for _, bad := range []float64{-1, math.NaN(), math.Inf(1)} { + issue.Weather[0].EstimatedPVW = &bad + if issue.Validate() == nil { + t.Fatal("invalid estimated PV accepted") + } + } + issue.Site = nil + issue.Weather = nil + if issue.Validate() != nil { + t.Fatal("legacy issue without site context rejected") + } +} + +func TestSiteContextRequiresReplayableIdentityClockAndCoordinates(t *testing.T) { + for _, tc := range []struct { + name string + mutate func(*SiteContext) + }{ + {"empty site", func(s *SiteContext) { s.SiteID = "" }}, + {"oversize revision", func(s *SiteContext) { s.LearningRevision = strings.Repeat("x", 129) }}, + {"host clock", func(s *SiteContext) { s.Timezone = "Local" }}, + {"missing zone", func(s *SiteContext) { s.Timezone = "" }}, + {"unknown zone", func(s *SiteContext) { s.Timezone = "unknown/place" }}, + {"latitude", func(s *SiteContext) { s.Latitude = 91 }}, + {"longitude", func(s *SiteContext) { s.Longitude = -181 }}, + {"nonfinite unused coordinate", func(s *SiteContext) { s.HasLocation = false; s.Latitude = math.NaN() }}, + } { + t.Run(tc.name, func(t *testing.T) { + s := testSiteContext() + tc.mutate(s) + if s.Validate() == nil { + t.Fatal("invalid replay context accepted") + } + }) + } + s := testSiteContext() + s.Timezone = "UTC" + s.HasLocation = false + if err := s.Validate(); err != nil { + t.Fatal(err) + } +} + +func TestDaylightMetricsIncludeZeroCandidateAndCountIndependentDays(t *testing.T) { + var issues []Issue + var observations []Observation + first := time.Date(2026, 6, 15, 0, 0, 0, 0, time.UTC) + for day := 0; day < 2; day++ { + for _, hour := range []int{0, 10} { + start := first.AddDate(0, 0, day).Add(time.Duration(hour) * time.Hour).UnixMilli() + actual := 0.0 + if hour == 10 { + actual = 1000 + } + for _, name := range []string{"champion", "candidate"} { + prediction := 0.0 + if name == "champion" && hour == 10 { + prediction = 900 + } + issue := testIssue(name+time.UnixMilli(start).String(), "cfg", name, start-hourMS, start-hourMS, []Point{testPoint(start, start+hourMS, prediction, 1000)}) + issue.Site = testSiteContext() + issues = append(issues, issue) + } + observations = append(observations, testObservation("cfg", start, start+hourMS, actual, 1000)) + } + } + samples := Errors(issues, observations, first.Add(48*time.Hour).UnixMilli()) + if len(samples) != 8 { + t.Fatalf("scored %d intervals", len(samples)) + } + var candidateDay, candidateAll Metric + for _, m := range Metrics(samples) { + if m.Series == "candidate" { + if m.Signal == "pv_daylight" { + candidateDay = m + } + if m.Signal == "pv" { + candidateAll = m + } + } + } + if candidateDay.Samples != 2 || candidateDay.Days != 2 || candidateDay.MAEW != 1000 { + t.Fatalf("daylight candidate-zero evaluation=%+v", candidateDay) + } + if candidateAll.Samples != 4 || candidateAll.Days != 2 || candidateAll.MAEW != 500 { + t.Fatalf("all-hours PV evaluation changed=%+v", candidateAll) + } + found := false + for _, m := range CompareSeries(samples, "champion", "candidate") { + if m.Signal == "pv_daylight" { + found = true + if m.CandidateWinRate != 0 || m.Samples != 2 { + t.Fatalf("daylight comparison=%+v", m) + } + } + } + if !found { + t.Fatal("daylight comparison absent") + } +} + +func TestDaylightUsesIndependentSunOrWeatherSignal(t *testing.T) { + start := time.Date(2026, 6, 15, 0, 0, 0, 0, time.UTC).UnixMilli() + ghi, pv := 500.0, 9000.0 + issue := Issue{Site: testSiteContext(), Weather: []Weather{{StartMS: start, EndMS: start + hourMS, GHIWm2: &ghi, DirectPVW: &pv, EstimatedPVW: &pv}}} + if intervalDaylight(issue, start, start+hourMS) { + t.Fatal("nighttime irradiance or PV prediction overrode sun position") + } + issue.Site = nil + if !intervalDaylight(issue, start, start+hourMS) { + t.Fatal("legacy irradiance evidence ignored") + } + ghi = 20 + if intervalDaylight(issue, start, start+hourMS) { + t.Fatal("GHI threshold is not strict") + } + issue.Weather[0].GHIWm2 = nil + if intervalDaylight(issue, start, start+hourMS) { + t.Fatal("forecast PV selected its own evaluation subset") + } +} + +func TestDaylightSubsetDoesNotChangeDefaultCalibration(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + var history []ErrorSample + for day := 0; day < 7; day++ { + for hour := 0; hour < 8; hour++ { + start := base + int64(day*24+hour)*hourMS + history = append(history, testError("champion", "cfg", "i", float64(start), float64(start-2*hourMS), float64(day*10+hour), 0)) + } + } + origin := base + 8*24*hourMS + before := NewCalibrator(history, "cfg", origin).Band("champion", "pv", origin+2*hourMS, 1000) + for i := range history { + history[i].Daylight = true + } + after := NewCalibrator(history, "cfg", origin).Band("champion", "pv", origin+2*hourMS, 1000) + if before != after || before.Method != BandMethodEmpirical || before.Samples != 56 { + t.Fatalf("daylight annotation changed calibration: before=%+v after=%+v", before, after) + } +} diff --git a/go/internal/loadmodel/learning_test.go b/go/internal/loadmodel/learning_test.go new file mode 100644 index 00000000..2c874226 --- /dev/null +++ b/go/internal/loadmodel/learning_test.go @@ -0,0 +1,118 @@ +package loadmodel + +import ( + "github.com/srcfl/ftw/go/internal/telemetry" + "math" + "testing" + "time" +) + +func TestIndependentDaysAreCadenceInvariant(t *testing.T) { + start := time.Date(2026, 1, 5, 3, 0, 0, 0, time.UTC) + var reference float64 + for _, cadence := range []time.Duration{time.Second, 10 * time.Second, time.Minute} { + m := NewModel(4000) + for day := 0; day < 10; day++ { + for elapsed := time.Duration(0); elapsed < time.Hour; elapsed += cadence { + m.Update(start.AddDate(0, 0, 7*day).Add(elapsed), 200+float64(day)*100, 20) + } + } + if got := m.Bucket[3].Days; got != 10 { + t.Fatalf("%s grants %d days", cadence, got) + } + predicted := m.Predict(start.AddDate(0, 0, 70), 20) + if reference == 0 { + reference = predicted + } else if math.Abs(reference-predicted) > 0.001 { + t.Fatalf("cadence changes structure: reference=%f got=%f", reference, predicted) + } + } +} +func TestSiteClockDSTRoutines(t *testing.T) { + loc, err := time.LoadLocation("Europe/Stockholm") + if err != nil { + t.Fatal(err) + } + m := NewModel(4000) + m.Timezone = loc.String() + winter := time.Date(2026, 3, 23, 19, 0, 0, 0, loc) + summer := time.Date(2026, 3, 30, 19, 0, 0, 0, loc) + if m.hourOfWeek(winter.UTC()) != 19 || m.hourOfWeek(summer.UTC()) != 19 { + t.Fatal("Monday evening moved with DST") + } + a := time.Date(2026, 10, 25, 0, 30, 0, 0, time.UTC) + if m.hourOfWeek(a) != m.hourOfWeek(a.Add(time.Hour)) { + t.Fatal("repeated local hour has two routine buckets") + } +} +func TestUnknownTemperaturePreservesHeatAndSkipsFit(t *testing.T) { + m := NewModel(4000) + m.HeatingW_per_degC = 100 + at := time.Date(2026, 1, 5, 3, 0, 0, 0, time.UTC) + m.Update(at, 2000, 0) + known := m.Predict(at, 0) + unknown := m.PredictNoTemp(at) + if unknown != known { + t.Fatalf("unknown removed heat: known=%f unknown=%f", known, unknown) + } + m.Update(at.Add(time.Minute), 2000, math.NaN()) + if m.HeatingW_per_degC != 100 || m.LastTemperatureC != 0 || !m.HasTemperature { + t.Fatal("unknown trained temperature") + } +} +func TestTimezoneCoverageTemperaturePersist(t *testing.T) { + st := openTestDB(t) + s := NewService(st, telemetry.NewStore(), "site", 4000, 11000) + if err := s.SetTimezone("Europe/Stockholm"); err != nil { + t.Fatal(err) + } + s.mu.Lock() + m := s.activeModelLocked() + m.HeatingW_per_degC = 100 + at := time.Date(2026, 1, 5, 18, 0, 0, 0, time.UTC) + for i := 0; i < 10; i++ { + m.Update(at.AddDate(0, 0, 7*i), 2000, 0) + } + s.mu.Unlock() + if err := s.persist(); err != nil { + t.Fatal(err) + } + restored := NewService(st, telemetry.NewStore(), "site", 4000, 11000) + if got := restored.Model(); got != s.Model() { + t.Fatalf("restart changed state: zone=%s days=%d temp=%f", got.Timezone, got.Bucket[19].Days, got.LastTemperatureC) + } + if err := restored.SetTimezone("UTC"); err != nil { + t.Fatal(err) + } + // A crash after writing the new timezone but before model persistence must + // discard the old clock model, never reinterpret its existing buckets. + again := NewService(st, telemetry.NewStore(), "site", 4000, 11000) + if again.Model().Samples != 0 { + t.Fatal("old zone data relabelled as UTC") + } +} +func TestCoverageDoesNotClaimUnseenHoursOrSeasons(t *testing.T) { + m := NewModel(4000) + at := time.Date(2026, 1, 5, 3, 0, 0, 0, time.UTC) + for i := 0; i < 8; i++ { + m.Update(at.AddDate(0, 0, 7*i), 100, 20) + } + last := at.AddDate(0, 0, 49) + if m.Coverage(last) != 1 || m.Coverage(last.Add(time.Hour)) != 0 { + t.Fatal("coverage ignored independent hour evidence") + } + if m.Coverage(last.AddDate(0, 0, 182)) >= 0.2 { + t.Fatal("stale season still trusted") + } +} +func BenchmarkLoadPredictSnapshot(b *testing.B) { + m := NewModel(4000) + m.Timezone = "Europe/Stockholm" + at := time.Now() + m.Predict(at, 5) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + m.Predict(at, 5) + } +} diff --git a/go/internal/loadmodel/model.go b/go/internal/loadmodel/model.go index 927ce647..b2fe3940 100644 --- a/go/internal/loadmodel/model.go +++ b/go/internal/loadmodel/model.go @@ -1,33 +1,4 @@ -// Package loadmodel learns a household load profile online. -// -// Design choices driven by robustness / interpretability: -// -// 1. 168 buckets — one per (weekday, hour-of-day). An EMA per bucket. -// Directly models the weekly pattern that dominates residential -// load (weekend vs weekday, morning peak, evening peak, overnight -// baseline) without having to fit non-linear basis functions. -// -// 2. Typical-home prior. Each bucket is seeded with a reasonable -// Swedish-home default (650W overnight, 2000W morning/evening -// peaks, 600W midday). Day-one predictions are useful; the model -// refines from there. -// -// 3. Trust-weighted blending. Per-bucket trust = min(samples/20, 1). -// A fresh bucket ignores its (noisy) EMA and returns the prior. -// After ~20 samples through that bucket (3 weeks of 1-sample/min -// yields ~60 samples per bucket per week), we trust observations. -// -// 4. Optional temperature correction. Outdoor temperature below 18°C -// tracks heating load in homes with electric/heat-pump heating. We -// maintain a global scalar `HeatingW_per_degC` and fit it online -// via SGD on the prediction residual against (18 − temp_c), gated -// on bucket trust. Houses unaffected by outdoor temperature (district -// heating, all-electric pure-resistive baseboards on thermostats, -// etc.) converge toward 0 W/°C. Adds 0 W when temp is unknown or -// ≥ 18°C. -// -// The fallback-on-empty behavior makes this model safe on cold boot — -// the MPC always gets a plausible load estimate, never zero or wild. +// Package loadmodel maintains the existing local household-load predictor. package loadmodel import ( @@ -38,43 +9,20 @@ import ( "github.com/srcfl/ftw/go/internal/modelstate" ) -// Buckets is the number of hour-of-week buckets: 7 days × 24 hours. const Buckets = 7 * 24 -// MinTrustSamples is how many samples we want in a bucket before we -// fully trust its EMA. Below this we blend with the prior. 8 ≈ two -// months of weekly observations, enough signal to outrank the prior. const MinTrustSamples = 8 -// HeatingReferenceC is the indoor setpoint the heating curve is -// relative to. Load proportional to max(setpoint − outdoor, 0). const HeatingReferenceC = 18.0 -// HeatingAlpha is the EMA weight applied to per-sample heating-slope -// estimates. ~0.01 picks up systematic bias within a few hundred cold -// samples (~1–2 weeks of every-15-min telemetry) while staying robust -// to noise and to the bucket↔coef joint-fit underdetermination. const HeatingAlpha = 0.01 -// HeatingMinDeltaT gates the online fit: a sample whose deltaT is too -// small (warm day, near reference) contributes too much noise via the -// 1/deltaT divisor in the SGD step. Skip it. Bucket EMA still updates. const HeatingMinDeltaT = 3.0 -// HeatingCoefMaxW is the physical upper bound for the learned slope. -// District-heating-replacement territory; well above any single-family -// home. Clamp prevents one anomalous sample from blowing up the fit. const HeatingCoefMaxW = 1500.0 -// PlausibleLoadHeadroom multiplies the main fuse capacity to get the -// point past which a reading must be a fault. Above 1.0 because a fuse -// tolerates brief overload and a meter can overshoot a step; well below -// anything a real house sustains, so a genuine 11 kW hour on a 25 A -// service is nowhere near it. const PlausibleLoadHeadroom = 1.25 -// Profile selects which learned occupancy profile is used for training -// and prediction. type Profile string const ( @@ -84,7 +32,6 @@ const ( const awayPriorScale = 0.25 -// Profiles returns the supported load-model profiles in display order. func Profiles() []Profile { return []Profile{ProfileHome, ProfileAway} } @@ -98,40 +45,40 @@ func (p Profile) valid() bool { } } -// Bucket holds one hour-of-week's learned state. type Bucket struct { - Mean float64 `json:"mean"` // EMA of observed load (W) - Samples int64 `json:"samples"` + Mean float64 `json:"mean"` // Day-weighted observed load (W) + Samples int64 `json:"samples"` + Days int64 `json:"days"` + LastDay string `json:"last_day"` + LastMs int64 `json:"last_ms"` + DaySum float64 `json:"day_sum"` + DaySamples int64 `json:"day_samples"` + PreviousMean float64 `json:"previous_mean"` } -// Model is the hour-of-week + heating-gain predictor. type Model struct { + ConfigRevision string `json:"config_revision,omitempty"` + Timezone string `json:"timezone,omitempty"` + LastTemperatureC float64 `json:"last_temperature_c"` + HasTemperature bool `json:"has_temperature"` Bucket [Buckets]Bucket `json:"bucket"` HeatingW_per_degC float64 `json:"heating_w_per_degc"` PeakW float64 `json:"peak_w"` Samples int64 `json:"samples"` LastMs int64 `json:"last_ms"` MAE float64 `json:"mae"` - Alpha float64 `json:"alpha"` // EMA coefficient for bucket updates + Alpha float64 `json:"alpha"` // Retained for state compatibility PriorScale float64 `json:"prior_scale,omitempty"` - // MaxPlausibleW is the physical ceiling a sample must fall under to be - // trained on: main fuse capacity plus headroom. Derived from configured - // hardware and never from what the model has learned, so it cannot be - // talked down by a model that has mislearned. 0 disables the check — - // the state a site with no fuse configuration is in. + // MaxPlausibleW remains for stored-state/API compatibility. Grid limits do not cap gross household load. MaxPlausibleW float64 `json:"max_plausible_w,omitempty"` } -// typicalPrior returns an approximate W load for a given hour-of-week -// based on a generic single-family Swedish home. Peak dinner around -// 18:00–19:00, morning coffee around 07:00, weekend patterns shifted -// slightly later. func typicalPrior(hourOfWeek int) float64 { weekday := hourOfWeek / 24 hour := hourOfWeek % 24 isWeekend := weekday >= 5 // Saturday (5), Sunday (6) - base := 650.0 // overnight baseload — typical Swedish house today, not 2010 + base := 650.0 // overnight baseload — typical Swedish house today, not 2010 morning := 2000.0 * math.Exp(-0.5*math.Pow(float64(hour-7)/1.2, 2)) midday := 600.0 * math.Exp(-0.5*math.Pow(float64(hour-13)/2.5, 2)) eveningH := 18.5 @@ -143,7 +90,6 @@ func typicalPrior(hourOfWeek int) float64 { return base + morning + midday + evening } -// NewModel returns a model seeded with the typical prior on every bucket. func NewModel(peakW float64) *Model { return newModel(peakW, 1) } @@ -180,50 +126,30 @@ func (m Model) prior(hourOfWeek int) float64 { return typicalPrior(hourOfWeek) * scale } -// repairPoisonedBuckets resets bucket.Mean back to the prior for any bucket -// whose stored mean has drifted below a floor of prior*poisonFloor. This -// repairs models that were trained before the heating-subtraction guard was -// in place: when heatEst exceeded actualLoad the code clamped baseSample to -// 0, causing the EMA to decay toward zero over many cold-weather samples even -// though a real baseline load (fridge, server, standby) always exists. -// -// Samples count is left intact — the data was genuinely observed, we just -// can't trust the mean it produced. Setting Samples=0 would reset trust to 0 -// and re-expose the prior, but would also trigger the exact-running-mean path -// for the next 10 samples on warm days which is acceptable. Either way the -// repaired model quickly re-learns from warm-season observations. -// -// Floor is conservative (25% of prior) so we only touch buckets that are -// clearly below any plausible real consumption — a house at 150 W overnight -// would be unusual but possible, so we preserve those. A mean of 15 W for an -// overnight bucket that has prior=650 W is unambiguously poisoned. const poisonFloor = 0.25 func (m *Model) repairPoisonedBuckets() { - for i := 0; i < Buckets; i++ { - p := m.prior(i) - if m.Bucket[i].Mean < p*poisonFloor { - m.Bucket[i].Mean = p - m.Bucket[i].Samples = 0 + for i := range m.Bucket { + if math.IsNaN(m.Bucket[i].Mean) || math.IsInf(m.Bucket[i].Mean, 0) || m.Bucket[i].Mean < 0 { + m.Bucket[i] = Bucket{Mean: m.prior(i)} } } } +func (m Model) localTime(t time.Time) time.Time { + return t.In(siteLocation(m.Timezone)) +} +func (m Model) hourOfWeek(t time.Time) int { + t = m.localTime(t) + return ((int(t.Weekday())+6)%7)*24 + t.Hour() +} -// HourOfWeek computes 0..167 for a time. Monday = 0 through Sunday. -// Coerces to UTC so the bucket index stays stable across DST -// transitions (wall-clock 19:00 maps to a different bucket in summer -// vs. winter otherwise, silently misaligning the EMA). +// HourOfWeek retains UTC indexing for older external callers. Model methods use their stored site timezone. func HourOfWeek(t time.Time) int { u := t.UTC() - // time.Weekday: Sunday=0, Saturday=6. We shift so Monday=0. wd := (int(u.Weekday()) + 6) % 7 return wd*24 + u.Hour() } -// heatingGain is the load a learned slope predicts at an outdoor -// temperature: linear in the shortfall below the reference, zero above it. -// One definition, used by both Predict and Update and probed by -// featureProbe — HeatingW_per_degC means nothing except against this shape. func heatingGain(coefWPerDegC, tempC float64) float64 { if tempC >= HeatingReferenceC { return 0 @@ -231,30 +157,8 @@ func heatingGain(coefWPerDegC, tempC float64) float64 { return coefWPerDegC * (HeatingReferenceC - tempC) } -// featureSemantics declares what the numbers this model learns from mean. It -// is the half of the fingerprint a probe cannot derive: change what the -// sampler subtracts before calling Update — stop netting out the EV, say — -// and every bucket mean is a measurement of something else, while nothing in -// the model's own code has moved. -// -// CHANGE THIS STRING in the commit that changes what a caller feeds in. -// Changes to the bucket indexing or the heating shape need no edit here — -// featureProbe moves the fingerprint on its own. -const featureSemantics = "loadmodel/1 load=site_w_less_pv_bat_ev_v2x temp=outdoor_c target=house_w" - -// featureProbe pins the two things whose change would invalidate stored -// coefficients: which bucket a moment maps to, and the shape the heating -// slope is measured against. -// -// The instants are given in a non-UTC zone and sit near midnight on purpose. -// Drop the UTC coercion in HourOfWeek and both the hour and the weekday move -// for those — which is precisely the defect commit 3255deba fixed, the one -// that silently misaligned every learned bucket across a DST change. -// -// Deliberately absent: typicalPrior. A bucket mean is measured watts and stays -// meaningful when the prior it started from is retuned; the prior only sets -// the fallback for buckets nobody has observed yet. Discarding months of -// learned buckets over a prior tweak would cost more than it protects. +const featureSemantics = "loadmodel/2 independent_days local_site_clock raw_complete_balance load=site_w_less_pv_bat_ev_v2x temp=outdoor_c target=house_w" + func featureProbe() []float64 { out := []float64{float64(Buckets), HeatingReferenceC} zone := time.FixedZone("probe", 2*60*60) @@ -277,106 +181,65 @@ var featureHash = sync.OnceValue(func() string { return modelstate.Fingerprint(featureSemantics, featureProbe()) }) -// FeatureHash fingerprints the feature space the bucket means and the heating -// slope are fitted against. Stored state is only restored when its recorded -// hash matches this one; see internal/modelstate for why, and service.go for -// what happens when it does not. func FeatureHash() string { return featureHash() } -// Predict returns the expected load (W, non-negative) at time t with -// outdoor temperature tempC (0 if unknown). Blends per-bucket EMA with -// the typical prior by sample count, then adds the heating correction. +// Predict uses site local time. NaN temperature means unknown and retains the last known heat estimate. func (m Model) Predict(t time.Time, tempC float64) float64 { - idx := HourOfWeek(t) + idx := m.hourOfWeek(t) b := m.Bucket[idx] - trust := float64(b.Samples) / MinTrustSamples - if trust > 1 { - trust = 1 - } + trust := m.Coverage(t) prior := m.prior(idx) base := trust*b.Mean + (1-trust)*prior + if math.IsNaN(tempC) || math.IsInf(tempC, 0) { + if m.HasTemperature { + tempC = m.LastTemperatureC + } else { + tempC = HeatingReferenceC + } + } y := base + heatingGain(m.HeatingW_per_degC, tempC) if math.IsNaN(y) || math.IsInf(y, 0) { y = prior } - // Same floor as restore repair: a bucket mean of 100 W overnight is - // below 25% of the typical prior and must not reach the planner. - if floor := prior * poisonFloor; y < floor { - y = floor - } if y < 0 { return 0 } - // Prefer the fuse-derived training ceiling; fall back to 3× typical - // peak only when no fuse is configured. - ceiling := m.MaxPlausibleW - if ceiling <= 0 && m.PeakW > 0 { - ceiling = 3 * m.PeakW - } - if ceiling > 0 && y > ceiling { - y = ceiling - } return y } -// PredictNoTemp is a convenience that predicts without a temperature -// signal — useful when no forecast is available. -func (m Model) PredictNoTemp(t time.Time) float64 { return m.Predict(t, HeatingReferenceC) } +func (m Model) PredictNoTemp(t time.Time) float64 { return m.Predict(t, math.NaN()) } -// Update runs one online update. Feed (now, actual_load_w, outdoor_temp_c). -// Pass 0 for tempC if unknown; we'll skip the heating fit in that case. -// Returns true when the update was applied (not filtered as an outlier). +// Update requires a valid complete electrical balance. Zero degrees is real weather; NaN is unknown. func (m *Model) Update(t time.Time, actualLoadW, tempC float64) (updated bool) { - if actualLoadW < 0 { + if actualLoadW < 0 || math.IsNaN(actualLoadW) || math.IsInf(actualLoadW, 0) || (m.LastMs > 0 && t.UnixMilli() <= m.LastMs) { return false } - // Physical bound — the only sample filter this model needs, and the - // first thing it does. A house cannot draw more than its main fuse - // passes, so a reading above it is a fault and must touch nothing: - // not the buckets, not MAE, and not the heating coefficient. Running - // it after the heating fit let one cold-weather meter fault move - // HeatingW_per_degC while Update still reported no update applied, - // and repeated faults could walk the coefficient to its ceiling. - // - // A household's real load is strongly multimodal: a few hundred watts - // of baseline for most of the day, then 11 kW when the sauna, oven and - // car overlap. Both are true readings. Nothing about a residual's size - // distinguishes "unusual but real" from "wrong", which is why this is - // the only rejection left — see the git history for the MAE band that - // used to sit below, and what it cost. - // - // Short-term noise is handled a layer down: telemetry runs a Kalman - // filter per signal and this model reads the smoothed values. - if m.MaxPlausibleW > 0 && actualLoadW > m.MaxPlausibleW { + idx := m.hourOfWeek(t) + b := &m.Bucket[idx] + if b.LastMs > 0 && t.UnixMilli() <= b.LastMs { return false } - - idx := HourOfWeek(t) - b := &m.Bucket[idx] + knownTemp := !math.IsNaN(tempC) && !math.IsInf(tempC, 0) + if knownTemp { + m.LastTemperatureC = tempC + m.HasTemperature = true + } else if m.HasTemperature { + tempC = m.LastTemperatureC + } else { + tempC = HeatingReferenceC + } predicted := m.Predict(t, tempC) err := actualLoadW - predicted - // ---- Online heating fit ---- - // Adapt HeatingW_per_degC from observed residuals before the outlier - // filter so a wildly stale coefficient can recover: every cold sample - // would otherwise look like an outlier vs the warm-day MAE, and no - // data could ever pull the coefficient down. Bucket-trust gates the - // fit because the residual derives the slope from the bucket - // baseline; an untrusted bucket would feed prior error into the - // heating estimate. - // - // SGD step on the squared-error loss: d/d(coef) ∝ −err · deltaT, - // so coef ← coef + α · err / deltaT (the 1/deltaT cancels the - // gradient's deltaT factor, giving a per-sample slope estimate). - // HeatingMinDeltaT gates near-reference samples where 1/deltaT - // amplifies noise. Clamp to [0, HeatingCoefMaxW]: floor at zero - // (heating doesn't go negative physically); a household whose load - // is unaffected by outdoor temperature gracefully settles at the - // floor. - if tempC < HeatingReferenceC-HeatingMinDeltaT && b.Samples >= MinTrustSamples { + if knownTemp && tempC < HeatingReferenceC-HeatingMinDeltaT && b.Days >= MinTrustSamples { deltaT := HeatingReferenceC - tempC - m.HeatingW_per_degC += HeatingAlpha * err / deltaT + elapsedHours := 1.0 + if m.LastMs > 0 { + elapsedHours = math.Min(1, math.Max(0, t.Sub(time.UnixMilli(m.LastMs)).Hours())) + } + alpha := 1 - math.Pow(1-HeatingAlpha, elapsedHours) + m.HeatingW_per_degC += alpha * err / deltaT if m.HeatingW_per_degC < 0 { m.HeatingW_per_degC = 0 } @@ -385,34 +248,26 @@ func (m *Model) Update(t time.Time, actualLoadW, tempC float64) (updated bool) { } } - // Bucket update: exact running mean for the first 10 samples (crisp - // early convergence), EMA after (smooth drift as the home evolves). - // Subtract the current heating-gain estimate so the bucket learns - // the "base" load — heating varies day-to-day and shouldn't smear - // into the hour-of-week signature. - // - // Guard: when the heating estimate exceeds the measured load we - // cannot cleanly isolate the base load from the heating component. - // Storing 0 would poison the bucket (the EMA decays toward 0 even - // though a real baseline — fridge, server, standby — always exists). - // Instead, skip the bucket update entirely for this sample and let - // existing Samples + Mean stand. Global Samples and MAE still update. heatEst := heatingGain(m.HeatingW_per_degC, tempC) - if heatEst < actualLoadW { + if heatEst <= actualLoadW { baseSample := actualLoadW - heatEst - if b.Samples < 10 { - b.Mean = (b.Mean*float64(b.Samples) + baseSample) / float64(b.Samples+1) - } else { - b.Mean = (1-m.Alpha)*b.Mean + m.Alpha*baseSample + day := m.localTime(t).Format("2006-01-02") + if day != b.LastDay { + b.Days++ + b.LastDay = day + b.PreviousMean = b.Mean + b.DaySum = 0 + b.DaySamples = 0 } + b.DaySum += baseSample + b.DaySamples++ b.Samples++ + // Average within a day before applying its weight to the weekly hour. + // Polling more often cannot give that day more structural influence. + weight := 1 / math.Min(float64(b.Days), 10) + b.Mean = (1-weight)*b.PreviousMean + weight*b.DaySum/float64(b.DaySamples) + b.LastMs = t.UnixMilli() } - // Heating coefficient is adapted online above. The operator value - // (Planner.HeatingWPerDegC) seeds the initial estimate and is also - // applied on /api/loadmodel/reset; from there observation drives the - // fit. For a household whose load doesn't track temperature, the - // coefficient converges toward zero — which matches the user-visible - // guarantee "the model uses what it sees". m.Samples++ m.LastMs = t.UnixMilli() @@ -424,20 +279,17 @@ func (m *Model) Update(t time.Time, actualLoadW, tempC float64) (updated bool) { return true } -// Quality reports confidence in [0, 1]. Roughly: what fraction of -// buckets have enough samples to be trusted, weighted by MAE. func (m Model) Quality() float64 { if m.PeakW <= 0 { return 0 } var warm int for i := 0; i < Buckets; i++ { - if m.Bucket[i].Samples >= MinTrustSamples { + if m.Bucket[i].Days >= MinTrustSamples { warm++ } } coverage := float64(warm) / float64(Buckets) - // Accuracy factor based on MAE vs peak. accuracy := 0.0 if m.Samples > 0 { rel := m.MAE / m.PeakW @@ -447,5 +299,31 @@ func (m Model) Quality() float64 { accuracy = 1 - (rel-0.05)/0.45 } } - return 0.5*coverage + 0.5*accuracy + return coverage * accuracy +} + +var locationCache sync.Map + +func siteLocation(zone string) *time.Location { + if loc, ok := locationCache.Load(zone); ok { + return loc.(*time.Location) + } + loc, err := time.LoadLocation(zone) + if err != nil { + loc = time.UTC + } + locationCache.Store(zone, loc) + return loc +} + +// Coverage measures independent local days at this hour. Unseen seasons lose +// trust after thirty days without observations; training error alone is not trust. +func (m Model) Coverage(t time.Time) float64 { + b := m.Bucket[m.hourOfWeek(t)] + trust := math.Min(1, float64(b.Days)/MinTrustSamples) + if b.LastMs > 0 { + ageDays := t.Sub(time.UnixMilli(b.LastMs)).Hours() / 24 + trust *= math.Exp(-math.Max(0, ageDays-30) / 60) + } + return trust } diff --git a/go/internal/loadmodel/model_test.go b/go/internal/loadmodel/model_test.go index 2556fc41..d3778017 100644 --- a/go/internal/loadmodel/model_test.go +++ b/go/internal/loadmodel/model_test.go @@ -41,33 +41,23 @@ func synthetic(t time.Time) float64 { return base + morning + midday + evening } -func TestPredictFloorsHundredWattOvernight(t *testing.T) { - // Operator report: overnight forecast sat at ~100 W on a lived-in - // house. 100 W is below 25% of the typical 650 W night prior and - // must not reach the planner, even when the bucket is fully trusted. +func TestPredictAllowsHundredWattOvernight(t *testing.T) { m := NewModel(5520) - night := time.Date(2026, 8, 18, 3, 0, 0, 0, time.UTC) - idx := HourOfWeek(night) - m.Bucket[idx].Mean = 100 - m.Bucket[idx].Samples = 40 - got := m.Predict(night, HeatingReferenceC) - floor := typicalPrior(idx) * poisonFloor - if got < floor { - t.Fatalf("100 W night must lift to prior×0.25 (%.0f W), got %.0f W", floor, got) + at := time.Date(2026, 8, 18, 3, 0, 0, 0, time.UTC) + idx := HourOfWeek(at) + m.Bucket[idx] = Bucket{Mean: 100, Samples: 40, Days: 8} + if got := m.Predict(at, HeatingReferenceC); math.Abs(got-100) > 0.001 { + t.Fatalf("valid low load raised to %.0f W", got) } } -func TestPredictCapsHeatingAtFuse(t *testing.T) { +func TestPredictDoesNotCapHouseAtGridFuse(t *testing.T) { m := NewModel(5520) m.MaxPlausibleW = 11000 - m.HeatingW_per_degC = HeatingCoefMaxW - midday := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) - got := m.Predict(midday, -20) - if got > 11000 { - t.Fatalf("heating add-on must not exceed the fuse ceiling, got %.0f W", got) - } - if got < 1000 { - t.Fatalf("cold midday should still predict real load, got %.0f W", got) + m.HeatingW_per_degC = 500 + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + if got := m.Predict(at, -20); got <= 11000 { + t.Fatalf("gross house capped by grid fuse: %.0f", got) } } @@ -161,18 +151,17 @@ func TestRejectsNegativeLoad(t *testing.T) { // it needs the physical ceiling set, which production wires from the fuse // configuration. The band version of this check also rejected genuine // household peaks; see TestFullHouseholdRangeIsTrained. -func TestRejectsOutliers(t *testing.T) { +func TestRejectsNonfiniteWithoutChangingModel(t *testing.T) { m := NewModel(4000) - m.MaxPlausibleW = 17250 - start := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) - for i := 0; i < 200; i++ { - m.Update(start.Add(time.Duration(i)*time.Minute), 1500, HeatingReferenceC) + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + before := *m + for _, w := range []float64{math.NaN(), math.Inf(1), math.Inf(-1)} { + if m.Update(at, w, HeatingReferenceC) { + t.Fatal("nonfinite accepted") + } } - preMean := m.Bucket[HourOfWeek(start)].Mean - m.Update(start.Add(500*time.Minute), 50000, HeatingReferenceC) // 33× typical - postMean := m.Bucket[HourOfWeek(start.Add(500*time.Minute))].Mean - if math.Abs(postMean-preMean) > 500 { - t.Errorf("outlier should be rejected, mean drift %.0f", postMean-preMean) + if *m != before { + t.Fatal("invalid observation changed model") } } @@ -237,7 +226,7 @@ func TestNightBucketNotPoisonedByHeatingSubtraction(t *testing.T) { // Feed 30 warm-weather samples at the real baseline (350 W, temp 20°C), // same hour-of-week as t0 so the bucket we predict actually moves. for i := 0; i < 30; i++ { - m.Update(t0.Add(time.Duration(i)*7*24*time.Hour), 350, 20.0) + m.Update(t0.Add(time.Duration(301+i*7)*24*time.Hour), 350, 20.0) } trainedPred := m.Predict(t0, 20.0) if math.Abs(trainedPred-350) > 100 { @@ -248,44 +237,19 @@ func TestNightBucketNotPoisonedByHeatingSubtraction(t *testing.T) { // TestRepairPoisonedBuckets verifies that repairPoisonedBuckets resets bucket // means that are clearly below the prior floor while leaving healthy buckets // untouched. -func TestRepairPoisonedBuckets(t *testing.T) { +func TestRepairOnlyInvalidBuckets(t *testing.T) { m := NewModel(5520) - m.HeatingW_per_degC = 300 - - // Artificially poison night bucket (3:00 UTC Monday) the old way: - // drain it to ~0 with many zero-valued EMA updates. - nightIdx := HourOfWeek(time.Date(2026, 1, 5, 3, 0, 0, 0, time.UTC)) - m.Bucket[nightIdx].Mean = 5.0 - m.Bucket[nightIdx].Samples = 260 - - // Set a healthy evening bucket (19:00 UTC Monday) to its proper value. - eveningIdx := HourOfWeek(time.Date(2026, 1, 5, 19, 0, 0, 0, time.UTC)) - m.Bucket[eveningIdx].Mean = 2200 - m.Bucket[eveningIdx].Samples = 260 - + m.Bucket[3] = Bucket{Mean: 5, Samples: 260, Days: 8} + m.Bucket[19] = Bucket{Mean: math.Inf(1), Samples: 10} m.repairPoisonedBuckets() - - nightPrior := typicalPrior(nightIdx) - if m.Bucket[nightIdx].Mean < nightPrior*poisonFloor { - t.Errorf("poisoned bucket not repaired: got %.0f W, want >= %.0f W", - m.Bucket[nightIdx].Mean, nightPrior*poisonFloor) + if m.Bucket[3].Mean != 5 || m.Bucket[3].Days != 8 { + t.Fatal("repair erased real low load") } - if m.Bucket[nightIdx].Samples != 0 { - t.Errorf("repaired bucket samples should be reset to 0, got %d", m.Bucket[nightIdx].Samples) - } - - // Evening bucket must be preserved — 2200 W is above floor. - if m.Bucket[eveningIdx].Mean != 2200 { - t.Errorf("healthy bucket should be untouched: got %.0f W, want 2200 W", m.Bucket[eveningIdx].Mean) + if m.Bucket[19].Samples != 0 || math.IsInf(m.Bucket[19].Mean, 0) { + t.Fatal("invalid bucket not reset") } } -// TestHeatingCoefLearnsFromMeasurements — a household whose load grows with -// the heating-degrees signal should converge to roughly the true sensitivity -// from measurements alone. The old behaviour was operator-only: coef stayed -// at whatever the human typed in (or 0 if untyped). With online adaptation, -// the model uses what it observes — including across mixed warm/cold days -// where the warm days anchor the bucket baseline. func TestHeatingCoefLearnsFromMeasurements(t *testing.T) { const trueBase = 800.0 const trueCoef = 250.0 // W per °C below 18°C @@ -378,34 +342,26 @@ func TestHeatingFitWaitsForBucketTrust(t *testing.T) { // overlap — and nothing about a residual's size separates "unusual but // real" from "wrong". Short-term noise is already handled by the Kalman // filter in telemetry, one layer down. -func TestSustainedLevelShiftIsLearned(t *testing.T) { +func TestSustainedLevelShiftNeedsIndependentDays(t *testing.T) { m := NewModel(10000) - m.MaxPlausibleW = 17000 - start := time.Date(2026, 7, 1, 2, 0, 0, 0, time.UTC) - - // Two quiet days — under the old filter this is what armed a band so - // narrow that the house could never be learned. - n := 0 - for ; n < 2*24*60; n++ { - m.Update(start.Add(time.Duration(n)*time.Minute), 400, HeatingReferenceC) + at := time.Date(2026, 7, 1, 2, 0, 0, 0, time.UTC) + for i := 0; i < 8; i++ { + if !m.Update(at.Add(time.Duration(i)*time.Minute), 3000, HeatingReferenceC) { + t.Fatal("valid level rejected") + } } - - trainedFrom := n - for i := 0; i < 3*24*60; i++ { - m.Update(start.Add(time.Duration(n)*time.Minute), 3000, HeatingReferenceC) - n++ + b := m.Bucket[HourOfWeek(at)] + if b.Days != 1 { + t.Fatalf("eight minutes granted %d days", b.Days) } - - for i := trainedFrom; i < n; i += 60 { - got := m.Predict(start.Add(time.Duration(i)*time.Minute), HeatingReferenceC) - if math.Abs(got-3000) > 300 { - t.Fatalf("bucket at minute %d predicts %.0f W, want ~3000 W", i, got) - } + for i := 1; i < 10; i++ { + m.Update(at.AddDate(0, 0, i*7), 3000, HeatingReferenceC) + } + if got := m.Predict(at.AddDate(0, 0, 70), HeatingReferenceC); math.Abs(got-3000) > 100 { + t.Fatalf("persistent level not learned: %.0f", got) } } -// A house that goes from near-idle to 11 kW is doing something ordinary, -// not reporting a fault. That whole range has to reach the model. func TestFullHouseholdRangeIsTrained(t *testing.T) { m := NewModel(8000) m.MaxPlausibleW = 17250 // 25 A × 3 × 230 V @@ -425,26 +381,15 @@ func TestFullHouseholdRangeIsTrained(t *testing.T) { // its main fuse passes. Because the bound comes from configured hardware // rather than from what the model has learned, it holds from the first // sample and a mislearned model cannot talk it down. -func TestImplausibleLoadRejected(t *testing.T) { +func TestGrossLoadAboveFuseAccepted(t *testing.T) { m := NewModel(4000) - m.MaxPlausibleW = 11000 * PlausibleLoadHeadroom // 16 A service - t0 := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) - - if m.Update(t0, 50000, HeatingReferenceC) { - t.Error("50 kW past a 16 A service should never be accepted") - } - if m.Samples != 0 { - t.Errorf("rejected sample must not count, samples = %d", m.Samples) - } - // Right at the service limit is high but real — a fuse passes its - // rating, so this has to train. - if !m.Update(t0, 11000, HeatingReferenceC) { - t.Error("a load at the service limit should be accepted") + m.MaxPlausibleW = 11000 + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + if !m.Update(at, 15000, HeatingReferenceC) { + t.Fatal("15kW house with PV support rejected by 11kW grid fuse") } } -// No fuse configured means no defensible ceiling, so the check disables -// itself rather than inventing one. func TestNoFuseConfiguredTrainsEverything(t *testing.T) { m := NewModel(4000) t0 := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) @@ -489,47 +434,14 @@ func TestSpikeIsDampedByTheBucketEMA(t *testing.T) { // is gated on that bucket's trust, so a fault landing in a fresh bucket // would be filtered by the gate rather than by the bound, and the test // would pass either way without proving anything. -func TestImplausibleLoadDoesNotMoveHeatingCoefficient(t *testing.T) { +func TestInvalidLoadDoesNotMoveHeatingCoefficient(t *testing.T) { m := NewModel(4000) - m.MaxPlausibleW = 11000 start := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) - const coldC = 0.0 // well past HeatingMinDeltaT - - // Warm the bucket past MinTrustSamples so the fit is ungated, and hold - // the load below the learned mean so the residual — and therefore the - // coefficient — is driven somewhere a fault could visibly move it. for i := 0; i < 20; i++ { - m.Update(start.Add(time.Duration(i)*time.Minute), 1200, coldC) - } - idx := HourOfWeek(start) - if m.Bucket[idx].Samples < MinTrustSamples { - t.Fatalf("warmup left the bucket untrusted (%d samples) — the fit would be gated, not bounded", - m.Bucket[idx].Samples) - } - - before := m.HeatingW_per_degC - beforeMAE := m.MAE - beforeSamples := m.Samples - - // Faults in the SAME bucket, so only the bound can stop them. - for i := 20; i < 60; i++ { - at := start.Add(time.Duration(i) * time.Minute) - if HourOfWeek(at) != idx { - t.Fatalf("sample %d escaped the bucket under test", i) - } - if m.Update(at, 50000, coldC) { - t.Fatal("an implausible reading was accepted") - } - } - - if m.HeatingW_per_degC != before { - t.Errorf("heating coefficient moved on rejected faults: %.4f → %.4f", - before, m.HeatingW_per_degC) - } - if m.MAE != beforeMAE { - t.Errorf("MAE moved on rejected faults: %.1f → %.1f", beforeMAE, m.MAE) + m.Update(start.AddDate(0, 0, 7*i), 1200, 0) } - if m.Samples != beforeSamples { - t.Errorf("sample count moved on rejected faults: %d → %d", beforeSamples, m.Samples) + before := *m + if m.Update(start.AddDate(0, 0, 150), math.Inf(1), 0) || *m != before { + t.Fatal("invalid reading changed trained model") } } diff --git a/go/internal/loadmodel/persistence_test.go b/go/internal/loadmodel/persistence_test.go index f0a7b370..3b613830 100644 --- a/go/internal/loadmodel/persistence_test.go +++ b/go/internal/loadmodel/persistence_test.go @@ -60,7 +60,7 @@ func requireLegacyAdoption(t *testing.T) { // purpose, and moving it would restore pre-envelope coefficients under the // new features, which is the exact fault this guards against. func TestFeatureHashPinned(t *testing.T) { - const want = "f79385ff0412d66b" + const want = "f2c6a746704f8ab0" if got := FeatureHash(); got != want { t.Errorf("load feature hash = %q, pinned at %q\n"+ "the feature definition changed: every deployed site will cold-start", got, want) diff --git a/go/internal/loadmodel/reconfigure_test.go b/go/internal/loadmodel/reconfigure_test.go new file mode 100644 index 00000000..9d8385e1 --- /dev/null +++ b/go/internal/loadmodel/reconfigure_test.go @@ -0,0 +1,91 @@ +package loadmodel + +import ( + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func TestReconfigureBindsEveryProfileAndSurvivesRestart(t *testing.T) { + st := openTestDB(t) + s := NewService(st, telemetry.NewStore(), "site", 4000, 0) + opts := telemetry.ForecastOptions{} + if err := s.Reconfigure("site", opts, "Europe/Stockholm", "a"); err != nil { + t.Fatal(err) + } + at := time.Now() + for _, p := range Profiles() { + s.models[p].Update(at, 300, 5) + } + if err := s.persist(); err != nil { + t.Fatal(err) + } + restarted := NewService(st, telemetry.NewStore(), "site", 4000, 0) + if err := restarted.Reconfigure("site", opts, "Europe/Stockholm", "a"); err != nil { + t.Fatal(err) + } + for _, p := range Profiles() { + if restarted.models[p].Samples != 1 { + t.Fatalf("same binding lost %s", p) + } + } + if err := restarted.Reconfigure("new-meter", opts, "Europe/Stockholm", "b"); err != nil { + t.Fatal(err) + } + for _, p := range Profiles() { + if m := restarted.models[p]; m.Samples != 0 || m.ConfigRevision != "b" { + t.Fatalf("old profile survived: %s", p) + } + } + // A partial save cannot bless a profile from the prior electrical boundary. + restarted.models[ProfileAway].ConfigRevision = "a" + restarted.models[ProfileAway].Update(at, 9999, 0) + if err := restarted.persist(); err != nil { + t.Fatal(err) + } + partial := NewService(st, telemetry.NewStore(), "new-meter", 4000, 0) + partial.models[ProfileHome].Update(at, 200, 5) + if err := partial.Reconfigure("new-meter", opts, "Europe/Stockholm", "b"); err != nil { + t.Fatal(err) + } + for _, p := range Profiles() { + if partial.models[p].Samples != 0 { + t.Fatalf("mixed saved revisions retained %s", p) + } + } +} + +func TestReconfigureRejectsTrainingCapturedAtPriorBoundary(t *testing.T) { + tel := telemetry.NewStore() + tel.Update("site", telemetry.DerMeter, 1000, nil, nil) + tel.RecordDriverSuccess("site") + s := NewService(nil, tel, "site", 4000, 0) + if err := s.Reconfigure("site", telemetry.ForecastOptions{}, "UTC", "a"); err != nil { + t.Fatal(err) + } + captured, release, done := make(chan struct{}), make(chan struct{}), make(chan struct{}) + s.Temp = func(time.Time) (float64, bool) { close(captured); <-release; return 5, true } + go func() { defer close(done); s.sampleAt(time.Now()) }() + <-captured + if err := s.Reconfigure("site", telemetry.ForecastOptions{HouseholdInvalidReason: "changed topology"}, "UTC", "b"); err != nil { + t.Fatal(err) + } + close(release) + <-done + if s.Model().Samples != 0 { + t.Fatal("old balance trained new topology") + } +} + +func TestResetKeepsConfigBinding(t *testing.T) { + s := NewService(nil, telemetry.NewStore(), "site", 4000, 0) + if err := s.Reconfigure("site", telemetry.ForecastOptions{}, "UTC", "a"); err != nil { + t.Fatal(err) + } + s.models[ProfileAway].Update(time.Now(), 300, 5) + s.Reset() + if s.Model().ConfigRevision != "a" || s.models[ProfileAway].Samples != 1 { + t.Fatal("user reset changed binding or inactive profile") + } +} diff --git a/go/internal/loadmodel/service.go b/go/internal/loadmodel/service.go index 27fef030..2e9a2dd5 100644 --- a/go/internal/loadmodel/service.go +++ b/go/internal/loadmodel/service.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "log/slog" + "math" "strings" "sync" "time" @@ -65,9 +66,14 @@ type Service struct { SampleInterval time.Duration PersistEvery int64 - mu sync.RWMutex - active Profile - models map[Profile]*Model + mu sync.RWMutex + persistMu sync.Mutex + generation uint64 + active Profile + models map[Profile]*Model + forecastOptions telemetry.ForecastOptions + timezone string + lastForecastInput time.Time stop chan struct{} done chan struct{} @@ -85,10 +91,11 @@ func NewService(st *state.Store, tel *telemetry.Store, siteMeter string, peakW, done: make(chan struct{}), active: ProfileHome, models: make(map[Profile]*Model), + timezone: "UTC", } for _, profile := range Profiles() { s.models[profile] = newProfileModel(peakW, profile) - s.models[profile].MaxPlausibleW = maxPlausibleW + s.models[profile].MaxPlausibleW = 0 } if st != nil { loadedProfiles := make(map[Profile]bool) @@ -121,6 +128,26 @@ func NewService(st *state.Store, tel *telemetry.Store, siteMeter string, peakW, } } } + if st != nil { + if zone, ok := st.LoadConfig("loadmodel/timezone"); ok { + if _, err := time.LoadLocation(zone); err == nil { + s.timezone = zone + } + } + for _, profile := range Profiles() { + old := s.models[profile] + zone := old.Timezone + if zone == "" { + zone = "UTC" + } + if old.Samples > 0 && zone != s.timezone { + m := newProfileModel(old.PeakW, profile) + m.HeatingW_per_degC = old.HeatingW_per_degC + s.models[profile] = m + } + s.models[profile].Timezone = s.timezone + } + } return s } @@ -133,6 +160,8 @@ func (s *Service) SetSiteMeter(name string) { } s.mu.Lock() s.SiteMeter = name + s.generation++ + s.lastForecastInput = time.Time{} s.mu.Unlock() } @@ -159,13 +188,12 @@ func restoreModel(js string, peakW, maxPlausibleW float64, profile Profile) *Mod "stored_hash", res.StoredHash, "current_hash", FeatureHash()) return nil } - m.PeakW = peakW // config may have changed - m.MaxPlausibleW = maxPlausibleW // ditto — fuse size is editable + m.PeakW = peakW // config may have changed + m.MaxPlausibleW = 0 // Grid fuse limits do not bound gross house load. if m.PriorScale <= 0 { m.PriorScale = newProfileModel(peakW, profile).PriorScale } - // Repair any bucket means that were poisoned by the pre-guard bug where - // heating-subtracted samples were clamped to 0 and stored in the EMA. + // Repair nonfinite or negative stored means; retain valid low readings. m.repairPoisonedBuckets() return &m } @@ -239,12 +267,12 @@ func (s *Service) activeModelLocked() *Model { // Predict is the MPC's integration point — expected load at time t. // If a temperature source is wired, the heating-gain correction is -// included; otherwise we predict assuming indoor setpoint (no heating). +// included; unknown weather retains the last known heat estimate. func (s *Service) Predict(t time.Time) float64 { if s == nil { return 0 } - temp := HeatingReferenceC + temp := math.NaN() if s.Temp != nil { if v, ok := s.Temp(t); ok { temp = v @@ -269,7 +297,7 @@ func (s *Service) PredictWith(t time.Time, profile Profile) float64 { if !profile.valid() { return s.Predict(t) } - temp := HeatingReferenceC + temp := math.NaN() if s.Temp != nil { if v, ok := s.Temp(t); ok { temp = v @@ -324,85 +352,104 @@ func (s *Service) loop(ctx context.Context) { } } -func (s *Service) driverOnline(name string) bool { - if s == nil || s.Tele == nil { - return false - } - h := s.Tele.DriverHealth(name) - return h != nil && h.IsOnline() -} - -// sample computes measured house load = grid_w - pv_w - bat_w - ev_w - v2x_w -// and feeds it to the model. Skips when drivers haven't settled yet -// (no site meter reading). EV is subtracted so the weekly-pattern -// learner tracks house consumption, not "house + occasional 10 kWh -// car session"; V2X is also subtracted because it is vehicle storage, -// not household demand, whether charging or discharging. -func (s *Service) sample() { - s.sampleAt(time.Now()) +// SetForecastOptions supplies the configured electrical measurement topology. +func (s *Service) SetForecastOptions(opts telemetry.ForecastOptions) { + s.mu.Lock() + defer s.mu.Unlock() + opts.ExpectedFlows = append([]telemetry.ForecastFlow(nil), opts.ExpectedFlows...) + s.forecastOptions = opts + s.generation++ } -func (s *Service) sampleAt(now time.Time) { - s.mu.RLock() - siteMeter := s.SiteMeter - s.mu.RUnlock() - meter := s.Tele.Get(siteMeter, telemetry.DerMeter) - if meter == nil { - slog.Debug("loadmodel: skip (no site meter yet)") - return +// Reconfigure binds every profile to the same electrical and clock boundary. +// The binding lives inside each saved model. A crash after saving only some +// profiles leaves a mismatch, which causes a full cold start at the next bind. +func (s *Service) Reconfigure(siteMeter string, opts telemetry.ForecastOptions, zone, revision string) error { + if s == nil { + return nil } - if !s.driverOnline(siteMeter) { - slog.Debug("loadmodel: skip (site meter offline)", "driver", siteMeter) - return + if revision == "" { + return fmt.Errorf("loadmodel config revision is empty") } - gridW := meter.SmoothedW - var pvW, batW float64 - for _, r := range s.Tele.ReadingsByType(telemetry.DerPV) { - if !s.driverOnline(r.Driver) { - continue + if _, err := time.LoadLocation(zone); err != nil { + return err + } + opts.ExpectedFlows = append([]telemetry.ForecastFlow(nil), opts.ExpectedFlows...) + s.mu.Lock() + changed := s.SiteMeter != siteMeter || s.timezone != zone + for _, p := range Profiles() { + if s.models[p] == nil || s.models[p].ConfigRevision != revision { + changed = true } - pvW += r.SmoothedW // site-sign: negative = generating } - for _, r := range s.Tele.ReadingsByType(telemetry.DerBattery) { - if !s.driverOnline(r.Driver) { - continue + s.SiteMeter, s.timezone, s.forecastOptions = siteMeter, zone, opts + s.generation++ + s.lastForecastInput = time.Time{} + if changed { + peak := s.activeModelLocked().PeakW + for _, p := range Profiles() { + m := newProfileModel(peak, p) + m.Timezone, m.ConfigRevision = zone, revision + s.models[p] = m } - batW += r.SmoothedW // site-sign: positive = charging - } - evW := s.Tele.SumOnlineEVW() // online-only so stale readings don't poison load - v2xW := s.Tele.SumOnlineV2XW() // signed: +charging, -discharging - loadW := gridW - pvW - batW - evW - v2xW - if loadW < 0 { - // Almost always a transient — during a PI step the measured - // flow can briefly appear negative. Skip rather than train - // on a physically impossible value. - slog.Debug("loadmodel: skip (neg load)", "grid_w", gridW, "pv_w", pvW, "bat_w", batW, "ev_w", evW, "v2x_w", v2xW) - return } + s.mu.Unlock() + return s.persist() +} - // Outdoor temp for heating-fit. HeatingReferenceC = "no contribution". - temp := HeatingReferenceC +// SetTimezone uses one site clock for all model calls, independent of caller zones. +// Changing the zone discards the old clock buckets; their meanings changed. +func (s *Service) SetTimezone(zone string) error { + if _, err := time.LoadLocation(zone); err != nil { + return err + } + s.mu.Lock() + if s.timezone != zone { + s.timezone = zone + s.generation++ + for _, p := range Profiles() { + old := s.models[p] + m := newProfileModel(old.PeakW, p) + m.Timezone = zone + m.HeatingW_per_degC = old.HeatingW_per_degC + s.models[p] = m + } + } + s.mu.Unlock() + if s.Store != nil { + return s.Store.SaveConfig("loadmodel/timezone", zone) + } + return nil +} +func (s *Service) sample() { s.sampleAt(time.Now()) } +func (s *Service) sampleAt(now time.Time) { + if s.Tele == nil { + return + } + s.mu.RLock() + site, opts, profile, generation := s.SiteMeter, s.forecastOptions, s.active, s.generation + s.mu.RUnlock() + reading := s.Tele.ForecastMeasurement(now, site, opts) + temp := math.NaN() if s.Temp != nil { - if v, ok := s.Temp(now); ok { - temp = v + if value, ok := s.Temp(now); ok { + temp = value } } - s.mu.Lock() - profile := s.active + if s.active != profile || s.SiteMeter != site || s.generation != generation { + s.mu.Unlock() + return + } model := s.activeModelLocked() - updated := model.Update(now, loadW, temp) + updated := false + if reading.Valid && reading.Latest.After(s.lastForecastInput) { + s.lastForecastInput = reading.Latest + updated = model.Update(now, reading.HouseholdW, temp) + } samples := model.Samples - mae := model.MAE - heating := model.HeatingW_per_degC s.mu.Unlock() - - slog.Info("loadmodel: sample", - "profile", profile, "load_w", loadW, "temp_c", temp, - "samples", samples, "mae_w", mae, - "heat_w_per_c", heating, "updated", updated) - - if updated && samples%s.PersistEvery == 0 { + if updated && s.PersistEvery > 0 && samples%s.PersistEvery == 0 { if err := s.persist(); err != nil { slog.Warn("loadmodel persist", "err", err) } @@ -417,11 +464,14 @@ func (s *Service) persistProfile(profile Profile) error { } func (s *Service) persist() error { + s.persistMu.Lock() + defer s.persistMu.Unlock() if s.Store == nil { return nil } s.mu.RLock() active := s.active + zone := s.timezone models := make(map[Profile]string, len(s.models)) for _, profile := range Profiles() { if s.models[profile] == nil { @@ -435,6 +485,9 @@ func (s *Service) persist() error { models[profile] = string(js) } s.mu.RUnlock() + if err := s.Store.SaveConfig("loadmodel/timezone", zone); err != nil { + return err + } if err := s.Store.SaveConfig(profileStateKey, string(active)); err != nil { return err } @@ -502,6 +555,10 @@ func (s *Service) Reset() { heating := old.HeatingW_per_degC s.models[profile] = newProfileModel(peak, profile) s.models[profile].HeatingW_per_degC = heating + s.models[profile].Timezone = s.timezone + s.models[profile].ConfigRevision = old.ConfigRevision + s.generation++ + s.lastForecastInput = time.Time{} s.mu.Unlock() if err := s.persist(); err != nil { slog.Warn("loadmodel persist", "err", err) diff --git a/go/internal/loadmodel/service_test.go b/go/internal/loadmodel/service_test.go index 9b6e2664..f02d9116 100644 --- a/go/internal/loadmodel/service_test.go +++ b/go/internal/loadmodel/service_test.go @@ -1,7 +1,6 @@ package loadmodel import ( - "math" "path/filepath" "testing" "time" @@ -60,7 +59,7 @@ func TestProfileSwitchTrainsOnlyActiveProfile(t *testing.T) { tel.RecordDriverSuccess("site") s := NewService(nil, tel, "site", 4000, 17250) - now := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + now := time.Now() s.sampleAt(now) if err := s.SetProfile(ProfileAway); err != nil { @@ -68,7 +67,7 @@ func TestProfileSwitchTrainsOnlyActiveProfile(t *testing.T) { } tel.Update("site", telemetry.DerMeter, 200, nil, nil) tel.RecordDriverSuccess("site") - s.sampleAt(now.Add(time.Hour)) + s.sampleAt(time.Now()) snap := s.Snapshot() if snap.ActiveProfile != ProfileAway { @@ -124,29 +123,22 @@ func TestSampleRequiresOnlineSiteMeter(t *testing.T) { } } -func TestSampleUsesOnlyOnlineDERsAndSubtractsEV(t *testing.T) { +func TestSampleRejectsMissingDERs(t *testing.T) { tel := telemetry.NewStore() - tel.Update("site", telemetry.DerMeter, 1000, nil, nil) + tel.Update("site", telemetry.DerMeter, 4000, nil, nil) tel.RecordDriverSuccess("site") - - tel.Update("pv-offline", telemetry.DerPV, -700, nil, nil) - tel.DriverHealthMut("pv-offline").SetOffline() - tel.Update("bat-offline", telemetry.DerBattery, -200, nil, nil) - tel.DriverHealthMut("bat-offline").SetOffline() - - tel.Update("charger", telemetry.DerEV, 300, nil, nil) - tel.RecordDriverSuccess("charger") - - s := NewService(nil, tel, "site", 4000, 17250) - now := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) - s.sampleAt(now) - + tel.Update("battery", telemetry.DerBattery, 3000, nil, nil) + tel.DriverHealthMut("battery").SetOffline() + s := NewService(nil, tel, "site", 4000, 11000) + s.sampleAt(time.Now()) + if s.Model().Samples != 0 { + t.Fatal("missing battery trained 4kW as house load") + } + tel.RecordDriverSuccess("battery") + tel.SetDriverCommandFault("battery", true, "refused") + s.sampleAt(time.Now()) m := s.Model() - if m.Samples != 1 { - t.Fatalf("samples = %d, want 1", m.Samples) - } - got := m.Bucket[HourOfWeek(now)].Mean - if math.Abs(got-700) > 1 { - t.Fatalf("bucket mean = %.1f, want house load 700 W", got) + if m.Samples != 1 || m.Bucket[m.hourOfWeek(time.Now())].Mean != 1000 { + t.Fatalf("fresh command fault dropped real battery flow: %+v", m) } } diff --git a/go/internal/mpc/energyplan_test.go b/go/internal/mpc/energyplan_test.go index 1bc99070..2020e0d8 100644 --- a/go/internal/mpc/energyplan_test.go +++ b/go/internal/mpc/energyplan_test.go @@ -9,6 +9,8 @@ import ( "sync/atomic" "testing" "time" + + "github.com/srcfl/ftw/go/internal/state" ) func TestValidatePlanRejectsEVOverCapacity(t *testing.T) { @@ -58,9 +60,17 @@ func TestNativeEnergyplanDownsideAndAsyncShadow(t *testing.T) { svc := shadowTestService(t) svc.Optimizer = &EnergyplanOptimizer{ExternalOptimizer: o} info, err := svc.Optimizer.(*EnergyplanOptimizer).Health(context.Background()) - if err != nil || info.Name != "ftw-solver" || info.Version != "0.1.2" { + if err != nil || info.Name != "ftw-solver" || info.Version != "0.2.0" { t.Fatalf("bundled worker health: %+v %v", info, err) } + start := time.Now().UTC().Truncate(time.Hour) + cloud := 10.0 + for i := 0; i < 4; i++ { + if err := svc.Store.SaveForecasts([]state.ForecastPoint{{SlotTsMs: start.Add(time.Duration(i) * time.Hour).UnixMilli(), SlotLenMin: 60, + FetchedAtMs: start.UnixMilli(), Source: "test", CloudCoverPct: &cloud}}); err != nil { + t.Fatal(err) + } + } svc.PVUncertaintyW = func() float64 { return 200 } svc.PVForecastSafetyK = 1 svc.PV = func(time.Time, float64) float64 { return 1500 } diff --git a/go/internal/mpc/forecast_snapshot.go b/go/internal/mpc/forecast_snapshot.go new file mode 100644 index 00000000..b0449cab --- /dev/null +++ b/go/internal/mpc/forecast_snapshot.go @@ -0,0 +1,41 @@ +package mpc + +import ( + "time" + + "github.com/srcfl/ftw/go/internal/state" +) + +// ForecastInputs owns one frozen model/weather view for a whole plan. The +// host captures state once; slot inference does not read a changing model. +type ForecastInputs struct { + Weather []state.ForecastPoint + PV PVPredictor + PVResidualCorrect PVResidualCorrector + Load LoadPredictor + PVWeight func(time.Time) float64 + PVUncertaintyW float64 + PVRelativeUncertainty float64 + // Risk may replace the legacy PV margin using calibrated joint net errors. + // It must preserve slot times/prices/limits and never add forecast PV. + Risk func(base, planning []Slot, k float64) + // Record runs only for a published plan, outside the service lock. + // Implementations enqueue bounded immutable work instead of disk/network I/O. + Record func(base, planning []Slot, decisionID string, issuedAtMS int64) +} + +const ForecastMaxAge = 12 * time.Hour + +// usableForecasts rejects weather unavailable at the decision origin and rows +// whose cache age exceeds policy. Unknown receipt time cannot establish +// that cached weather was available and fresh at the decision. +func usableForecasts(rows []state.ForecastPoint, nowMS int64) []state.ForecastPoint { + out := make([]state.ForecastPoint, 0, len(rows)) + for _, r := range rows { + if r.FetchedAtMs <= 0 || r.FetchedAtMs > nowMS || nowMS-r.FetchedAtMs > ForecastMaxAge.Milliseconds() { + continue + } + out = append(out, r) + } + return out +} diff --git a/go/internal/mpc/optimizer_transport.go b/go/internal/mpc/optimizer_transport.go index 0550977f..a0c6c051 100644 --- a/go/internal/mpc/optimizer_transport.go +++ b/go/internal/mpc/optimizer_transport.go @@ -113,7 +113,7 @@ func (t *ProcessTransport) RoundTrip(ctx context.Context, payload []byte) ([]byt t.scheduleIdleStopLocked() return nil, err } - if _, err := t.stdin.Write(append(append([]byte(nil), payload...), '\n')); err != nil { + if err := t.writeLocked(ctx, payload); err != nil { t.stopLocked() return nil, fmt.Errorf("write optimizer request: %w", err) } @@ -143,7 +143,7 @@ func (t *ProcessTransport) Health(ctx context.Context) (OptimizerRuntimeInfo, er "type": "handshake", "protocol_version": OptimizerProtocolVersion, }) - if _, err := t.stdin.Write(append(payload, '\n')); err != nil { + if err := t.writeLocked(ctx, payload); err != nil { t.stopLocked() return OptimizerRuntimeInfo{}, fmt.Errorf("write optimizer handshake: %w", err) } @@ -161,6 +161,33 @@ func (t *ProcessTransport) Health(ctx context.Context) (OptimizerRuntimeInfo, er return info, nil } +// writeLocked keeps a worker that stops reading stdin inside the caller's +// deadline. Closing and killing the process releases a blocked pipe write; we +// then wait for the writer so no request buffer or goroutine survives the call. +func (t *ProcessTransport) writeLocked(ctx context.Context, payload []byte) error { + frame := make([]byte, len(payload)+1) + copy(frame, payload) + frame[len(payload)] = '\n' + stdin := t.stdin + written := make(chan error, 1) + go func() { + n, err := stdin.Write(frame) + if err == nil && n != len(frame) { + err = io.ErrShortWrite + } + written <- err + }() + + select { + case err := <-written: + return err + case <-ctx.Done(): + t.stopLocked() + <-written + return ctx.Err() + } +} + // errOptimizerWorkerMissing marks the absence of the bundled Python worker // interpreter in this build. The containerized core ships no Python — the // optimizer runs as the separate ftw-optimizer sidecar — so a missing diff --git a/go/internal/mpc/optimizer_transport_test.go b/go/internal/mpc/optimizer_transport_test.go index 3db17a54..f13049b5 100644 --- a/go/internal/mpc/optimizer_transport_test.go +++ b/go/internal/mpc/optimizer_transport_test.go @@ -2,6 +2,7 @@ package mpc import ( "bufio" + "bytes" "context" "encoding/json" "errors" @@ -87,6 +88,58 @@ func TestProcessTransportRejectsCanceledContextBeforeWorkerLookup(t *testing.T) } } +func TestProcessTransportWriteCancellationRestartsWorker(t *testing.T) { + if len(os.Args) >= 2 && os.Args[len(os.Args)-2] == "process-write-helper" { + marker := os.Args[len(os.Args)-1] + first, err := os.OpenFile(marker, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) + if err == nil { + _ = first.Close() + // The first worker never reads stdin. Its parent must kill it when the + // request deadline expires and the pipe write is still blocked. + time.Sleep(10 * time.Second) + return + } + if !errors.Is(err, os.ErrExist) { + os.Exit(2) + } + scanner := bufio.NewScanner(os.Stdin) + if scanner.Scan() { + _, _ = os.Stdout.WriteString(`{"ok":true}` + "\n") + } + return + } + + marker := t.TempDir() + "/worker-started" + transport, err := NewProcessTransport(ProcessTransportConfig{ + Command: []string{os.Args[0], "-test.run=TestProcessTransportWriteCancellationRestartsWorker", "--", "process-write-helper", marker}, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = transport.Close() }) + + ctx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond) + started := time.Now() + _, err = transport.RoundTrip(ctx, bytes.Repeat([]byte("x"), 2<<20)) + cancel() + if !errors.Is(err, context.DeadlineExceeded) { + t.Fatalf("RoundTrip error = %v, want context.DeadlineExceeded", err) + } + if elapsed := time.Since(started); elapsed > 2*time.Second { + t.Fatalf("blocked write returned after %v, want at most 2s", elapsed) + } + + restartCtx, restartCancel := context.WithTimeout(context.Background(), 2*time.Second) + defer restartCancel() + response, err := transport.RoundTrip(restartCtx, []byte(`{}`)) + if err != nil { + t.Fatalf("RoundTrip after canceled write: %v", err) + } + if string(response) != `{"ok":true}` { + t.Fatalf("RoundTrip after canceled write = %s, want healthy worker response", response) + } +} + func TestUnixTransportHandshakeAndRoundTrip(t *testing.T) { path := fmt.Sprintf("/tmp/ftw-opt-%d.sock", time.Now().UnixNano()) t.Cleanup(func() { _ = os.Remove(path) }) diff --git a/go/internal/mpc/service.go b/go/internal/mpc/service.go index e04d2d87..976fa21f 100644 --- a/go/internal/mpc/service.go +++ b/go/internal/mpc/service.go @@ -84,14 +84,14 @@ type Service struct { Interval time.Duration PV PVPredictor // optional — overrides stored pv_w_estimated PVResidualCorrect PVResidualCorrector // optional — additive short-horizon bias on top of PV - // PVNameplateW is the site PV ceiling (W). Forecast and plan PV - // above this are cut to the nameplate so a kWp-as-watts paste - // cannot schedule megawatts. 0 disables the cut. + ForecastSnapshot func(time.Time, []state.ForecastPoint) ForecastInputs + // PVNameplateW accepts a verified AC generation ceiling. A configured + // DC rating or learned scale is not a hard limit. Zero disables the cut. PVNameplateW float64 Load LoadPredictor // optional — overrides flat BaseLoad - // LoadMaxW is the site fuse ceiling (W). Slot and published load - // forecasts are hard-cut to this so a wild twin cannot plan 50 kW - // of house load. 0 disables the upper cut. + // LoadMaxW is an independently verified gross-load limit, not the + // grid fuse: local generation may supply load above grid import. + // Zero disables the upper cut. LoadMaxW float64 // Optimizer is the external mathematical planning engine. Nil — the // default since #1020 — makes the in-process Go DP the champion. When @@ -252,6 +252,7 @@ type Service struct { // running on a forecast the twins have since corrected away from. type plannedPredictions struct { pv []float64 // per-slot W (magnitude, ≥ 0) + pvCovered []bool // the issued plan had weather for this PV sample load []float64 // per-slot W (≥ 0) slotStart []time.Time // slot-start timestamps for re-sampling builtAt time.Time @@ -993,8 +994,8 @@ func (s *Service) checkDivergence(ctx context.Context) { // grid so the twin-drift detector can later re-sample at the same // timestamps and compute RMSE. Returns nil when neither predictor is // wired — twin-drift is a no-op in that case. -func (s *Service) snapshotPredictions(slots []Slot, forecasts []state.ForecastPoint) *plannedPredictions { - if s == nil || (s.PV == nil && s.Load == nil) { +func (s *Service) snapshotPredictions(slots []Slot, forecasts []state.ForecastPoint, pvFn PVPredictor, loadFn LoadPredictor) *plannedPredictions { + if s == nil || (pvFn == nil && loadFn == nil) { return nil } horizon := s.TwinDriftHorizonSlots @@ -1009,24 +1010,36 @@ func (s *Service) snapshotPredictions(slots []Slot, forecasts []state.ForecastPo return nil } pp := &plannedPredictions{ - pv: make([]float64, n), - load: make([]float64, n), slotStart: make([]time.Time, n), builtAt: time.Now(), } + if pvFn != nil { + pp.pv = make([]float64, n) + pp.pvCovered = make([]bool, n) + } + if loadFn != nil { + pp.load = make([]float64, n) + } for i := 0; i < n; i++ { ts := time.UnixMilli(slots[i].StartMs).UTC() pp.slotStart[i] = ts - if s.PV != nil { - cloud := lookupCloud(forecasts, slots[i].StartMs) - pv := s.PV(ts, cloud) - if math.IsNaN(pv) || math.IsInf(pv, 0) || pv < 0 { - pv = 0 + if pvFn != nil { + _, directInput := lookupPVInput(forecasts, slots[i].StartMs) + cloud, cloudInput := lookupCloudInput(forecasts, slots[i].StartMs) + if directInput == nil && cloudInput == nil { + // The plan did not call the twin without a covered weather + // interval, so this slot has no model-drift baseline either. + } else { + pp.pvCovered[i] = true + pv := pvFn(ts, cloud) + if math.IsNaN(pv) || math.IsInf(pv, 0) || pv < 0 { + pv = 0 + } + pp.pv[i] = pv } - pp.pv[i] = pv } - if s.Load != nil { - ld := s.Load(ts) + if loadFn != nil { + ld := loadFn(ts) if math.IsNaN(ld) || math.IsInf(ld, 0) || ld < 0 { ld = 0 } @@ -1082,17 +1095,20 @@ func (s *Service) checkTwinDrift(ctx context.Context) { var pvSumSq, loadSumSq float64 pvCount, loadCount := 0, 0 for i, ts := range pp.slotStart { - if pvFn != nil && pvThresh > 0 { - cloud := lookupCloud(forecasts, ts.UnixMilli()) - pv := pvFn(ts, cloud) - if math.IsNaN(pv) || math.IsInf(pv, 0) || pv < 0 { - pv = 0 + if pvFn != nil && pvThresh > 0 && len(pp.pv) == len(pp.slotStart) { + covered := len(pp.pvCovered) == 0 || (len(pp.pvCovered) == len(pp.slotStart) && pp.pvCovered[i]) + if covered { + cloud := lookupCloud(forecasts, ts.UnixMilli()) + pv := pvFn(ts, cloud) + if math.IsNaN(pv) || math.IsInf(pv, 0) || pv < 0 { + pv = 0 + } + d := pv - pp.pv[i] + pvSumSq += d * d + pvCount++ } - d := pv - pp.pv[i] - pvSumSq += d * d - pvCount++ } - if loadFn != nil && loadThresh > 0 { + if loadFn != nil && loadThresh > 0 && len(pp.load) == len(pp.slotStart) { ld := loadFn(ts) if math.IsNaN(ld) || math.IsInf(ld, 0) || ld < 0 { ld = 0 @@ -1360,14 +1376,23 @@ func (s *Service) runReplan(request replanRequest) *Plan { slog.Warn("mpc: load forecasts", "err", err) // continue without PV forecast } + forecasts = usableForecasts(forecasts, now.UnixMilli()) forecasts = clampForecastPV(forecasts, s.PVNameplateW) - slots := buildSlots(prices, forecasts, s.BaseLoad, now.UnixMilli(), s.PV, s.PVResidualCorrect, s.Load) + pv, correct, load := s.PV, s.PVResidualCorrect, s.Load + var captured ForecastInputs + if s.ForecastSnapshot != nil { + captured = s.ForecastSnapshot(now, forecasts) + pv, correct, load = captured.PV, captured.PVResidualCorrect, captured.Load + if captured.Weather != nil { + forecasts = captured.Weather + } + } + slots := buildSlots(prices, forecasts, s.BaseLoad, now.UnixMilli(), pv, correct, load, captured.PVWeight) slots = capSlotsPVToNameplate(slots, s.PVNameplateW) slots = capSlotsLoad(slots, 0, s.LoadMaxW) - if recent := recentDailyLoadWh(s.Store, now, loadRainCheckDays); recent > 0 { - slots = rainCheckLoadSlots(slots, recent, s.LoadMaxW) - } + // Qualified load models own their level. Unqualified historic daily + // totals must not impose a floor on a changed or low-load household. if len(slots) == 0 { return nil } @@ -1391,6 +1416,9 @@ func (s *Service) runReplan(request replanRequest) *Plan { if pvRelative != nil { pvRelativeUncertainty = pvRelative() } + if s.ForecastSnapshot != nil { + pvUncertaintyW, pvRelativeUncertainty = captured.PVUncertaintyW, captured.PVRelativeUncertainty + } // Plumb the site fuse + export ceiling into per-slot limits so the DP // joint-plans battery + EV under the grid constraints instead of @@ -1434,14 +1462,17 @@ func (s *Service) runReplan(request replanRequest) *Plan { p.MinArbitrageSpreadOreKwh = s.MinArbitrageSpreadOreKwh p.ExportFloorOreKwh = s.ExportFloorOreKwh p.PVForecastSafetyK = s.PVForecastSafetyK - if pvUncertainty != nil { + if pvUncertainty != nil || s.ForecastSnapshot != nil { p.PVUncertaintyW = pvUncertaintyW } - if pvRelative != nil { + if pvRelative != nil || s.ForecastSnapshot != nil { p.PVRelativeUncertainty = pvRelativeUncertainty } applyPVDownsidePerSlot(fallbackSlots, p.PVForecastSafetyK, p.PVRelativeUncertainty, p.PVUncertaintyW) + if captured.Risk != nil { + captured.Risk(slots, fallbackSlots, p.PVForecastSafetyK) + } // Default terminal valuation. Mode-dependent because self-consumption // is a constrained game: the battery can only offset local load, not @@ -1705,7 +1736,7 @@ func (s *Service) runReplan(request replanRequest) *Plan { // timestamps buildSlots used. forecasts cloud lookup mirrors the // path buildSlots takes for the PV predictor so the snapshot is // apples-to-apples with what's re-sampled later. - pp := s.snapshotPredictions(slots, forecasts) + pp := s.snapshotPredictions(slots, forecasts, pv, load) s.mu.Lock() if s.stopping || request.wasCanceledByService() { @@ -1737,6 +1768,9 @@ func (s *Service) runReplan(request replanRequest) *Plan { replanAtMs := s.lastReplanAt.UnixMilli() saveDiag := s.SaveDiag s.mu.Unlock() + if captured.Record != nil { + captured.Record(slots, fallbackSlots, plan.DecisionID, replanAtMs) + } // Horizon statistics — surfaced in logs so operators can // reconstruct "what did the DP know?" without pulling the full // Diagnostic JSON. Captures the three factors most likely to @@ -1951,7 +1985,7 @@ func extendPricesWithForecast(prices []state.PricePoint, zone string, pricer Pri // that the forecast service stored at fetch time. This lets the model // learn system-specific orientation/shading/soiling and drive planning // off the better signal without re-fetching weather. -func buildSlots(prices []state.PricePoint, forecasts []state.ForecastPoint, baseLoad float64, nowMs int64, pv PVPredictor, pvCorrect PVResidualCorrector, load LoadPredictor) []Slot { +func buildSlots(prices []state.PricePoint, forecasts []state.ForecastPoint, baseLoad float64, nowMs int64, pv PVPredictor, pvCorrect PVResidualCorrector, load LoadPredictor, weights ...func(time.Time) float64) []Slot { out := make([]Slot, 0, len(prices)) now := time.UnixMilli(nowMs).UTC() for _, pr := range prices { @@ -1976,20 +2010,30 @@ func buildSlots(prices []state.PricePoint, forecasts []state.ForecastPoint, base if pv != nil { cloud, cloudInput := lookupCloudInput(forecasts, pr.SlotTsMs) weatherInput = cloudInput - radiationBacked := lookupHasRadiation(forecasts, pr.SlotTsMs) - base := pv(slotT, cloud) - if pvCorrect != nil { - // Correction returns generation-positive W (same as `base`). - // Floor the corrected base at 0 — a residual large enough - // to push it negative is a sign-flip, not a plausible PV - // prediction. - corrected := base + pvCorrect(now, slotMidT, base) - if corrected < 0 { - corrected = 0 + if forecastInput == nil && cloudInput == nil { + // A learned model may refine a covered weather row. It cannot + // turn a missing provider interval into valid forecast PV. + pvW = 0 + } else { + radiationBacked := lookupHasRadiation(forecasts, pr.SlotTsMs) + base := pv(slotT, cloud) + if pvCorrect != nil { + // Correction returns generation-positive W (same as `base`). + // Floor the corrected base at 0 — a residual large enough + // to push it negative is a sign-flip, not a plausible PV + // prediction. + corrected := base + pvCorrect(now, slotMidT, base) + if corrected < 0 { + corrected = 0 + } + base = corrected } - base = corrected + weight := PlannerRadiationWeight + if len(weights) > 0 && weights[0] != nil { + weight = weights[0](slotT) + } + pvW = selectPlannerPVWithWeight(forecastPVW, base, radiationBacked, weight) } - pvW = selectPlannerPVW(forecastPVW, base, radiationBacked) } else { weatherInput = forecastInput pvW = forecastPVW @@ -2191,73 +2235,34 @@ func upperHalfMeanPrice(prices []state.PricePoint) float64 { // non-representative training data). const PlannerRadiationWeight = 0.3 -// PlannerForecastCapRatio caps how much the radiation-backed forecast may -// exceed the twin's prediction before it's treated as a NWP error rather -// than a calibration gap. -// -// When the NWP model is confidently wrong (e.g. predicts 1% cloud while -// the site measures 300 W from a 13 kW array), the forecast can be 5–10× -// higher than reality. The RLS twin — especially when its NowAnchor -// correction has pulled it close to the live reading — is a more reliable -// signal in those moments. Capping the forecast at this multiple prevents -// the 70 % NWP weight from swamping the calibrated twin. -// -// 3× is chosen empirically: it covers a 2–3 string orientation difference -// and a heavy soiling scenario, which are legitimate reasons for the twin -// to under-predict relative to the NWP GHI × rated-kWp estimate. Beyond -// 3× the NWP forecast is more likely wrong (cloud/shading mis-model) than -// the twin is. This constant is intentionally conservative — tightening -// it below ~2 risks degrading performance on normal sunny days where the -// forecast is right and the twin is under-trained. -const PlannerForecastCapRatio = 3.0 - func selectPlannerPVW(forecastPVW, predictedPVW float64, radiationBacked bool) float64 { - // Invalid predicted → fall back to forecast (unchanged). - switch { - case math.IsNaN(predictedPVW), math.IsInf(predictedPVW, 0), predictedPVW < 0: - if math.IsNaN(forecastPVW) || math.IsInf(forecastPVW, 0) { + return selectPlannerPVWithWeight(forecastPVW, predictedPVW, radiationBacked, PlannerRadiationWeight) +} + +func selectPlannerPVWithWeight(forecastPVW, predictedPVW float64, radiationBacked bool, weight float64) float64 { + if math.IsNaN(forecastPVW) || math.IsInf(forecastPVW, 0) || forecastPVW < 0 { + forecastPVW = 0 + } + if math.IsNaN(predictedPVW) || math.IsInf(predictedPVW, 0) || predictedPVW < 0 { + return forecastPVW + } + if radiationBacked { + if forecastPVW == 0 { return 0 } - return forecastPVW + if math.IsNaN(weight) || math.IsInf(weight, 0) { + weight = 0 + } + weight = math.Max(0, math.Min(1, weight)) + return (1-weight)*forecastPVW + weight*predictedPVW } - - // Radiation-backed forecasts (open_meteo, forecast_solar) have the - // correct diurnal shape and cloud response already. Blend the twin's - // prediction in as a thin per-site calibration instead of letting it - // override the forecast. Typical picture on homelab-rpi after the - // switch: forecast shows smooth bell curve 0–8 kW, an under-trained - // twin still spits random spikes from overfit feature vectors — and - // we want the smooth curve. - // - // Guard: if the forecast exceeds PlannerForecastCapRatio × the twin's - // prediction, and the twin has a meaningful signal (> 50 W — i.e. it - // is not night-gated or collapsed), cap the forecast before blending. - // This prevents a confidently-wrong NWP cloud-cover forecast from - // dominating the plan — the twin's NowAnchor-corrected value already - // reflects live irradiance conditions, and a 3–10× divergence between - // forecast and twin is a stronger signal of NWP error than calibration - // gap. Production incident T33 (2026-05-25) observed open_meteo predicting - // 154 W/m2 / 1% cloud while - // site measured ~22 W/m2 effective irradiance → 7× blend over-shoot). - if radiationBacked && forecastPVW > 0 { - cappedForecast := forecastPVW - if predictedPVW > 50 && forecastPVW > PlannerForecastCapRatio*predictedPVW { - cappedForecast = PlannerForecastCapRatio * predictedPVW - } - return (1-PlannerRadiationWeight)*cappedForecast + PlannerRadiationWeight*predictedPVW - } - - // Cloud-only legacy path: prefer the twin when forecast is near zero - // (forecast probably missing), fall back to forecast when the twin - // collapsed to ~0 (twin probably broken). if forecastPVW < plannerMinForecastPVFallbackW { return predictedPVW } - collapseCeil := math.Max(plannerMaxCollapsedPVW, forecastPVW*plannerMaxCollapsedPVFrac) - if predictedPVW <= collapseCeil { - return forecastPVW - } - return predictedPVW + // Fade a collapsed cloud-only model into the provider continuously. + ceiling := math.Max(plannerMaxCollapsedPVW, forecastPVW*plannerMaxCollapsedPVFrac) + trust := math.Min(1, predictedPVW/ceiling) + return (1-trust)*forecastPVW + trust*predictedPVW } // lookupHasRadiation reports whether the forecast row covering `ts` has @@ -2273,15 +2278,14 @@ func lookupHasRadiation(forecasts []state.ForecastPoint, ts int64) bool { } end := f.SlotTsMs + int64(slotLen)*60*1000 if ts >= f.SlotTsMs && ts < end { - return f.SolarWm2 != nil + return f.PVWEstimated != nil && (f.SolarWm2 != nil || f.Source == "forecast_solar") } } return false } // lookupCloud returns the cloud cover (%) for the forecast row covering -// `ts`, falling back to the nearest neighbour. 50% is the neutral -// prior if no forecast is available at all. +// `ts`. 50% is the neutral prior if no forecast covers the interval. func lookupCloud(forecasts []state.ForecastPoint, ts int64) float64 { cloud, _ := lookupCloudInput(forecasts, ts) return cloud @@ -2309,24 +2313,10 @@ func lookupCloudInput(forecasts []state.ForecastPoint, ts int64) (float64, *stat return 50, f } if ts < f.SlotTsMs { - if i == 0 { - if f.CloudCoverPct != nil { - return *f.CloudCoverPct, f - } - return 50, f - } - prev := &forecasts[i-1] - if prev.CloudCoverPct != nil { - return *prev.CloudCoverPct, prev - } - return 50, prev + return 50, nil } } - last := &forecasts[len(forecasts)-1] - if last.CloudCoverPct != nil { - return *last.CloudCoverPct, last - } - return 50, last + return 50, nil } // lookupPV finds the forecast row whose slot covers ts and returns its PV @@ -2360,17 +2350,8 @@ func lookupPVInput(forecasts []state.ForecastPoint, ts int64) (float64, *state.F } return 0, f } - // Fall back: if between rows, use the preceding row (interpolation - // within the forecast range only). if ts < f.SlotTsMs { - if i == 0 { - return 0, nil - } - prev := &forecasts[i-1] - if prev.PVWEstimated != nil { - return *prev.PVWEstimated, prev - } - return 0, prev + return 0, nil } } // After last row — return 0 (no forecast coverage). diff --git a/go/internal/mpc/service_test.go b/go/internal/mpc/service_test.go index 188c9898..438932bb 100644 --- a/go/internal/mpc/service_test.go +++ b/go/internal/mpc/service_test.go @@ -213,7 +213,7 @@ func TestForecastPriceFadesTowardClimatologyOverHours(t *testing.T) { func TestBuildSlotsWeatherProvenanceFollowsTwinCloudInput(t *testing.T) { weatherStart := time.Date(2026, 4, 15, 10, 0, 0, 0, time.UTC) - priceStart := weatherStart.Add(75 * time.Minute) + priceStart := weatherStart.Add(45 * time.Minute) cloud := 25.0 prices := []state.PricePoint{{ SlotTsMs: priceStart.UnixMilli(), SlotLenMin: 15, @@ -235,7 +235,7 @@ func TestBuildSlotsWeatherProvenanceFollowsTwinCloudInput(t *testing.T) { } } -func TestBuildSlotsWeatherProvenanceKeepsNearestNilCloudRow(t *testing.T) { +func TestBuildSlotsDoesNotUseFutureWeatherBeforeCoverage(t *testing.T) { firstTs := time.Date(2026, 4, 15, 10, 0, 0, 0, time.UTC).UnixMilli() laterCloud := 91.0 priceTs := firstTs - int64(15*time.Minute/time.Millisecond) @@ -259,9 +259,62 @@ func TestBuildSlotsWeatherProvenanceKeepsNearestNilCloudRow(t *testing.T) { if len(slots) != 1 { t.Fatalf("buildSlots returned %d slots, want 1", len(slots)) } - if got := slots[0]; got.PVW != -500 || got.WeatherRowSource != "nearest" || - got.WeatherRowAvailableAtMs != 111 { - t.Fatalf("nearest nil-cloud provenance = %+v", got) + if got := slots[0]; got.PVW != 0 || got.WeatherRowSource != "" || got.WeatherRowAvailableAtMs != 0 { + t.Fatalf("future weather manufactured PV or provenance = %+v", got) + } +} + +func TestBuildSlotsDoesNotCreatePVAcrossWeatherGap(t *testing.T) { + start := time.Date(2026, 4, 15, 10, 0, 0, 0, time.UTC) + cloud := 10.0 + pvW := 3000.0 + forecasts := []state.ForecastPoint{ + {SlotTsMs: start.UnixMilli(), SlotLenMin: 60, CloudCoverPct: &cloud, PVWEstimated: &pvW, Source: "before"}, + {SlotTsMs: start.Add(2 * time.Hour).UnixMilli(), SlotLenMin: 60, CloudCoverPct: &cloud, PVWEstimated: &pvW, Source: "after"}, + } + target := start.Add(time.Hour).UnixMilli() + slots := buildSlots( + []state.PricePoint{{SlotTsMs: target, SlotLenMin: 15, SpotOreKwh: 50, TotalOreKwh: 100}}, + forecasts, 500, target, + func(time.Time, float64) float64 { return 5000 }, nil, nil, + ) + if len(slots) != 1 { + t.Fatalf("buildSlots returned %d slots, want 1", len(slots)) + } + if got := slots[0]; got.PVW != 0 || got.WeatherRowSource != "" || got.WeatherRowAvailableAtMs != 0 { + t.Fatalf("weather gap manufactured learned PV or provenance = %+v", got) + } +} + +func TestSnapshotPredictionsUsesFrozenPlanPredictors(t *testing.T) { + start := time.Date(2026, 4, 15, 10, 0, 0, 0, time.UTC) + cloud := 25.0 + weather := []state.ForecastPoint{{SlotTsMs: start.UnixMilli(), SlotLenMin: 60, CloudCoverPct: &cloud}} + service := &Service{ + PV: func(time.Time, float64) float64 { return 9000 }, + Load: func(time.Time) float64 { return 8000 }, + } + points := service.snapshotPredictions( + []Slot{{StartMs: start.UnixMilli(), LenMin: 60}}, weather, + func(time.Time, float64) float64 { return 1000 }, + func(time.Time) float64 { return 700 }, + ) + if points == nil || len(points.pv) != 1 || points.pv[0] != 1000 || len(points.load) != 1 || points.load[0] != 700 { + t.Fatalf("drift baseline re-read live predictors: %+v", points) + } + loadOnly := service.snapshotPredictions( + []Slot{{StartMs: start.UnixMilli(), LenMin: 60}}, nil, + nil, func(time.Time) float64 { return 700 }, + ) + if loadOnly == nil || loadOnly.pv != nil || len(loadOnly.load) != 1 { + t.Fatalf("nil frozen PV fell through to live service predictor: %+v", loadOnly) + } + withoutWeather := service.snapshotPredictions( + []Slot{{StartMs: start.UnixMilli(), LenMin: 60}}, nil, + func(time.Time, float64) float64 { return 1000 }, nil, + ) + if withoutWeather == nil || len(withoutWeather.pv) != 1 || len(withoutWeather.pvCovered) != 1 || withoutWeather.pvCovered[0] { + t.Fatalf("missing weather created a PV drift baseline: %+v", withoutWeather) } } @@ -880,52 +933,26 @@ func TestSelectPlannerPVWRadiationBlendClampsWildTwin(t *testing.T) { } } -// When forecast is radiation-backed but zero (night), the legacy cloud -// path takes over — we don't want to emit 0.3*predicted for a slot -// where the forecast correctly says "no sun". -func TestSelectPlannerPVWRadiationZeroForecastIgnoresBlend(t *testing.T) { - // Twin predicts 300W at night (probably garbage); radiation says 0. - // With the guard, we fall through to cloud-only logic: forecast < - // 200 threshold → use twin. That's the original behaviour and - // matches "we have no sun, twin is the only signal left". - got := selectPlannerPVW(0, 300, true) - if got != 300 { - t.Errorf("zero-forecast with radiation flag should fall through, got %f", got) +// A provider's explicit zero is a valid signal, including night. +func TestSelectPlannerPVWRadiationZeroDoesNotInventPV(t *testing.T) { + if got := selectPlannerPVW(0, 300, true); got != 0 { + t.Fatalf("provider zero became %v W", got) } } -// T33 regression: open_meteo predicted 2002 W (solar_wm2=154, cloud=1%) for a -// 13 kW site while the trained RLS twin (NowAnchor-corrected via live telemetry) -// predicted 290 W — actual measured PV was ~290 W. The old code produced -// 0.7*2002 + 0.3*290 = 1488 W (5× actual). With the forecast cap, the forecast -// is limited to PlannerForecastCapRatio (3×) × twin before blending: -// -// cappedForecast = 3 × 290 = 870 -// result = 0.7×870 + 0.3×290 = 696 W (2.4× actual — still an overshoot -// but far better than 5×) -// -// The residual over-prediction is expected and acceptable: the cap only activates -// when the NWP cloud forecast was catastrophically wrong. On a normal day (forecast -// and twin agree within 3×) the cap is a no-op and accuracy is unchanged. -func TestSelectPlannerPVWForecastCapActivatesOnWildForecast(t *testing.T) { - // Reproduce T33 inputs (scaled to round numbers). - forecast := 2002.0 - twin := 290.0 // NowAnchor-corrected RLS twin value - - got := selectPlannerPVW(forecast, twin, true) - - // With the cap at PlannerForecastCapRatio=3: capped = 3*290 = 870. - cappedForecast := PlannerForecastCapRatio * twin - want := (1-PlannerRadiationWeight)*cappedForecast + PlannerRadiationWeight*twin - if math.Abs(got-want) > 0.5 { - t.Errorf("T33 forecast-cap: got %.1f, want %.1f (capped at %.0fx twin=%g)", - got, want, PlannerForecastCapRatio, twin) +func TestSelectPlannerPVWContinuousAtLegacyThreshold(t *testing.T) { + before := selectPlannerPVW(6000, 50, true) + after := selectPlannerPVW(6000, 51, true) + if math.Abs((after-before)-PlannerRadiationWeight) > 1e-9 { + t.Fatalf("one watt changed blend %v -> %v", before, after) } +} - // Result must be materially less than the uncapped blend. - uncapped := (1-PlannerRadiationWeight)*forecast + PlannerRadiationWeight*twin - if got >= uncapped { - t.Errorf("capped result %.1f should be less than uncapped %.1f", got, uncapped) +func TestPlannerPVWeightRequiresBoundedTrust(t *testing.T) { + for _, tc := range []struct{ weight, want float64 }{{0, 6000}, {1, 50}, {-1, 6000}, {2, 50}, {math.NaN(), 6000}} { + if got := selectPlannerPVWithWeight(6000, 50, true, tc.weight); got != tc.want { + t.Fatalf("weight %v: got%v want%v", tc.weight, got, tc.want) + } } } diff --git a/go/internal/ocpp/forecast_power_test.go b/go/internal/ocpp/forecast_power_test.go new file mode 100644 index 00000000..0f881c5d --- /dev/null +++ b/go/internal/ocpp/forecast_power_test.go @@ -0,0 +1,164 @@ +package ocpp + +import ( + "fmt" + "strings" + "testing" + "time" + + "github.com/lorenzodonini/ocpp-go/ocpp1.6/core" + types16 "github.com/lorenzodonini/ocpp-go/ocpp1.6/types" + "github.com/lorenzodonini/ocpp-go/ocpp2.0.1/availability" + "github.com/lorenzodonini/ocpp-go/ocpp2.0.1/meter" + "github.com/lorenzodonini/ocpp-go/ocpp2.0.1/transactions" + types201 "github.com/lorenzodonini/ocpp-go/ocpp2.0.1/types" + "github.com/srcfl/ftw/go/internal/telemetry" +) + +type forecastOCPPFixture struct { + h *Handler + tel *telemetry.Store + power func(float64, time.Time) + energy func() + status func() + stop func() +} + +func newForecastOCPPFixture(t *testing.T, version string) forecastOCPPFixture { + t.Helper() + tel := telemetry.NewStore() + h := NewHandler(tel, 60) + h.SetApprovedIDs([]string{"charger"}) + h.OnConnect("charger") + f := forecastOCPPFixture{h: h, tel: tel} + if version == "1.6" { + f.power = func(w float64, at time.Time) { + h.OnMeterValues("charger", &core.MeterValuesRequest{ConnectorId: 1, MeterValue: []types16.MeterValue{{Timestamp: types16.NewDateTime(at), SampledValue: []types16.SampledValue{{Value: fmt.Sprint(w), Measurand: types16.MeasurandPowerActiveImport}}}}}) + } + f.energy = func() { + h.OnMeterValues("charger", &core.MeterValuesRequest{ConnectorId: 1, MeterValue: []types16.MeterValue{{Timestamp: types16.NewDateTime(time.Now()), SampledValue: []types16.SampledValue{{Value: "1234", Measurand: types16.MeasurandEnergyActiveImportRegister}}}}}) + } + f.status = func() { + h.OnStatusNotification("charger", &core.StatusNotificationRequest{ConnectorId: 1, Status: core.ChargePointStatusCharging}) + } + f.stop = func() { h.OnStopTransaction("charger", &core.StopTransactionRequest{}) } + } else { + v := &handlerV201{h} + f.power = func(w float64, at time.Time) { + v.OnMeterValues("charger", &meter.MeterValuesRequest{EvseID: 1, MeterValue: []types201.MeterValue{{Timestamp: *types201.NewDateTime(at), SampledValue: []types201.SampledValue{{Value: w, Measurand: types201.MeasurandPowerActiveImport}}}}}) + } + f.energy = func() { + v.OnMeterValues("charger", &meter.MeterValuesRequest{EvseID: 1, MeterValue: []types201.MeterValue{{Timestamp: *types201.NewDateTime(time.Now()), SampledValue: []types201.SampledValue{{Value: 1234, Measurand: types201.MeasurandEnergyActiveImportRegister}}}}}) + } + f.status = func() { + v.OnStatusNotification("charger", &availability.StatusNotificationRequest{EvseID: 1, ConnectorID: 1, ConnectorStatus: availability.ConnectorStatusOccupied}) + } + f.stop = func() { + v.OnTransactionEvent("charger", &transactions.TransactionEventRequest{EventType: transactions.TransactionEventEnded}) + } + } + return f +} +func (f forecastOCPPFixture) reading() telemetry.ForecastReading { + f.tel.Update("site", telemetry.DerMeter, 5000, nil, nil) + f.tel.RecordDriverSuccess("site") + f.tel.Update("pv", telemetry.DerPV, -1000, nil, nil) + f.tel.RecordDriverSuccess("pv") + return f.tel.ForecastMeasurement(time.Now(), "site", telemetry.ForecastOptions{ExpectedFlows: []telemetry.ForecastFlow{{Driver: "charger", DerType: telemetry.DerEV}}, MaxSkew: time.Minute}) +} + +func TestForecastOCPPRequiresRealPowerInBothVersions(t *testing.T) { + for _, version := range []string{"1.6", "2.0.1"} { + t.Run(version, func(t *testing.T) { + f := newForecastOCPPFixture(t, version) + for _, stage := range []func(){func() {}, f.status, f.energy} { + stage() + r := f.reading() + if r.Valid || !r.PVValid || !strings.HasPrefix(r.Reason, "unknown_power:charger:") { + t.Fatalf("status/energy-only became measured zero: %+v", r) + } + } + at := time.Now() + f.power(0, at) + r := f.reading() + if !r.Valid || r.EVW != 0 || r.HouseholdW != 6000 { + t.Fatalf("measured zero rejected: %+v", r) + } + f.stop() + r = f.reading() + if r.Valid || !r.PVValid { + t.Fatalf("synthetic stop zero became a measured sample: %+v", r) + } + // Replaying a pre-stop sample must not revive a synthetic zero. + f.power(0, at) + if r = f.reading(); r.Valid { + t.Fatal("duplicate timestamp revived stopped power") + } + f.h.OnDisconnect("charger") + f.h.OnConnect("charger") + f.status() + if r = f.reading(); r.Valid { + t.Fatal("reconnect reused prior-socket power") + } + time.Sleep(2 * time.Millisecond) // next distinct source timestamp + f.power(0, time.Now()) + if r = f.reading(); !r.Valid { + t.Fatalf("new socket's real zero rejected: %+v", r) + } + }) + } +} + +func TestForecastOCPPStatusCannotRefreshOldPower(t *testing.T) { + for _, version := range []string{"1.6", "2.0.1"} { + t.Run(version, func(t *testing.T) { + f := newForecastOCPPFixture(t, version) + // The connection predates the delayed source sample; receipt is fresh. + f.h.mu.Lock() + f.h.chargers["charger"].powerConnectedAt = time.Now().Add(-time.Hour) + f.h.mu.Unlock() + f.power(700, time.Now().Add(-2*time.Minute)) + f.status() + f.energy() + r := f.reading() + if r.Valid || !r.PVValid || !strings.HasPrefix(r.Reason, "stale:charger:") { + t.Fatalf("later status/energy refreshed old power: %+v", r) + } + }) + } +} + +func TestForecastOCPPRejectsFutureAndOutOfOrderSamples(t *testing.T) { + for _, version := range []string{"1.6", "2.0.1"} { + t.Run(version, func(t *testing.T) { + f := newForecastOCPPFixture(t, version) + f.power(900, time.Now().Add(time.Hour)) + if f.reading().Valid { + t.Fatal("future source timestamp accepted") + } + at := time.Now() + f.power(700, at) + f.power(9000, at.Add(-time.Second)) + r := f.reading() + if !r.Valid || r.EVW != 700 { + t.Fatalf("out-of-order power replaced accepted measurement: %+v", r) + } + if raw := f.tel.Get("charger", telemetry.DerEV); raw.RawW != 9000 { + t.Fatal("forecast qualification changed existing dispatch publication") + } + }) + } +} + +func TestForecastOCPP201TransactionPowerAndMissingPower(t *testing.T) { + f := newForecastOCPPFixture(t, "2.0.1") + v := &handlerV201{f.h} + v.OnTransactionEvent("charger", &transactions.TransactionEventRequest{EventType: transactions.TransactionEventUpdated}) + if f.reading().Valid { + t.Fatal("power-free transaction event became zero measurement") + } + v.OnTransactionEvent("charger", &transactions.TransactionEventRequest{EventType: transactions.TransactionEventUpdated, MeterValue: []types201.MeterValue{{Timestamp: *types201.NewDateTime(time.Now()), SampledValue: []types201.SampledValue{{Value: 0, Measurand: types201.MeasurandPowerActiveImport}}}}}) + if r := f.reading(); !r.Valid || r.EVW != 0 { + t.Fatalf("real transaction zero rejected: %+v", r) + } +} diff --git a/go/internal/ocpp/handlers.go b/go/internal/ocpp/handlers.go index 4b523953..09f9b294 100644 --- a/go/internal/ocpp/handlers.go +++ b/go/internal/ocpp/handlers.go @@ -3,6 +3,7 @@ package ocpp import ( "encoding/json" "log/slog" + "math" "strconv" "sync" "time" @@ -77,6 +78,8 @@ type chargerState struct { sessionStartMeterWh float64 sessionMeterWh float64 lastPowerW float64 + forecastPower telemetry.ForecastPowerSample + powerConnectedAt time.Time // lastAmps is the most recent per-phase limit this charger accepted. // A resume with no rate of its own restores it. lastAmps float64 @@ -171,7 +174,7 @@ func (h *Handler) SetApprovedIDs(ids []string) { } h.mu.Unlock() for _, id := range revoked { - blob, _ := json.Marshal(map[string]any{"type": "ev", "w": 0.0}) + blob, _ := json.Marshal(map[string]any{"type": "ev", "w": 0.0, "forecast_power": telemetry.ForecastPowerSample{Version: 1}}) h.tel.Update(id, telemetry.DerEV, 0, nil, blob) } } @@ -382,10 +385,12 @@ func (h *Handler) OnConnect(id string) { s := h.state(id) h.mu.Lock() s.online = true + s.powerConnectedAt = time.Now().Truncate(time.Second) s.connectionGeneration++ s.connectedKnown = false s.charging = false s.lastPowerW = 0 + s.forecastPower.Known = false s.identityCurrent = false s.featureProfiles = "" s.steerable = nil @@ -412,6 +417,7 @@ func (h *Handler) OnDisconnect(id string) { s.connectedKnown = false s.charging = false s.lastPowerW = 0 + s.forecastPower.Known = false h.mu.Unlock() // Push a zero so the dispatch clamp releases — otherwise the last known // non-zero w would survive until staleness kicks in. @@ -513,6 +519,7 @@ func (h *Handler) OnStatusNotification(id string, req *core.StatusNotificationRe func (h *Handler) OnMeterValues(id string, req *core.MeterValuesRequest) (*core.MeterValuesConfirmation, error) { s := h.state(id) h.mu.Lock() + received := time.Now() for _, mv := range req.MeterValue { for _, sv := range mv.SampledValue { measurand := sv.Measurand @@ -530,6 +537,13 @@ func (h *Handler) OnMeterValues(id string, req *core.MeterValuesRequest) (*core. val *= 1000 } s.lastPowerW = val + if sv.Phase == "" && (sv.Unit == "" || sv.Unit == types.UnitOfMeasureW || sv.Unit == types.UnitOfMeasureKW) { + measured := received + if mv.Timestamp != nil { + measured = mv.Timestamp.Time + } + s.recordForecastPower(val, measured, received) + } case types.MeasurandEnergyActiveImportRegister: if sv.Unit == types.UnitOfMeasureKWh { val *= 1000 @@ -580,6 +594,7 @@ func (h *Handler) OnStopTransaction(id string, req *core.StopTransactionRequest) s.transactionID = -1 s.charging = false s.lastPowerW = 0 + s.forecastPower.Known = false s.sessionMeterWh = sessionWh h.mu.Unlock() @@ -610,11 +625,13 @@ func (h *Handler) pushReading(id string, s *chargerState) { h.mu.Lock() approved := h.approved[id] w := s.lastPowerW + s.forecastPower.Version = 1 data := map[string]any{ - "type": "ev", - "w": w, - "charging": s.charging, - "session_wh": s.sessionMeterWh, + "type": "ev", + "w": w, + "charging": s.charging, + "session_wh": s.sessionMeterWh, + "forecast_power": s.forecastPower, } data["connection_generation"] = s.connectionGeneration if s.online && s.connectedKnown { @@ -634,3 +651,14 @@ func (h *Handler) pushReading(id string, s *chargerState) { blob, _ := json.Marshal(data) h.tel.Update(id, telemetry.DerEV, w, nil, blob) } + +// recordForecastPower is separate from the existing status/dispatch power. +// Only a real aggregate power measurand may refresh it. Samples older than a +// connection or the accepted sample, and future/nonfinite values, cannot revive +// a stale or synthesized reading. The caller holds h.mu. +func (s *chargerState) recordForecastPower(w float64, measured, received time.Time) { + if math.IsNaN(w) || math.IsInf(w, 0) || w < 0 || measured.IsZero() || measured.After(received) || measured.Before(s.powerConnectedAt) || measured.UnixMilli() <= s.forecastPower.MeasuredAtMS { + return + } + s.forecastPower = telemetry.ForecastPowerSample{Version: 1, Known: true, Watts: w, MeasuredAtMS: measured.UnixMilli(), ReceivedAtMS: received.UnixMilli()} +} diff --git a/go/internal/ocpp/handlers_v201.go b/go/internal/ocpp/handlers_v201.go index 26054bc3..41f46f24 100644 --- a/go/internal/ocpp/handlers_v201.go +++ b/go/internal/ocpp/handlers_v201.go @@ -23,6 +23,7 @@ package ocpp import ( "log/slog" + "math" "time" "github.com/lorenzodonini/ocpp-go/ocpp2.0.1/authorization" @@ -102,6 +103,7 @@ func (h *handlerV201) OnStatusNotification(id string, req *availability.StatusNo s.connected = false s.charging = false s.lastPowerW = 0 + s.forecastPower.Known = false case availability.ConnectorStatusOccupied, availability.ConnectorStatusReserved: s.connected = true s.connectedKnown = true @@ -112,6 +114,7 @@ func (h *handlerV201) OnStatusNotification(id string, req *availability.StatusNo s.connectedKnown = true s.charging = false s.lastPowerW = 0 + s.forecastPower.Known = false } faulted := req.ConnectorStatus == availability.ConnectorStatusFaulted h.mu.Unlock() @@ -172,12 +175,14 @@ func (h *handlerV201) OnTransactionEvent(id string, req *transactions.Transactio s.transactionRef = "" s.charging = false s.lastPowerW = 0 + s.forecastPower.Known = false powerW = 0 } if req.EventType != transactions.TransactionEventEnded { s.lastPowerW = powerW } + s.recordForecastPowerV201(req.MeterValue, time.Now()) sessionWh := s.sessionMeterWh ended := req.EventType == transactions.TransactionEventEnded h.mu.Unlock() @@ -209,6 +214,7 @@ func (h *handlerV201) OnMeterValues(id string, req *meter.MeterValuesRequest) (* h.mu.Lock() s.lastPowerW = powerW + s.recordForecastPowerV201(req.MeterValue, time.Now()) if hasEnergy && s.transactionID >= 0 { s.sessionMeterWh = energyWh - s.sessionStartMeterWh } @@ -273,3 +279,30 @@ func unitIsKilo(u *types201.UnitOfMeasure) bool { return false } } + +func (s *chargerState) recordForecastPowerV201(values []types201.MeterValue, received time.Time) { + for _, mv := range values { + for _, sv := range mv.SampledValue { + if sv.Measurand != types201.MeasurandPowerActiveImport || sv.Phase != "" { + continue + } + w := sv.Value + if unit := sv.UnitOfMeasure; unit != nil { + if unit.Unit != "" && unit.Unit != "W" && unit.Unit != "kW" { + continue + } + if unit.Unit == "kW" { + w *= 1000 + } + if unit.Multiplier != nil { + w *= math.Pow10(*unit.Multiplier) + } + } + measured := mv.Timestamp.Time + if measured.IsZero() { + measured = received + } + s.recordForecastPower(w, measured, received) + } + } +} diff --git a/go/internal/ocpp/server.go b/go/internal/ocpp/server.go index 202ba3fe..992b3b1e 100644 --- a/go/internal/ocpp/server.go +++ b/go/internal/ocpp/server.go @@ -175,7 +175,7 @@ func Start(ctx context.Context, cfg *Config, tel *telemetry.Store) (*Server, err // layer up, in authorizer.checkClient, which refuses the handshake // for a connection that arrived somewhere else. // cs.Start blocks until cs.Stop is called. - s.cs.Start(cfg.Port, fmt.Sprintf("%s{ws}", cfg.Path)) + cs.Start(cfg.Port, fmt.Sprintf("%s{ws}", cfg.Path)) }() go func() { <-ctx.Done() diff --git a/go/internal/pvmodel/model.go b/go/internal/pvmodel/model.go index 53c10398..3c89c08a 100644 --- a/go/internal/pvmodel/model.go +++ b/go/internal/pvmodel/model.go @@ -43,21 +43,44 @@ import ( // NFeat is the number of features in the RLS regression. const NFeat = 7 +// maxLearningW is a numerical sensor-unit guard, not a site hardware limit. +// It permits up to 10 MW; only ACLimitW represents a verified inverter limit. +const maxLearningW = 10_000_000.0 + +func finite(v float64) bool { return !math.IsNaN(v) && !math.IsInf(v, 0) } + // Model is the learned PV predictor. type Model struct { - Beta [NFeat]float64 `json:"beta"` - P [NFeat][NFeat]float64 `json:"p"` // covariance - Forgetting float64 `json:"forgetting"` - Samples int64 `json:"samples"` - LastMs int64 `json:"last_ms"` - MAE float64 `json:"mae"` // EMA of |err| (W) + ConfigRevision string `json:"config_revision,omitempty"` + Beta [NFeat]float64 `json:"beta"` + P [NFeat][NFeat]float64 `json:"p"` // covariance + Forgetting float64 `json:"forgetting"` + Samples int64 `json:"samples"` + LastMs int64 `json:"last_ms"` + MAE float64 `json:"mae"` // EMA of |err| (W) // RelMAE is MAE expressed as a share of the prediction it belongs to // (0..1), over the same EMA window. The planner sizes each slot's PV // downside against that slot's own expected generation, which a watt // figure cannot do. Absent from state persisted before #1020; 0 there // reads as "not learned yet" and the planner keeps the flat haircut. - RelMAE float64 `json:"rel_mae"` - RatedW float64 `json:"rated_w"` // nominal plate rating (prior) + RelMAE float64 `json:"rel_mae"` + RatedW float64 `json:"rated_w"` // nominal plate rating (prior) + ACLimitW float64 `json:"ac_limit_w"` // verified AC limit only; zero is unknown + InferredScaleKnown bool `json:"inferred_scale_known"` + InferredScaleW float64 `json:"inferred_scale_w"` + ScaleCandidateW float64 `json:"scale_candidate_w"` + ScaleSamples uint16 `json:"scale_samples"` + ScaleDays uint16 `json:"scale_days"` + ScaleLastDay int64 `json:"scale_last_day"` + ScaleStartMs int64 `json:"scale_start_ms"` + ScaleLastMs int64 `json:"scale_last_ms"` + ScaleDirection int `json:"scale_direction"` + CoverageDays [24]uint16 `json:"coverage_days"` + CoverageLastDay [24]int64 `json:"coverage_last_day"` + ChangeCount int `json:"change_count"` + ChangeSign int `json:"change_sign"` + ChangeStartMs int64 `json:"change_start_ms"` + ChangeLastMs int64 `json:"change_last_ms"` } // relMAEMinPredictedW gates the relative-error EMA. Below it the denominator @@ -67,6 +90,9 @@ const relMAEMinPredictedW = 500.0 // NewModel returns a model anchored on the naive clear-sky prior. func NewModel(ratedW float64) *Model { + if !finite(ratedW) || ratedW < 0 || ratedW > maxLearningW { + ratedW = 0 + } m := &Model{ Forgetting: 0.995, // ~200-sample effective window RatedW: ratedW, @@ -171,15 +197,15 @@ var featureHash = sync.OnceValue(func() string { // does not. func FeatureHash() string { return featureHash() } -// Predict returns the expected AC output in W (non-negative). Cold-start -// behavior: during the first WarmupSamples we blend the learned β with -// the naive physics prior so a wild β coefficient (which RLS can take a -// few samples to tame) doesn't produce an unreasonable forecast. -// -// After ~warmup samples we trust the learned model fully. +// Predict returns non-negative AC output. Separate days of coverage at the +// target hour control the blend between the learned shape and the scale prior. +// WarmupSamples remains the minimum history for the residual outlier filter. const WarmupSamples = 50 func (m Model) Predict(clearSkyW, cloudPct float64, t time.Time) float64 { + if !finite(clearSkyW) || !finite(cloudPct) || clearSkyW > 2000 { + return 0 + } // Physics gate: no sun above the horizon → no PV output. Mirrors the // Update-side guard (`clearSkyW < 50` skips training), so prediction // and training share one definition of "night". Without this gate the @@ -208,41 +234,59 @@ func (m Model) Predict(clearSkyW, cloudPct float64, t time.Time) float64 { } cf = math.Pow(1-c, 1.5) } - prior := m.RatedW * (clearSkyW / 1000.0) * cf + scale := m.RatedW + if m.InferredScaleKnown || m.InferredScaleW > 0 { + scale = m.InferredScaleW + } + prior := scale * (clearSkyW / 1000.0) * cf - // Trust = samples / WarmupSamples, clipped to [0, 1]. - // samples=0 → 100% prior. - // samples≥50 → 100% learned. - trust := float64(m.Samples) / float64(WarmupSamples) - if trust > 1 { - trust = 1 + // Dense samples from one morning cannot grant full-day trust. + trust := m.Trust(t) + if !finite(learned) { + learned = prior } y := trust*learned + (1-trust)*prior if y < 0 { return 0 } - // Hard cap at 105% of nameplate. Anything above is RLS having a bad - // day — fall back to the physics prior, which is bounded by construction. - if m.RatedW > 0 && y > 1.05*m.RatedW { - return prior + // Only a verified AC boundary limits an otherwise valid forecast. + if m.ACLimitW > 0 { + y = math.Min(y, m.ACLimitW) } - return y + return math.Min(y, maxLearningW) +} + +// Trust is coverage at the target UTC hour, earned on separate days. Legacy +// states retain their coefficients but start with no earned coverage. +func (m Model) Trust(t time.Time) float64 { + hour := t.UTC().Hour() + days := t.Unix()/86400 - m.CoverageLastDay[hour] + if days < 0 { + return 0 + } + // Coverage from a distant season cannot grant full weight to today's + // solar response. The first fortnight covers the normal planning horizon; + // older support decays with a 30-day time scale. + age := math.Exp(-math.Max(0, float64(days-14)) / 30) + return math.Min(1, float64(m.CoverageDays[hour])/7) * age } // Update runs one RLS step. Skipped when clearSky < threshold (night / // near-night — little signal, mostly noise), or when the residual is a // large-σ outlier (sensor glitch, inverter restart). func (m *Model) Update(clearSkyW, cloudPct float64, t time.Time, actualPVW float64) (updated bool) { + if !finite(clearSkyW) || !finite(cloudPct) || !finite(actualPVW) || clearSkyW > 2000 || actualPVW > maxLearningW { + return false + } if clearSkyW < 50 { return false } if actualPVW < 0 { return false } - // Physical sanity envelope: anything wildly above nameplate is sensor - // noise (inverter restart, transient) — never feed it to RLS. - if m.RatedW > 0 && actualPVW > 1.2*m.RatedW { + // A verified AC limit can reject impossible readings; a size guess cannot. + if m.ACLimitW > 0 && actualPVW > 1.2*m.ACLimitW { return false } x := Features(clearSkyW, cloudPct, t) @@ -251,18 +295,57 @@ func (m *Model) Update(clearSkyW, cloudPct float64, t time.Time, actualPVW float yHat += m.Beta[i] * x[i] } err := actualPVW - yHat - // Cold-start outlier guard: before the MAE-based filter kicks in, reject - // samples where the predicted value is already absurd (>2× rated). This - // stops a single bad sample from cascading into wild β coefficients. - if m.RatedW > 0 && math.Abs(yHat) > 2*m.RatedW { - return false + // Recover corrupt numerical state instead of rejecting every later sample. + if !finite(yHat) || math.Abs(yHat) > maxLearningW*10 { + fresh := NewModel(m.RatedW) + m.Beta = fresh.Beta + m.P = fresh.P + m.Forgetting = fresh.Forgetting + yHat = 0 + for i := 0; i < NFeat; i++ { + yHat += m.Beta[i] * x[i] + } + err = actualPVW - yHat } // After warm-up, reject 10σ outliers. MAE is in W; use it as a proxy // for σ (scales with system size, unlike a hard-coded threshold). - if m.Samples > 50 { + if m.Samples > WarmupSamples { band := math.Max(m.MAE*10, 200) if math.Abs(err) > band { - return false + sign := 1 + if err < 0 { + sign = -1 + } + if m.ChangeSign != sign || t.UnixMilli()-m.ChangeLastMs > int64((2*time.Hour)/time.Millisecond) { + m.ChangeCount = 0 + m.ChangeStartMs = t.UnixMilli() + } + m.ChangeSign = sign + m.ChangeCount++ + m.ChangeLastMs = t.UnixMilli() + if m.ChangeCount < 5 || t.UnixMilli()-m.ChangeStartMs < int64((15*time.Minute)/time.Millisecond) { + return false + } + // Repeated evidence of a new operating regime is not a sensor + // spike. Retire the old fit and earn coverage again. Resetting its + // covariance also avoids amplifying ill-conditioned old harmonics. + fresh := NewModel(m.RatedW) + m.Beta = [NFeat]float64{} + if x[2] >= 50 { + m.Beta[2] = actualPVW / x[2] + } else { + m.Beta[1] = actualPVW / clearSkyW + } + m.P = fresh.P + m.CoverageDays = [24]uint16{} + m.CoverageLastDay = [24]int64{} + m.ChangeCount = 0 + m.ChangeSign = 0 + yHat = actualPVW + err = 0 + } else { + m.ChangeCount = 0 + m.ChangeSign = 0 } } @@ -279,7 +362,23 @@ func (m *Model) Update(clearSkyW, cloudPct float64, t time.Time, actualPVW float for i := 0; i < NFeat; i++ { xPx += x[i] * Px[i] } + if !finite(m.Forgetting) || m.Forgetting <= 0 || m.Forgetting > 1 { + m.Forgetting = 0.995 + } denom := m.Forgetting + xPx + if !finite(denom) || denom <= 0 { + // A lost covariance direction must not permanently stop learning. + // Rebuild uncertainty while retaining the finite coefficient estimate. + m.P = [NFeat][NFeat]float64{} + xPx = 0 + for i := 1; i < NFeat; i++ { + m.P[i][i] = 1 + Px[i] = x[i] + xPx += x[i] * x[i] + } + Px[0] = 0 + denom = m.Forgetting + xPx + } var K [NFeat]float64 for i := 0; i < NFeat; i++ { K[i] = Px[i] / denom @@ -299,20 +398,59 @@ func (m *Model) Update(clearSkyW, cloudPct float64, t time.Time, actualPVW float // ~140k samples, after which Px[0] = Inf*0 = NaN poisons K, β, and // all predictions. Freezing row/column 0 at zero keeps the // dead-slot invariant numerically stable forever. Codex P1 on PR #136. - var newP [NFeat][NFeat]float64 + // Joseph covariance update preserves symmetry and positive directions + // under repeated, nearly identical feature vectors. The short subtractive + // form can lose both and produce large extrapolation errors after days. + var a, ap, newP [NFeat][NFeat]float64 for i := 1; i < NFeat; i++ { for j := 1; j < NFeat; j++ { - var kxTP float64 + a[i][j] = -K[i] * x[j] + if i == j { + a[i][j]++ + } + } + } + for i := 1; i < NFeat; i++ { + for j := 1; j < NFeat; j++ { + for k := 1; k < NFeat; k++ { + ap[i][j] += a[i][k] * m.P[k][j] + } + } + } + var trace float64 + for i := 1; i < NFeat; i++ { + for j := i; j < NFeat; j++ { + v := K[i] * K[j] for k := 1; k < NFeat; k++ { - kxTP += K[i] * x[k] * m.P[k][j] + v += ap[i][k] * a[j][k] / m.Forgetting + } + if i == j { + v = math.Max(0, v) + trace += v + } + newP[i][j] = v + newP[j][i] = v + } + } + // Bound unobserved covariance growth (not PV power). Scaling the whole + // matrix preserves its positive directions and finite numerical range. + if trace > 1e6 { + for i := 1; i < NFeat; i++ { + for j := 1; j < NFeat; j++ { + newP[i][j] *= 1e6 / trace } - newP[i][j] = (m.P[i][j] - kxTP) / m.Forgetting } } m.P = newP m.Samples++ m.LastMs = t.UnixMilli() + hour, day := t.UTC().Hour(), t.Unix()/86400 + if m.CoverageDays[hour] == 0 || m.CoverageLastDay[hour] != day { + m.CoverageDays[hour] = min(365, m.CoverageDays[hour]+1) + m.CoverageLastDay[hour] = day + } + m.observeScale(clearSkyW, cloudPct, t, actualPVW) // MAE EMA: gives a ~99-sample window; good for outlier banding. if m.Samples == 1 { m.MAE = math.Abs(err) @@ -345,19 +483,98 @@ func (m *Model) Update(clearSkyW, cloudPct float64, t time.Time, actualPVW float return true } -// Quality reports how confident we are in the model. 0 = untrained, -// 1.0+ = fully converged (matches rated_w → 5% MAE threshold). +// observeScale changes the prior only after separate observations support a +// persistent change. Low-light cloud normalization cannot resize the plant. +// A drop requires three separate days (seven for near-zero production), while +// repeated growth can correct an undersized guess within an hour. +func (m *Model) observeScale(cs, cloud float64, t time.Time, actual float64) { + if cs < 300 || cloud < 0 || cloud > 20 { + return + } + if m.ScaleLastMs > 0 && t.UnixMilli()-m.ScaleLastMs < int64(15*time.Minute/time.Millisecond) { + return + } + scale := actual / (cs / 1000 * math.Pow(1-cloud/100, 1.5)) + base := m.RatedW + if m.InferredScaleKnown || m.InferredScaleW > 0 { + base = m.InferredScaleW + } + direction := 0 + if scale > base*1.2+50 { + direction = 1 + } else if scale < base*.8-50 { + direction = -1 + } + if direction == 0 { + m.ScaleDirection = 0 + m.ScaleSamples = 0 + m.ScaleDays = 0 + m.ScaleLastMs = t.UnixMilli() + return + } + if direction != m.ScaleDirection || t.UnixMilli()-m.ScaleLastMs > int64(14*24*time.Hour/time.Millisecond) { + m.ScaleSamples = 0 + m.ScaleDays = 0 + m.ScaleStartMs = t.UnixMilli() + } + m.ScaleDirection = direction + m.ScaleSamples = min(96, m.ScaleSamples+1) + if m.ScaleSamples == 1 { + m.ScaleCandidateW = scale + } else { + m.ScaleCandidateW += (scale - m.ScaleCandidateW) / float64(min(16, m.ScaleSamples)) + } + day := t.Unix() / 86400 + if m.ScaleDays == 0 || day != m.ScaleLastDay { + m.ScaleDays = min(365, m.ScaleDays+1) + m.ScaleLastDay = day + } + m.ScaleLastMs = t.UnixMilli() + if m.ScaleSamples < 4 || t.UnixMilli()-m.ScaleStartMs < int64(45*time.Minute/time.Millisecond) { + return + } + if direction < 0 { + need := uint16(3) + if m.ScaleCandidateW < base*.05 { + need = 7 + } + if m.ScaleDays < need { + return + } + } + m.InferredScaleW = math.Min(maxLearningW, m.ScaleCandidateW) + m.InferredScaleKnown = true +} + +// Quality is a training-fit diagnostic limited by independent coverage. +// It is not out-of-sample forecast accuracy and must not select a model. func (m Model) Quality() float64 { - if m.Samples < 30 || m.RatedW <= 0 { + scale := m.RatedW + if m.InferredScaleKnown || m.InferredScaleW > 0 { + scale = m.InferredScaleW + } + if m.Samples < 30 || scale <= 0 { return 0 } // Relative MAE vs. rated → inverse (lower MAE = higher quality). - rel := m.MAE / m.RatedW + rel := m.MAE / scale + var coverage float64 + var seen int + for _, days := range m.CoverageDays { + if days > 0 { + coverage += math.Min(1, float64(days)/7) + seen++ + } + } + if seen == 0 { + return 0 + } + coverage /= float64(seen) if rel <= 0.05 { - return 1.0 + return coverage } if rel >= 0.5 { return 0.0 } - return 1.0 - (rel-0.05)/0.45 + return coverage * (1.0 - (rel-0.05)/0.45) } diff --git a/go/internal/pvmodel/model_test.go b/go/internal/pvmodel/model_test.go index 65a6013f..1c2e52be 100644 --- a/go/internal/pvmodel/model_test.go +++ b/go/internal/pvmodel/model_test.go @@ -191,8 +191,8 @@ func TestPredictAtNightReturnsZero(t *testing.T) { t02 := time.Date(2026, 4, 20, 2, 0, 0, 0, time.UTC) cases := []struct { - name string - clearSkyW float64 + name string + clearSkyW float64 }{ {"pitch-dark-midnight", 0}, {"astronomical-twilight", 10}, diff --git a/go/internal/pvmodel/robustness_test.go b/go/internal/pvmodel/robustness_test.go new file mode 100644 index 00000000..a4e875e6 --- /dev/null +++ b/go/internal/pvmodel/robustness_test.go @@ -0,0 +1,198 @@ +package pvmodel + +import ( + "math" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func TestPVSamplingFreshZeroMissingStaleCurtailment(t *testing.T) { + at := time.Now() + for _, test := range []struct { + name string + zero, offline, missing, stale, curtailed bool + want bool + }{ + {name: "fresh", want: true}, {name: "healthy_zero", zero: true, want: true}, + {name: "offline", offline: true}, {name: "missing", missing: true}, {name: "stale", stale: true}, {name: "curtailed", curtailed: true}, + } { + t.Run(test.name, func(t *testing.T) { + tel := telemetry.NewStore() + w := -8000.0 + if test.zero { + w = 0 + } + tel.Update("pv", telemetry.DerPV, w, nil, nil) + tel.RecordDriverSuccess("pv") + if test.offline { + tel.WatchdogScan(-time.Nanosecond) + } + s := NewService(nil, tel, func(time.Time) float64 { return 700 }, func(time.Time) (float64, bool) { return 0, true }, 1000) + s.CurtailmentActive = func() bool { return test.curtailed } + if test.missing { + s.SetForecastOptions(telemetry.ForecastOptions{ExpectedFlows: []telemetry.ForecastFlow{{Driver: "missing-pv", DerType: telemetry.DerPV}}}) + } + now := time.Now() + if test.stale { + now = at.Add(5 * time.Minute) + } + s.sampleAt(now) + if got := s.Model().Samples > 0; got != test.want { + t.Fatalf("trained=%v want=%v", got, test.want) + } + }) + } +} + +func TestLegacyPVLongStreamStaysFiniteAndLearning(t *testing.T) { + m := NewModel(1000) + start := time.Date(2026, 6, 1, 11, 0, 0, 0, time.UTC) + accepted := 0 + for i := 0; i < 100000; i++ { + at := start.Add(time.Duration(i) * time.Minute) + if m.Update(800, 0, at, 8000) { + accepted++ + } + if i > 1000 && i%1000 == 0 { + if p := m.Predict(800, 0, at); !finite(p) || math.Abs(p-8000) > 1600 { + t.Fatalf("unstable stream at %d: %.0fW", i, p) + } + } + } + if accepted < 95000 { + t.Fatalf("steady stream stopped learning: %d accepted", accepted) + } + for _, row := range m.P { + for _, v := range row { + if !finite(v) { + t.Fatal("nonfinite covariance") + } + } + } +} + +func TestLegacyZeroScaleAndIndependentCoverageSurviveRestart(t *testing.T) { + db := openTestDB(t) + s := NewService(db, nil, nil, nil, 10000) + s.SetACLimit(11000) + at := time.Date(2026, 6, 1, 11, 0, 0, 0, time.UTC) + for day := 0; day < 8; day++ { + s.model.Update(800, 0, at.Add(time.Duration(day)*24*time.Hour), 0) + } + s.persist() + restored := NewService(db, nil, nil, nil, 10000) + if restored.Model() != s.Model() { + t.Fatal("restart lost learned state") + } + if p := restored.Model().Predict(800, 0, at.Add(8*24*time.Hour)); p > 1 { + t.Fatalf("known zero treated as missing scale: %.0fW", p) + } + if restored.Model().Trust(at.Add(8*24*time.Hour)) < 1 { + t.Fatal("restart lost independent day coverage") + } +} + +func TestLegacyNumericalInputsDoNotPoisonState(t *testing.T) { + m := NewModel(5000) + at := time.Now() + for _, v := range []float64{math.NaN(), math.Inf(1), math.Inf(-1)} { + if m.Update(v, 0, at, 1000) || m.Update(800, v, at, 1000) || m.Update(800, 0, at, v) { + t.Fatal("nonfinite input accepted") + } + } + m.P[1][1] = math.Inf(1) + if !m.Update(800, 0, at, 4000) { + t.Fatal("damaged covariance prevented recovery") + } + if !finite(m.Predict(800, 0, at)) { + t.Fatal("damaged covariance poisoned prediction") + } +} + +func TestLegacyUnknownScaleCoverageAndRegime(t *testing.T) { + at := time.Date(2026, 6, 1, 11, 0, 0, 0, time.UTC) + m := NewModel(1000) + if !m.Update(800, 0, at, 8000) { + t.Fatal("guessed nameplate rejected real scale") + } + for minute := 1; minute < 60; minute++ { + m.Update(800, 0, at.Add(time.Duration(minute)*time.Minute), 8000) + } + if m.Trust(at) > 1.0/7 { + t.Fatal("correlated minute samples granted full trust") + } + if m.Trust(at.Add(6*time.Hour)) != 0 { + t.Fatal("morning granted afternoon trust") + } + for day := 1; day < 10; day++ { + for minute := 0; minute < 60; minute++ { + m.Update(800, 0, at.Add(time.Duration(day)*24*time.Hour+time.Duration(minute)*time.Minute), 8000) + } + } + start := at.Add(10 * 24 * time.Hour) + accepted := 0 + for minute := 0; minute < 90; minute++ { + if m.Update(800, 0, start.Add(time.Duration(minute)*time.Minute), 1000) { + accepted++ + } + } + if accepted < 20 { + t.Fatalf("regime remains locked out: %d accepted", accepted) + } + // A new site-wide scale needs support on separate days; short-term bias + // has its own residual correction and must not resize tomorrow's prior. + for day := 1; day < 8; day++ { + for minute := 0; minute < 60; minute++ { + m.Update(800, 0, start.Add(time.Duration(day)*24*time.Hour+time.Duration(minute)*time.Minute), 1000) + } + } + if got := m.Predict(800, 0, start.Add(8*24*time.Hour)); got > 4000 { + t.Fatalf("regime failed to lower structural forecast: %.0f", got) + } +} + +func TestLegacySingleHealthyZeroDoesNotEraseGlobalScale(t *testing.T) { + m := NewModel(8000) + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + before := m.Predict(800, 0, at.Add(24*time.Hour)) + if !m.Update(800, 0, at, 0) { + t.Fatal("healthy zero should train") + } + after := m.Predict(800, 0, at.Add(24*time.Hour)) + if after < before*.8 || m.InferredScaleKnown { + t.Fatalf("one zero erased the whole-site scale: %.0f -> %.0f", before, after) + } +} + +func TestLegacyCloudRegimeDoesNotResizePlant(t *testing.T) { + m := NewModel(8000) + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + for i := 0; i < 60; i++ { + m.Update(800, 0, at.Add(time.Duration(i)*time.Minute), 6400) + } + for i := 60; i < 80; i++ { + m.Update(800, 100, at.Add(time.Duration(i)*time.Minute), 1000) + } + if p := m.Predict(800, 0, at.Add(24*time.Hour)); p > 6400*1.1 { + t.Fatalf("cloud error resized plant: %.0fW", p) + } + if m.InferredScaleW > 8000 { + t.Fatalf("overcast inferred %.0fW of capacity", m.InferredScaleW) + } +} + +func TestLegacyCoverageAgesAcrossSeasons(t *testing.T) { + m := NewModel(8000) + at := time.Date(2026, 1, 5, 12, 0, 0, 0, time.UTC) + for i := 0; i < 8; i++ { + m.Update(800, 0, at.AddDate(0, 0, i), 6400) + } + if m.Trust(at.AddDate(0, 0, 8)) < 0.99 { + t.Fatal("fresh independent coverage lost") + } + if m.Trust(at.AddDate(0, 0, 190)) > 0.01 { + t.Fatal("previous season still grants full trust") + } +} diff --git a/go/internal/pvmodel/service.go b/go/internal/pvmodel/service.go index 068ef23c..01b216cc 100644 --- a/go/internal/pvmodel/service.go +++ b/go/internal/pvmodel/service.go @@ -15,7 +15,7 @@ import ( // The `_utc` suffix invalidates pre-UTC-coercion models: learned β // coefficients were fitted against local-zone hour-of-day harmonic // features and would silently misalign if restored under the current -// UTC-based Features(). Fresh init + ~50 samples retrains. +// UTC-based Features(). Fresh state must earn new coverage. const stateKey = "pvmodel/state_utc" // legacyFeatureHash is the fingerprint of the feature space in force when the @@ -51,10 +51,15 @@ type Service struct { Cloud CloudFunc SampleInterval time.Duration PersistEvery int64 // samples between SQLite writes + // CurtailmentActive must include commands awaiting release confirmation. + // Curtailed production is not available PV and cannot train the model. + CurtailmentActive func() bool + forecastOptions telemetry.ForecastOptions - mu sync.RWMutex - model *Model - persistMu sync.Mutex // serialises SQLite writes so a stale persist can't clobber a Reset + mu sync.RWMutex + model *Model + generation uint64 // invalidates samples read before a site reset + persistMu sync.Mutex // serialises SQLite writes so a stale persist can't clobber a Reset // Residuals captures (predicted_at_t, actual_at_t) pairs to compute a // short-horizon additive correction the MPC applies on top of the @@ -69,6 +74,9 @@ type Service struct { // NewService constructs the service. If model state exists in the DB, // it's restored; otherwise a fresh prior is initialized using ratedW. func NewService(st *state.Store, tel *telemetry.Store, cs ClearSkyFunc, cf CloudFunc, ratedW float64) *Service { + if !finite(ratedW) || ratedW < 0 || ratedW > maxLearningW { + ratedW = 0 + } s := &Service{ Store: st, Tele: tel, @@ -92,8 +100,7 @@ func NewService(st *state.Store, tel *telemetry.Store, cs ClearSkyFunc, cf Cloud } if reason != "" { // Info, not Warn: a cold start is the designed response to - // state we cannot vouch for, and ~50 daylight samples - // rebuild it. Both hashes go in the line so an operator can + // state we cannot vouch for. Both hashes let an operator // tell "the features changed under me" from "the file is // damaged" without a debugger. slog.Info("pvmodel: discarding learned state, cold starting", @@ -129,14 +136,10 @@ func (s *Service) Model() Model { return *s.model } -// SetRated updates the array nameplate (W) used by the model's output -// envelope, input outlier guards, and cold-start prior. Learned RLS -// coefficients are NOT reset — the twin has already adapted to reality -// so the learned fit stays more accurate than a fresh prior. Call -// `POST /api/pvmodel/reset` separately if the array itself changed -// and you want the model to re-seed. +// SetRated updates the scale prior without resetting the learned coefficients. +// It is a soft prior; only SetACLimit may impose a hardware boundary. func (s *Service) SetRated(w float64) { - if s == nil || w <= 0 { + if s == nil || !finite(w) || w < 0 || w > maxLearningW { return } s.mu.Lock() @@ -148,6 +151,50 @@ func (s *Service) SetRated(w float64) { } } +// SetACLimit sets a verified inverter AC limit. Zero means unknown. +// A configured DC nameplate or inferred rating must never be passed here. +func (s *Service) SetACLimit(w float64) { + if s == nil || !finite(w) || w < 0 || w > maxLearningW { + return + } + s.mu.Lock() + s.model.ACLimitW = w + s.mu.Unlock() +} + +func (s *Service) SetForecastOptions(options telemetry.ForecastOptions) { + if s == nil { + return + } + options.ExpectedFlows = append([]telemetry.ForecastFlow(nil), options.ExpectedFlows...) + s.mu.Lock() + s.forecastOptions = options + s.generation++ // an in-flight sample may have used the previous identity gate + s.mu.Unlock() +} + +// Reconfigure replaces the site function and binds the model to its config +// revision in the same persisted JSON. A changed or previously absent revision +// clears learned state. Without a revision it always resets. A sampler that +// read old inputs cannot train the new model. Set any new rating first. +func (s *Service) Reconfigure(clearSky ClearSkyFunc, revision ...string) { + if s == nil || clearSky == nil { + return + } + s.mu.Lock() + s.ClearSky = clearSky + if len(revision) == 0 || revision[0] == "" || revision[0] != s.model.ConfigRevision { + s.resetLocked() + } else { + s.generation++ + } + if len(revision) > 0 { + s.model.ConfigRevision = revision[0] + } + s.mu.Unlock() + s.persist() +} + // PredictStructural returns the RLS-driven prediction WITHOUT the // now-anchor live-telemetry correction. This is the surface the MPC and // residual-buffer sampler consume: the residual buffer measures and @@ -159,10 +206,13 @@ func (s *Service) PredictStructural(t time.Time, cloudPct float64) float64 { if s == nil { return 0 } - cs := s.ClearSky(t) s.mu.RLock() - defer s.mu.RUnlock() - return s.model.Predict(cs, cloudPct, t) + clearSky, m := s.ClearSky, *s.model + s.mu.RUnlock() + if clearSky == nil { + return 0 + } + return m.Predict(clearSky(t), cloudPct, t) } // Predict is the main integration point for the UI + dispatch live-reading @@ -178,17 +228,19 @@ func (s *Service) PredictStructural(t time.Time, cloudPct float64) float64 { // (weather shifts blur the correction). See applyNowAnchor for the math. // // This guards against systematically-wrong forecasts (met.no predicts -// cloudy, sky is clear) that the RLS would need ~50 samples to learn -// away — the twin should react to reality *now*, not in an hour. +// cloudy, sky is clear) while the structural model learns more slowly. func (s *Service) Predict(t time.Time, cloudPct float64) float64 { if s == nil { return 0 } - cs := s.ClearSky(t) s.mu.RLock() - basePred := s.model.Predict(cs, cloudPct, t) - rated := s.model.RatedW + clearSky, m := s.ClearSky, *s.model s.mu.RUnlock() + if clearSky == nil { + return 0 + } + basePred := m.Predict(clearSky(t), cloudPct, t) + rated := m.ACLimitW actualNow, ok := s.liveActualPV() if !ok { @@ -201,10 +253,7 @@ func (s *Service) Predict(t time.Time, cloudPct float64) float64 { cloudNow = v } } - csNow := s.ClearSky(now) - s.mu.RLock() - priorNow := s.model.Predict(csNow, cloudNow, now) - s.mu.RUnlock() + priorNow := m.Predict(clearSky(now), cloudNow, now) anchored := applyNowAnchor(basePred, priorNow, actualNow, t.Sub(now)) if rated > 0 && anchored > rated { @@ -237,10 +286,10 @@ const NowAnchorClamp = 5.0 // caller stays simple and tests can exercise every edge case without // wiring a telemetry store. // -// basePred : model.Predict(t, cloudPct_t) — in W -// priorNow : model.Predict(now, cloudPct_now) — in W -// actualNow: summed live PV telemetry right now — in W (≥ 0) -// dt : t − now (signed) +// basePred : model.Predict(t, cloudPct_t) — in W +// priorNow : model.Predict(now, cloudPct_now) — in W +// actualNow: summed live PV telemetry right now — in W (≥ 0) +// dt : t − now (signed) // // Rules: // - dt > NowAnchorHorizon → no correction (return basePred). @@ -288,26 +337,21 @@ func applyNowAnchor(basePred, priorNow, actualNow float64, dt time.Duration) flo return anchored } -// liveActualPV sums SmoothedW across every PV reading, flipping site- -// sign to produce a non-negative generation value. Mirrors sample(). -// Returns (value, false) when nothing's reporting — so Predict falls -// back to pure-model behavior instead of pretending we saw 0 W. +// liveActualPV returns fresh raw generation across all expected PV flows. +// Healthy zero is valid; missing, stale and actively curtailed data are not. func (s *Service) liveActualPV() (float64, bool) { - if s.Tele == nil { - return 0, false - } - var pvW float64 - count := 0 - for _, r := range s.Tele.ReadingsByType(telemetry.DerPV) { - if r.SmoothedW < 0 { - pvW += -r.SmoothedW - count++ - } - } - if count == 0 || pvW < 1 { + return s.liveActualPVAt(time.Now()) +} + +func (s *Service) liveActualPVAt(now time.Time) (float64, bool) { + if s.Tele == nil || (s.CurtailmentActive != nil && s.CurtailmentActive()) { return 0, false } - return pvW, true + s.mu.RLock() + options := s.forecastOptions + s.mu.RUnlock() + m := s.Tele.ForecastMeasurement(now, "", options) + return -m.PVW, m.PVValid } // PredictNow returns the twin's prediction for right now using the @@ -367,31 +411,31 @@ func (s *Service) loop(ctx context.Context) { // sample reads current PV telemetry, pulls current clear-sky + cloud, // and runs one RLS update. func (s *Service) sample() { - now := time.Now() - cs := s.ClearSky(now) - if cs < 50 { + s.sampleAt(time.Now()) +} + +func (s *Service) sampleAt(now time.Time) { + s.mu.RLock() + clearSky, generation := s.ClearSky, s.generation + s.mu.RUnlock() + if clearSky == nil { + return + } + cs := clearSky(now) + if !finite(cs) || cs < 50 || cs > 2000 { slog.Debug("pvmodel: skip (night)", "cs", cs) return // night / near-night — no signal } - cloud := 50.0 // neutral fallback if no forecast row + cloud, cloudOK := 0.0, false if s.Cloud != nil { - if v, ok := s.Cloud(now); ok { - cloud = v + if v, ok := s.Cloud(now); ok && finite(v) && v >= 0 && v <= 100 { + cloud, cloudOK = v, true } } // Aggregate PV across all drivers. PV telemetry is stored as // site-sign (negative = generating), so flip to positive. - var pvW float64 - readings := s.Tele.ReadingsByType(telemetry.DerPV) - for _, r := range readings { - if r.SmoothedW < 0 { - pvW += -r.SmoothedW - } - } - // Guard: if all drivers report 0 when there's meaningful clear-sky, - // that's likely a driver outage — skip so we don't learn "0 output". - if pvW < 1 { - slog.Debug("pvmodel: skip (no PV reading)", "readings", len(readings), "cs", cs) + pvW, valid := s.liveActualPVAt(now) + if !valid { return } @@ -403,19 +447,25 @@ func (s *Service) sample() { // is correcting that structural output. The Residuals buffer // itself applies the gates / fade / variance check. s.mu.Lock() + if generation != s.generation { + s.mu.Unlock() + return + } predicted := s.model.Predict(cs, cloud, now) - updated := s.model.Update(cs, cloud, now, pvW) + updated := false + if cloudOK { + updated = s.model.Update(cs, cloud, now, pvW) + } samples := s.model.Samples mae := s.model.MAE - s.mu.Unlock() - - if s.Residuals != nil { + if s.Residuals != nil && cloudOK { s.Residuals.Add(now, predicted, pvW) } + s.mu.Unlock() slog.Info("pvmodel: sample", "cs_wm2", cs, "cloud_pct", cloud, "pv_w", pvW, "samples", samples, "mae_w", mae, "updated", updated) - if updated && samples%s.PersistEvery == 0 { + if updated && s.PersistEvery > 0 && samples%s.PersistEvery == 0 { s.persist() } } @@ -449,11 +499,20 @@ func (s *Service) Reset() { return } s.mu.Lock() + s.resetLocked() + s.mu.Unlock() + s.persist() +} + +func (s *Service) resetLocked() { rated := s.model.RatedW + ac := s.model.ACLimitW + revision := s.model.ConfigRevision s.model = NewModel(rated) + s.model.ACLimitW = ac + s.model.ConfigRevision = revision s.Residuals = NewResidualBuffer() - s.mu.Unlock() - s.persist() + s.generation++ } // ResidualCorrect is the integration point for the MPC. Returns the @@ -465,19 +524,25 @@ func (s *Service) Reset() { // underlying pvmodel.Predict). Callers consuming site-sign PV (e.g. // mpc.buildSlots which negates) should match the sign at their boundary. func (s *Service) ResidualCorrect(now, tTarget time.Time, basePrediction float64) float64 { - if s == nil || s.Residuals == nil { + if s == nil { return 0 } - return s.Residuals.Correct(now, tTarget, basePrediction) + s.mu.RLock() + residuals := s.Residuals + s.mu.RUnlock() + return residuals.Correct(now, tTarget, basePrediction) } // ResidualDiagSnapshot returns the current residual-buffer state for // /api/pvmodel diagnostics. Zero-valued when the buffer is empty. func (s *Service) ResidualDiagSnapshot() ResidualDiag { - if s == nil || s.Residuals == nil { + if s == nil { return ResidualDiag{WindowMinutes: int(ResidualBufferWindow.Minutes())} } - return s.Residuals.Diag(time.Now()) + s.mu.RLock() + residuals := s.Residuals + s.mu.RUnlock() + return residuals.Diag(time.Now()) } // ResidualStdW returns the std (W) of recent PV-prediction residuals — the diff --git a/go/internal/pvmodel/service_test.go b/go/internal/pvmodel/service_test.go index 2144c30c..5d3a600f 100644 --- a/go/internal/pvmodel/service_test.go +++ b/go/internal/pvmodel/service_test.go @@ -179,6 +179,7 @@ func TestService_PredictAnchorsOnLiveTelemetry(t *testing.T) { tel := telemetry.NewStore() // Site convention: PV is negative. 8000 W = -8000 stored. tel.Update("pv", telemetry.DerPV, -8000, nil, nil) + tel.RecordDriverSuccess("pv") svc := &Service{ Tele: tel, @@ -223,6 +224,7 @@ func TestService_PredictFallsBackWhenNoTelemetry(t *testing.T) { func TestPredict_AppliesNowAnchor(t *testing.T) { tel := telemetry.NewStore() tel.Update("pv", telemetry.DerPV, -8000, nil, nil) + tel.RecordDriverSuccess("pv") svc := &Service{ Tele: tel, @@ -249,6 +251,7 @@ func TestPredictStructural_DoesNotApplyNowAnchor(t *testing.T) { tel := telemetry.NewStore() // 8 kW live, but model predicts ~715 W from the prior. tel.Update("pv", telemetry.DerPV, -8000, nil, nil) + tel.RecordDriverSuccess("pv") svc := &Service{ Tele: tel, @@ -286,16 +289,16 @@ func TestPredictStructural_StillRespectsRLS(t *testing.T) { now := time.Date(2026, 4, 15, 12, 0, 0, 0, time.UTC) before := svc.PredictStructural(now, 20) - // Drive ~60 RLS updates against a synthetic "actual" that is well + // Drive RLS updates on 60 separate days against an actual value well // above what the cold-start prior would predict. RLS should track // the new operating point. target := before * 1.6 for i := 0; i < 60; i++ { svc.mu.Lock() - svc.model.Update(800, 20, now, target) + svc.model.Update(800, 20, now.Add(time.Duration(i)*24*time.Hour), target) svc.mu.Unlock() } - after := svc.PredictStructural(now, 20) + after := svc.PredictStructural(now.Add(60*24*time.Hour), 20) if after <= before*1.1 { t.Errorf("PredictStructural did not track RLS update: before=%.0f W, after=%.0f W (target was %.0f W)", before, after, target) } @@ -315,6 +318,7 @@ func TestPredictStructural_StillRespectsRLS(t *testing.T) { func TestResidualBufferSampler_UsesStructuralPrediction(t *testing.T) { tel := telemetry.NewStore() tel.Update("pv", telemetry.DerPV, -8000, nil, nil) + tel.RecordDriverSuccess("pv") svc := &Service{ Tele: tel, diff --git a/go/internal/pvmodel/snapshot.go b/go/internal/pvmodel/snapshot.go new file mode 100644 index 00000000..eea66ede --- /dev/null +++ b/go/internal/pvmodel/snapshot.go @@ -0,0 +1,107 @@ +package pvmodel + +import ( + "crypto/sha256" + "encoding/json" + "fmt" + "math" + "time" +) + +// ResidualObservation is the portable inference state for the short forecast +// correction. Both powers are non-negative generation watts. +type ResidualObservation struct { + At time.Time `json:"at"` + PredictedW float64 `json:"predicted_w"` + ActualW float64 `json:"actual_w"` +} + +// ForecastSnapshot freezes the existing RLS model and its residual window for +// one issued horizon. Weather and clear-sky inputs come from the same caller's +// frozen forecast. Revision hashes inference state, excluding capture time. +type ForecastSnapshot struct { + Model Model `json:"model"` + Residuals []ResidualObservation `json:"residuals"` + Revision string `json:"revision"` + LatestInput time.Time `json:"latest_input"` + CapturedAt time.Time `json:"captured_at"` +} + +func (s *Service) ForecastSnapshot() ForecastSnapshot { + var out ForecastSnapshot + if s == nil { + return out + } + s.mu.RLock() + if s.model != nil { + out.Model = *s.model + } + if s.Residuals != nil { + s.Residuals.mu.Lock() + for _, p := range s.Residuals.samples { + out.Residuals = append(out.Residuals, ResidualObservation{p.t.UTC(), p.predicted, p.actual}) + } + s.Residuals.mu.Unlock() + } + out.CapturedAt = time.Now().UTC() + s.mu.RUnlock() + if out.Model.LastMs > 0 { + out.LatestInput = time.UnixMilli(out.Model.LastMs).UTC() + } + for _, p := range out.Residuals { + if p.At.After(out.LatestInput) { + out.LatestInput = p.At + } + } + state, err := json.Marshal(struct { + Model Model + Residuals []ResidualObservation + }{out.Model, out.Residuals}) + if err == nil { + out.Revision = fmt.Sprintf("pv-legacy/%s/%x", FeatureHash(), sha256.Sum256(state)) + } + return out +} + +func (s ForecastSnapshot) Structural(target time.Time, clearSkyWm2, cloudPct float64) float64 { + return s.Model.Predict(clearSkyWm2, cloudPct, target) +} + +func (s ForecastSnapshot) residualStats(origin time.Time) (n int, mean, std float64) { + cutoff := origin.Add(-ResidualBufferWindow) + var m2 float64 + for _, p := range s.Residuals { + if p.At.Before(cutoff) || p.At.After(origin) || !finite(p.ActualW) || !finite(p.PredictedW) { + continue + } + n++ + x := p.ActualW - p.PredictedW + delta := x - mean + mean += delta / float64(n) + m2 += delta * (x - mean) + } + if n > 0 { + std = math.Sqrt(math.Max(0, m2/float64(n))) + } + return +} + +func (s ForecastSnapshot) ResidualCorrect(origin, target time.Time, base float64) float64 { + _ = base + dt := target.Sub(origin) + if dt <= 0 || dt > residualFadeEnd { + return 0 + } + n, mean, std := s.residualStats(origin) + if n < residualMinSamples || math.Abs(mean) < residualEpsilonW || std/math.Max(1, math.Abs(mean)) > residualMaxCoVar { + return 0 + } + return mean * residualFadeFactor(dt) +} + +func (s ForecastSnapshot) RelativeUncertainty() float64 { return s.Model.RelMAE } + +func (s ForecastSnapshot) ResidualStdW(origin time.Time) float64 { + _, _, std := s.residualStats(origin) + return std +} diff --git a/go/internal/pvmodel/snapshot_test.go b/go/internal/pvmodel/snapshot_test.go new file mode 100644 index 00000000..64d57226 --- /dev/null +++ b/go/internal/pvmodel/snapshot_test.go @@ -0,0 +1,160 @@ +package pvmodel + +import ( + "encoding/json" + "math" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/telemetry" +) + +func TestForecastSnapshotFreezesWholeHorizon(t *testing.T) { + s := NewService(nil, nil, nil, nil, 5000) + origin := time.Date(2026, 6, 15, 11, 0, 0, 0, time.UTC) + for i := 0; i < 30; i++ { + s.Residuals.Add(origin.Add(-time.Duration(i)*time.Minute), 1000, 1500) + } + s.model.LastMs = origin.UnixMilli() + snapshot := s.ForecastSnapshot() + for i := 0; i < 30; i++ { + s.Residuals.Add(origin.Add(time.Duration(i)*time.Minute), 1000, 2000) + } + s.SetRated(12000) + want := snapshot.Structural(origin, 700, 20) + if snapshot.ResidualCorrect(origin, origin.Add(15*time.Minute), want) != 500 { + t.Fatal("later residuals changed issued snapshot") + } + if snapshot.Revision == s.ForecastSnapshot().Revision { + t.Fatal("state changed without a new revision") + } + if snapshot.LatestInput != origin { + t.Fatalf("latest input %v", snapshot.LatestInput) + } + var restored ForecastSnapshot + encoded, err := json.Marshal(snapshot) + if err != nil { + t.Fatal(err) + } + if err := json.Unmarshal(encoded, &restored); err != nil { + t.Fatal(err) + } + if restored.Structural(origin, 700, 20) != want || restored.ResidualCorrect(origin, origin.Add(time.Hour), want) != snapshot.ResidualCorrect(origin, origin.Add(time.Hour), want) || restored.Revision != snapshot.Revision { + t.Fatal("serialized inference cannot replay") + } + // The capture time is not a learned model revision. + if s.ForecastSnapshot().Revision != s.ForecastSnapshot().Revision { + t.Fatal("unchanged inference state got a new revision") + } +} + +func TestForecastSnapshotResidualsExcludeFutureAndExpire(t *testing.T) { + s := NewService(nil, nil, nil, nil, 5000) + origin := time.Date(2026, 6, 15, 11, 0, 0, 0, time.UTC) + for i := 0; i < 30; i++ { + s.Residuals.Add(origin.Add(time.Duration(i+1)*time.Second), 1000, 1500) + } + p := s.ForecastSnapshot() + if p.ResidualCorrect(origin, origin.Add(time.Minute), 1000) != 0 { + t.Fatal("future labels leaked into correction") + } + later := origin.Add(time.Minute) + if p.ResidualCorrect(later, later.Add(15*time.Minute), 1000) != 500 { + t.Fatal("available observations not used") + } + if p.ResidualCorrect(origin.Add(3*time.Hour), origin.Add(4*time.Hour), 1000) != 0 { + t.Fatal("stale residuals did not expire") + } +} + +func TestForecastSnapshotMatchesLegacyCorrection(t *testing.T) { + s := NewService(nil, nil, nil, nil, 5000) + origin := time.Now() + for i := 0; i < 30; i++ { + s.Residuals.Add(origin.Add(-time.Duration(i)*time.Minute), 1000, 1500+float64(i*10)) + } + p := s.ForecastSnapshot() + for _, minutes := range []int{0, 15, 30, 60, 120, 180} { + target := origin.Add(time.Duration(minutes) * time.Minute) + if math.Abs(p.ResidualCorrect(origin, target, 1000)-s.ResidualCorrect(origin, target, 1000)) > 1e-9 { + t.Fatalf("legacy behavior changed at horizon %dm", minutes) + } + } +} + +func TestReconfigureRejectsOldSiteSample(t *testing.T) { + db := openTestDB(t) + entered, release := make(chan struct{}), make(chan struct{}) + tel := telemetry.NewStore() + tel.Update("pv", telemetry.DerPV, -4000, nil, nil) + tel.RecordDriverSuccess("pv") + s := NewService(db, tel, func(time.Time) float64 { close(entered); <-release; return 800 }, func(time.Time) (float64, bool) { return 0, true }, 5000) + s.Residuals.Add(time.Now(), 1000, 2000) + done := make(chan struct{}) + go func() { s.sampleAt(time.Now()); close(done) }() + <-entered + s.Reconfigure(func(time.Time) float64 { return 400 }) + close(release) + <-done + if m := s.Model(); m.Samples != 0 || s.Residuals.Len() != 0 { + t.Fatal("old-site sample survived reset") + } + if got := s.PredictStructural(time.Now(), 0); got != 2000 { + t.Fatalf("new location callback not applied: %.0f", got) + } + restored := NewService(db, nil, nil, nil, 5000) + if restored.Model().Samples != 0 { + t.Fatal("site reset not persisted") + } +} + +func TestReconfigurePersistsRevisionWithModel(t *testing.T) { + db := openTestDB(t) + cs := func(time.Time) float64 { return 800 } + s := NewService(db, nil, cs, nil, 5000) + s.Reconfigure(cs, "site-v1") + s.model.Update(800, 0, time.Now(), 4000) + s.persist() + restored := NewService(db, nil, cs, nil, 5000) + restored.Reconfigure(cs, "site-v1") + if m := restored.Model(); m.Samples != 1 || m.ConfigRevision != "site-v1" { + t.Fatal("same config discarded bound state") + } + restored.Reconfigure(cs, "site-v2") + if m := restored.Model(); m.Samples != 0 || m.ConfigRevision != "site-v2" { + t.Fatal("new config retained old training") + } + last := NewService(db, nil, cs, nil, 5000).Model() + if last.ConfigRevision != "site-v2" || last.Samples != 0 { + t.Fatal("revision and clean model were not persisted together") + } +} + +func BenchmarkLegacyPVUpdate(b *testing.B) { + m := NewModel(5000) + at := time.Date(2026, 6, 15, 11, 0, 0, 0, time.UTC) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + m.Update(700, 20, at.Add(time.Duration(i)*time.Minute), 3000) + } + b.ReportMetric(float64(m.Samples)/float64(b.N), "accepted/op") +} + +func BenchmarkLegacyPVSnapshotHorizon(b *testing.B) { + s := NewService(nil, nil, nil, nil, 5000) + origin := time.Now() + for i := 0; i < 240; i++ { + s.Residuals.Add(origin.Add(-time.Duration(240-i)*30*time.Second), 1000, 1500) + } + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + p := s.ForecastSnapshot() + for q := 0; q < 192; q++ { + at := origin.Add(time.Duration(q) * 15 * time.Minute) + base := p.Structural(at, 700, 20) + p.ResidualCorrect(origin, at, base) + } + } +} diff --git a/go/internal/state/forecast_cache.go b/go/internal/state/forecast_cache.go new file mode 100644 index 00000000..3e3f8155 --- /dev/null +++ b/go/internal/state/forecast_cache.go @@ -0,0 +1,8 @@ +package state + +// InvalidateWeatherForecasts discards the replaceable weather cache after a +// source or site change. Immutable issued forecasts remain in the archive. +func (s *Store) InvalidateWeatherForecasts() error { + _, err := s.cache.Exec("DELETE FROM forecasts") + return err +} diff --git a/go/internal/state/forecast_issues.go b/go/internal/state/forecast_issues.go new file mode 100644 index 00000000..61201224 --- /dev/null +++ b/go/internal/state/forecast_issues.go @@ -0,0 +1,571 @@ +package state + +import ( + "bytes" + "compress/gzip" + "context" + "crypto/sha256" + "database/sql" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "time" + + "github.com/srcfl/ftw/go/internal/forecasting" +) + +const ( + ForecastIssueRetention = 30 * 24 * time.Hour + + MaxForecastIssues = 4096 + MaxForecastArchiveBytes = 64 << 20 + MaxForecastModelStateBytes = 64 << 20 + MaxForecastObservations = 8192 + MaxForecastObservationBytes = 16 << 20 + MaxForecastErrors = 65536 + MaxForecastErrorBytes = 64 << 20 + + maxForecastCompressedBytes = 64 << 10 + maxForecastModelCompressed = 256 << 10 + maxForecastRecordBytes = 8 << 10 + maxForecastSliceBytes = 32 << 20 + maxForecastFutureSkew = 5 * time.Minute +) + +// InitForecastArchive creates additive tables in precious state.db. Issued +// forecasts cannot be fetched again from a weather API. Old binaries can +// reopen the database and ignore these tables. +func (s *Store) InitForecastArchive(ctx context.Context) error { + _, err := s.db.ExecContext(ctx, ` +CREATE TABLE IF NOT EXISTS forecast_issues ( + id TEXT PRIMARY KEY, origin_ms INTEGER NOT NULL, issued_at_ms INTEGER NOT NULL, + config_version TEXT NOT NULL, payload BLOB NOT NULL); +CREATE INDEX IF NOT EXISTS forecast_issues_time ON forecast_issues(issued_at_ms); +CREATE TABLE IF NOT EXISTS forecast_model_states ( + id TEXT PRIMARY KEY, expanded_bytes INTEGER NOT NULL, created_at_ms INTEGER NOT NULL, + payload BLOB NOT NULL); +CREATE TABLE IF NOT EXISTS forecast_issue_model_states ( + issue_id TEXT NOT NULL, state_id TEXT NOT NULL, + PRIMARY KEY(issue_id,state_id)); +CREATE INDEX IF NOT EXISTS forecast_issue_model_state_ref ON forecast_issue_model_states(state_id); +CREATE TABLE IF NOT EXISTS forecast_observations ( + start_ms INTEGER NOT NULL, end_ms INTEGER NOT NULL, available_at_ms INTEGER NOT NULL, + config_version TEXT NOT NULL, payload TEXT NOT NULL, + PRIMARY KEY(start_ms,end_ms,config_version)); +CREATE INDEX IF NOT EXISTS forecast_observations_time ON forecast_observations(available_at_ms); +CREATE TABLE IF NOT EXISTS forecast_errors ( + series TEXT NOT NULL, config_version TEXT NOT NULL, lead INTEGER NOT NULL, + start_ms INTEGER NOT NULL, end_ms INTEGER NOT NULL, origin_ms INTEGER NOT NULL, + issued_at_ms INTEGER NOT NULL, issue_id TEXT NOT NULL, + available_at_ms INTEGER NOT NULL, payload TEXT NOT NULL, + PRIMARY KEY(series,config_version,lead,start_ms,end_ms)); +CREATE INDEX IF NOT EXISTS forecast_errors_time ON forecast_errors(start_ms); +`) + return err +} + +func gzipForecastIssue(issue forecasting.Issue) ([]byte, error) { + data, err := json.Marshal(issue) + if err != nil { + return nil, err + } + if len(data) > forecasting.MaxPayloadBytes { + return nil, errors.New("forecast issue exceeds payload limit") + } + var buf bytes.Buffer + z := gzip.NewWriter(&buf) + if _, err = z.Write(data); err != nil { + return nil, err + } + if err = z.Close(); err != nil { + return nil, err + } + if buf.Len() > maxForecastCompressedBytes { + return nil, errors.New("compressed forecast issue exceeds 64 KiB") + } + return buf.Bytes(), nil +} + +func gzipForecastModelState(state json.RawMessage) ([]byte, error) { + if len(state) == 0 || len(state) > forecasting.MaxModelStateBytes || !json.Valid(state) { + return nil, errors.New("invalid forecast model state") + } + var buf bytes.Buffer + z := gzip.NewWriter(&buf) + if _, err := z.Write(state); err != nil { + return nil, err + } + if err := z.Close(); err != nil { + return nil, err + } + if buf.Len() > maxForecastModelCompressed { + return nil, errors.New("compressed forecast model state exceeds 256 KiB") + } + return buf.Bytes(), nil +} + +func externalizeForecastModelStates(ctx context.Context, tx *sql.Tx, issue forecasting.Issue) (forecasting.Issue, error) { + issue.Models = append([]forecasting.ModelState(nil), issue.Models...) + for i := range issue.Models { + model := &issue.Models[i] + model.State = append(json.RawMessage(nil), model.State...) + if len(model.State) == 0 { + if model.StateID == "" { + continue + } + var exists int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM forecast_model_states WHERE id=?", model.StateID).Scan(&exists); err != nil { + return forecasting.Issue{}, err + } + if exists != 1 { + return forecasting.Issue{}, errors.New("forecast model state reference is missing") + } + continue + } + digest := sha256.Sum256(model.State) + stateID := hex.EncodeToString(digest[:]) + if model.StateID != "" && model.StateID != stateID { + return forecasting.Issue{}, errors.New("forecast model state hash mismatch") + } + compressed, err := gzipForecastModelState(model.State) + if err != nil { + return forecasting.Issue{}, err + } + result, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO forecast_model_states(id,expanded_bytes,created_at_ms,payload) + VALUES(?,?,?,?)`, stateID, len(model.State), issue.IssuedAtMS, compressed) + if err != nil { + return forecasting.Issue{}, err + } + if n, _ := result.RowsAffected(); n == 0 { + var expanded int + var old []byte + if err = tx.QueryRowContext(ctx, "SELECT expanded_bytes,payload FROM forecast_model_states WHERE id=?", stateID).Scan(&expanded, &old); err != nil { + return forecasting.Issue{}, err + } + if expanded != len(model.State) || !bytes.Equal(old, compressed) { + return forecasting.Issue{}, errors.New("forecast model state ID is immutable") + } + } + model.StateID = stateID + model.State = nil + } + return issue, issue.Validate() +} + +func cleanForecastModelStateRefs(ctx context.Context, tx *sql.Tx) error { + if _, err := tx.ExecContext(ctx, `DELETE FROM forecast_issue_model_states + WHERE issue_id NOT IN (SELECT id FROM forecast_issues)`); err != nil { + return err + } + _, err := tx.ExecContext(ctx, `DELETE FROM forecast_model_states + WHERE id NOT IN (SELECT state_id FROM forecast_issue_model_states)`) + return err +} + +func enforceForecastModelStateBudget(ctx context.Context, tx *sql.Tx) error { + for { + var total int64 + if err := tx.QueryRowContext(ctx, "SELECT COALESCE(SUM(length(payload)),0) FROM forecast_model_states").Scan(&total); err != nil { + return err + } + if total <= MaxForecastModelStateBytes { + return nil + } + var oldest string + if err := tx.QueryRowContext(ctx, "SELECT id FROM forecast_issues ORDER BY issued_at_ms,id LIMIT 1").Scan(&oldest); err != nil { + return err + } + if _, err := tx.ExecContext(ctx, "DELETE FROM forecast_issues WHERE id=?", oldest); err != nil { + return err + } + if err := cleanForecastModelStateRefs(ctx, tx); err != nil { + return err + } + } +} + +// SaveForecastIssue is append-only within a bounded retention window. +// An identical retry is allowed; reusing an ID for a changed issue is an error. +func (s *Store) SaveForecastIssue(ctx context.Context, issue forecasting.Issue) error { + if err := issue.Validate(); err != nil { + return err + } + now := time.Now().UnixMilli() + if issue.IssuedAtMS > now+maxForecastFutureSkew.Milliseconds() { + return errors.New("forecast issue is from the future") + } + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + storedIssue, err := externalizeForecastModelStates(ctx, tx, issue) + if err != nil { + return err + } + data, err := gzipForecastIssue(storedIssue) + if err != nil { + return err + } + result, err := tx.ExecContext(ctx, "INSERT OR IGNORE INTO forecast_issues(id,origin_ms,issued_at_ms,config_version,payload) VALUES(?,?,?,?,?)", + storedIssue.ID, storedIssue.OriginMS, storedIssue.IssuedAtMS, storedIssue.ConfigVersion, data) + if err != nil { + return err + } + if n, _ := result.RowsAffected(); n == 0 { + var old []byte + if err = tx.QueryRowContext(ctx, "SELECT payload FROM forecast_issues WHERE id=?", storedIssue.ID).Scan(&old); err != nil { + return err + } + if !bytes.Equal(old, data) { + return errors.New("forecast issue ID is immutable") + } + } + for _, model := range storedIssue.Models { + if model.StateID == "" { + continue + } + if _, err = tx.ExecContext(ctx, "INSERT OR IGNORE INTO forecast_issue_model_states(issue_id,state_id) VALUES(?,?)", storedIssue.ID, model.StateID); err != nil { + return err + } + } + if _, err = tx.ExecContext(ctx, "DELETE FROM forecast_issues WHERE issued_at_ms < ?", now-ForecastIssueRetention.Milliseconds()); err != nil { + return err + } + if _, err = tx.ExecContext(ctx, `DELETE FROM forecast_issues WHERE id IN ( + SELECT id FROM (SELECT id,ROW_NUMBER() OVER (ORDER BY issued_at_ms DESC,id DESC) AS n, + SUM(length(payload)) OVER (ORDER BY issued_at_ms DESC,id DESC) AS bytes FROM forecast_issues) + WHERE n>? OR bytes>?)`, MaxForecastIssues, MaxForecastArchiveBytes); err != nil { + return err + } + if err = cleanForecastModelStateRefs(ctx, tx); err != nil { + return err + } + if err = enforceForecastModelStateBudget(ctx, tx); err != nil { + return err + } + return tx.Commit() +} + +func (s *Store) SaveForecastObservation(ctx context.Context, observation forecasting.Observation) error { + if err := observation.Validate(); err != nil { + return err + } + now := time.Now().UnixMilli() + if observation.AvailableAtMS > now+maxForecastFutureSkew.Milliseconds() { + return errors.New("forecast observation is from the future") + } + data, err := json.Marshal(observation) + if err != nil { + return err + } + if len(data) > maxForecastRecordBytes { + return errors.New("forecast observation exceeds payload limit") + } + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + result, err := tx.ExecContext(ctx, "INSERT OR IGNORE INTO forecast_observations(start_ms,end_ms,available_at_ms,config_version,payload) VALUES(?,?,?,?,?)", + observation.StartMS, observation.EndMS, observation.AvailableAtMS, observation.ConfigVersion, string(data)) + if err != nil { + return err + } + if n, _ := result.RowsAffected(); n == 0 { + var old string + if err = tx.QueryRowContext(ctx, "SELECT payload FROM forecast_observations WHERE start_ms=? AND end_ms=? AND config_version=?", + observation.StartMS, observation.EndMS, observation.ConfigVersion).Scan(&old); err != nil { + return err + } + if old != string(data) { + return errors.New("forecast observation is immutable") + } + } + if _, err = tx.ExecContext(ctx, "DELETE FROM forecast_observations WHERE available_at_ms < ?", now-ForecastIssueRetention.Milliseconds()); err != nil { + return err + } + if _, err = tx.ExecContext(ctx, `DELETE FROM forecast_observations WHERE rowid IN ( + SELECT rowid FROM (SELECT rowid,ROW_NUMBER() OVER (ORDER BY available_at_ms DESC,start_ms DESC,end_ms DESC,config_version DESC) AS n, + SUM(length(payload)) OVER (ORDER BY available_at_ms DESC,start_ms DESC,end_ms DESC,config_version DESC) AS bytes FROM forecast_observations) + WHERE n>? OR bytes>?)`, MaxForecastObservations, MaxForecastObservationBytes); err != nil { + return err + } + return tx.Commit() +} + +func decodeForecastIssue(data []byte) (forecasting.Issue, int, error) { + if len(data) > maxForecastCompressedBytes { + return forecasting.Issue{}, 0, errors.New("oversized forecast archive row") + } + z, err := gzip.NewReader(bytes.NewReader(data)) + if err != nil { + return forecasting.Issue{}, 0, err + } + plain, readErr := io.ReadAll(io.LimitReader(z, forecasting.MaxPayloadBytes+1)) + closeErr := z.Close() + if readErr != nil { + return forecasting.Issue{}, 0, readErr + } + if closeErr != nil { + return forecasting.Issue{}, 0, closeErr + } + if len(plain) > forecasting.MaxPayloadBytes { + return forecasting.Issue{}, 0, errors.New("oversized expanded forecast") + } + var issue forecasting.Issue + if err = json.Unmarshal(plain, &issue); err != nil { + return forecasting.Issue{}, 0, err + } + if err = issue.Validate(); err != nil { + return forecasting.Issue{}, 0, fmt.Errorf("invalid archived issue: %w", err) + } + return issue, len(plain), nil +} + +// LoadForecastModelState expands and verifies one content-addressed model +// snapshot for backup or audit export. Normal scoring uses the StateID only. +func (s *Store) LoadForecastModelState(ctx context.Context, stateID string) (json.RawMessage, error) { + decodedID, err := hex.DecodeString(stateID) + if err != nil || len(decodedID) != sha256.Size { + return nil, errors.New("invalid forecast model state ID") + } + var expanded int + var data []byte + if err = s.db.QueryRowContext(ctx, "SELECT expanded_bytes,payload FROM forecast_model_states WHERE id=?", stateID).Scan(&expanded, &data); err != nil { + return nil, err + } + if expanded <= 0 || expanded > forecasting.MaxModelStateBytes || len(data) > maxForecastModelCompressed { + return nil, errors.New("oversized forecast model state") + } + z, err := gzip.NewReader(bytes.NewReader(data)) + if err != nil { + return nil, err + } + plain, readErr := io.ReadAll(io.LimitReader(z, int64(forecasting.MaxModelStateBytes)+1)) + closeErr := z.Close() + if readErr != nil { + return nil, readErr + } + if closeErr != nil { + return nil, closeErr + } + if len(plain) != expanded || len(plain) > forecasting.MaxModelStateBytes || !json.Valid(plain) { + return nil, errors.New("invalid expanded forecast model state") + } + digest := sha256.Sum256(plain) + if hex.EncodeToString(digest[:]) != stateID { + return nil, errors.New("forecast model state hash mismatch") + } + return json.RawMessage(plain), nil +} + +// LoadForecastIssues loads a bounded slice for tests and small tools. Runtime +// evaluation should use VisitForecastIssues so expanded issues do not collect. +func (s *Store) LoadForecastIssues(ctx context.Context, since, until int64, limit int) ([]forecasting.Issue, error) { + if limit <= 0 || limit > MaxForecastIssues { + limit = MaxForecastIssues + } + rows, err := s.db.QueryContext(ctx, "SELECT payload FROM forecast_issues WHERE issued_at_ms>=? AND issued_at_ms<=? ORDER BY issued_at_ms DESC,id DESC LIMIT ?", + since, until, limit+1) + if err != nil { + return nil, err + } + defer rows.Close() + out := make([]forecasting.Issue, 0, min(limit, 64)) + expandedBytes := 0 + for rows.Next() { + if len(out) == limit { + return nil, fmt.Errorf("forecast issue load exceeds slice limit %d; use VisitForecastIssues", limit) + } + var data []byte + if err = rows.Scan(&data); err != nil { + return nil, err + } + issue, size, decodeErr := decodeForecastIssue(data) + if decodeErr != nil { + return nil, decodeErr + } + expandedBytes += size + if expandedBytes > maxForecastSliceBytes { + return nil, errors.New("expanded forecast issue slice exceeds memory limit; use VisitForecastIssues") + } + out = append(out, issue) + } + if err = rows.Err(); err != nil { + return nil, err + } + for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 { + out[i], out[j] = out[j], out[i] + } + return out, nil +} + +func (s *Store) LoadForecastObservations(ctx context.Context, since, until int64) ([]forecasting.Observation, error) { + rows, err := s.db.QueryContext(ctx, `SELECT payload FROM forecast_observations + WHERE start_ms>=? AND end_ms<=? ORDER BY start_ms,end_ms,config_version LIMIT ?`, since, until, MaxForecastObservations+1) + if err != nil { + return nil, err + } + defer rows.Close() + out := make([]forecasting.Observation, 0, 3000) + totalBytes := 0 + for rows.Next() { + if len(out) == MaxForecastObservations { + return nil, errors.New("forecast observation load exceeds memory limit") + } + var data string + if err = rows.Scan(&data); err != nil { + return nil, err + } + totalBytes += len(data) + if len(data) > maxForecastRecordBytes || totalBytes > MaxForecastObservationBytes { + return nil, errors.New("oversized forecast observation load") + } + var observation forecasting.Observation + if err = json.Unmarshal([]byte(data), &observation); err != nil { + return nil, err + } + if err = observation.Validate(); err != nil { + return nil, err + } + out = append(out, observation) + } + return out, rows.Err() +} + +// VisitForecastIssues decodes one bounded record at a time. The box can score a +// month of archived forecasts without retaining a month's model snapshots. +func (s *Store) VisitForecastIssues(ctx context.Context, since, until int64, visit func(forecasting.Issue) error) error { + if visit == nil { + return errors.New("forecast issue visitor is nil") + } + rows, err := s.db.QueryContext(ctx, "SELECT payload FROM forecast_issues WHERE issued_at_ms>=? AND issued_at_ms<=? ORDER BY issued_at_ms,id", since, until) + if err != nil { + return err + } + defer rows.Close() + for rows.Next() { + if err = ctx.Err(); err != nil { + return err + } + var data []byte + if err = rows.Scan(&data); err != nil { + return err + } + issue, _, decodeErr := decodeForecastIssue(data) + if decodeErr != nil { + return decodeErr + } + if err = visit(issue); err != nil { + return err + } + } + return rows.Err() +} + +// SaveForecastErrors stores derived scores; immutable issue and observation +// rows retain the evidence. A newer issue for the same target and lead wins. +func (s *Store) SaveForecastErrors(ctx context.Context, samples []forecasting.ErrorSample, now int64) error { + if now <= 0 { + return errors.New("invalid forecast score time") + } + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + for _, sample := range samples { + if err = sample.Validate(); err != nil { + return err + } + if sample.AvailableAtMS > now || sample.EndMS > now { + return errors.New("future forecast score") + } + data, marshalErr := json.Marshal(sample) + if marshalErr != nil { + return marshalErr + } + if len(data) > maxForecastRecordBytes { + return errors.New("forecast error exceeds payload limit") + } + result, execErr := tx.ExecContext(ctx, `INSERT INTO forecast_errors(series,config_version,lead,start_ms,end_ms,origin_ms,issued_at_ms,issue_id,available_at_ms,payload) + VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(series,config_version,lead,start_ms,end_ms) DO UPDATE SET + origin_ms=excluded.origin_ms,issued_at_ms=excluded.issued_at_ms,issue_id=excluded.issue_id, + available_at_ms=excluded.available_at_ms,payload=excluded.payload + WHERE excluded.origin_ms>forecast_errors.origin_ms + OR (excluded.origin_ms=forecast_errors.origin_ms AND excluded.issued_at_ms>forecast_errors.issued_at_ms) + OR (excluded.origin_ms=forecast_errors.origin_ms AND excluded.issued_at_ms=forecast_errors.issued_at_ms AND excluded.issue_id>forecast_errors.issue_id)`, + sample.Series, sample.ConfigVersion, sample.Lead, sample.StartMS, sample.EndMS, sample.OriginMS, + sample.IssuedAtMS, sample.IssueID, sample.AvailableAtMS, string(data)) + if execErr != nil { + return execErr + } + if n, _ := result.RowsAffected(); n == 0 { + var oldOrigin, oldIssued int64 + var oldIssueID string + var old string + if err = tx.QueryRowContext(ctx, `SELECT origin_ms,issued_at_ms,issue_id,payload FROM forecast_errors + WHERE series=? AND config_version=? AND lead=? AND start_ms=? AND end_ms=?`, sample.Series, sample.ConfigVersion, + sample.Lead, sample.StartMS, sample.EndMS).Scan(&oldOrigin, &oldIssued, &oldIssueID, &old); err != nil { + return err + } + if oldOrigin == sample.OriginMS && oldIssued == sample.IssuedAtMS && oldIssueID == sample.IssueID && old != string(data) { + return errors.New("forecast error for one issue origin is immutable") + } + } + } + if _, err = tx.ExecContext(ctx, "DELETE FROM forecast_errors WHERE end_ms < ?", now-ForecastIssueRetention.Milliseconds()); err != nil { + return err + } + if _, err = tx.ExecContext(ctx, `DELETE FROM forecast_errors WHERE rowid IN ( + SELECT rowid FROM (SELECT rowid,ROW_NUMBER() OVER (ORDER BY end_ms DESC,start_ms DESC,series DESC,lead DESC) AS n, + SUM(length(payload)) OVER (ORDER BY end_ms DESC,start_ms DESC,series DESC,lead DESC) AS bytes FROM forecast_errors) + WHERE n>? OR bytes>?)`, MaxForecastErrors, MaxForecastErrorBytes); err != nil { + return err + } + return tx.Commit() +} + +// LoadForecastErrors reads a bounded set of valid residuals. With hourly set, +// adjacent replans and quarter-hour points cannot crowd independent days out. +func (s *Store) LoadForecastErrors(ctx context.Context, since, until int64, hourly bool) ([]forecasting.ErrorSample, error) { + rows, err := s.db.QueryContext(ctx, `SELECT payload FROM forecast_errors WHERE start_ms>=? AND end_ms<=? AND available_at_ms<=? + AND (?=0 OR start_ms%3600000=0) ORDER BY start_ms DESC,series,lead LIMIT ?`, since, until, until, hourly, MaxForecastErrors+1) + if err != nil { + return nil, err + } + defer rows.Close() + out := make([]forecasting.ErrorSample, 0, min(MaxForecastErrors, 40000)) + totalBytes := 0 + for rows.Next() { + if len(out) == MaxForecastErrors { + return nil, errors.New("forecast error load exceeds memory limit") + } + var data string + if err = rows.Scan(&data); err != nil { + return nil, err + } + totalBytes += len(data) + if len(data) > maxForecastRecordBytes || totalBytes > MaxForecastErrorBytes { + return nil, errors.New("oversized forecast error load") + } + var sample forecasting.ErrorSample + if err = json.Unmarshal([]byte(data), &sample); err != nil { + return nil, err + } + if err = sample.Validate(); err != nil { + return nil, fmt.Errorf("invalid archived forecast error: %w", err) + } + out = append(out, sample) + } + if err = rows.Err(); err != nil { + return nil, err + } + for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 { + out[i], out[j] = out[j], out[i] + } + return out, nil +} diff --git a/go/internal/state/forecast_issues_test.go b/go/internal/state/forecast_issues_test.go new file mode 100644 index 00000000..fe98ec09 --- /dev/null +++ b/go/internal/state/forecast_issues_test.go @@ -0,0 +1,199 @@ +package state + +import ( + "bytes" + "context" + "math" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/forecasting" +) + +func openForecastArchive(t *testing.T) *Store { + t.Helper() + store, err := Open(filepath.Join(t.TempDir(), "state.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { store.Close() }) + if err = store.InitForecastArchive(context.Background()); err != nil { + t.Fatal(err) + } + return store +} + +func archiveBand() forecasting.Band { + return forecasting.Band{LowW: 0, HighW: 5000, Method: forecasting.BandMethodColdStart} +} + +func archivePoint(start int64) forecasting.Point { + return forecasting.Point{ + StartMS: start, EndMS: start + int64(time.Hour/time.Millisecond), PVW: 100, LoadW: 1000, + PVKnown: true, LoadKnown: true, PVQuality: "forecast", LoadQuality: "forecast", + PVBand: archiveBand(), LoadBand: archiveBand(), NetBand: archiveBand(), + } +} + +func archiveIssue(id string, origin, start int64) forecasting.Issue { + return forecasting.Issue{ + Schema: forecasting.Schema, ID: id, OriginMS: origin, IssuedAtMS: origin, LatestInputMS: origin, + ConfigVersion: "cfg", Series: []forecasting.Series{{Name: "champion", ModelVersion: "v1", Points: []forecasting.Point{archivePoint(start)}}}, + } +} + +func archiveError(issueID string, origin, issued, start int64) forecasting.ErrorSample { + return forecasting.ErrorSample{ + Series: "champion", ConfigVersion: "cfg", IssueID: issueID, OriginMS: origin, IssuedAtMS: issued, + StartMS: start, EndMS: start + int64(time.Hour/time.Millisecond), AvailableAtMS: start + int64(time.Hour/time.Millisecond), + Lead: forecasting.LeadBucket(origin, start), PVErrorW: 10, LoadErrorW: 20, PVKnown: true, LoadKnown: true, + Prediction: archivePoint(start), + } +} + +func TestForecastIssueExternalizesAndVerifiesFullModelState(t *testing.T) { + store := openForecastArchive(t) + ctx := context.Background() + now := time.Now().UTC().Truncate(time.Hour).Add(-time.Hour).UnixMilli() + issue := archiveIssue("one", now-2*int64(time.Hour/time.Millisecond), now) + state := append([]byte(`{"weights":"`), bytes.Repeat([]byte("x"), 900000)...) + state = append(state, []byte(`"}`)...) + issue.Models = []forecasting.ModelState{{ + Name: "pv", Version: "v1", Quality: forecasting.ModelQualityWarm, + UpdatedAtMS: issue.OriginMS, State: state, + }} + if err := store.SaveForecastIssue(ctx, issue); err != nil { + t.Fatal(err) + } + if issue.Models[0].StateID != "" || !bytes.Equal(issue.Models[0].State, state) { + t.Fatal("saving an issue mutated the caller's model snapshot") + } + if err := store.SaveForecastIssue(ctx, issue); err != nil { + t.Fatalf("identical retry with inline state failed: %v", err) + } + issues, err := store.LoadForecastIssues(ctx, 0, time.Now().Add(time.Hour).UnixMilli(), 10) + if err != nil { + t.Fatal(err) + } + if len(issues) != 1 || len(issues[0].Models) != 1 || issues[0].Models[0].StateID == "" || len(issues[0].Models[0].State) != 0 { + t.Fatalf("stored issue did not contain one light model reference: %+v", issues) + } + loaded, err := store.LoadForecastModelState(ctx, issues[0].Models[0].StateID) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(loaded, state) { + t.Fatal("hydrated model state differs from issued state") + } + if err = store.SaveForecastIssue(ctx, issues[0]); err != nil { + t.Fatalf("retry with an existing state reference failed: %v", err) + } + second := issue + second.ID = "two" + if err = store.SaveForecastIssue(ctx, second); err != nil { + t.Fatal(err) + } + var blobs int + if err = store.db.QueryRow("SELECT COUNT(*) FROM forecast_model_states").Scan(&blobs); err != nil || blobs != 1 { + t.Fatalf("content-addressed states=%d err=%v, want 1", blobs, err) + } +} + +func TestForecastIssueStoresEmptyColdStartModel(t *testing.T) { + store := openForecastArchive(t) + ctx := context.Background() + start := time.Now().UTC().Truncate(time.Hour).Add(-time.Hour).UnixMilli() + issue := archiveIssue("cold", start-2*int64(time.Hour/time.Millisecond), start) + issue.Models = []forecasting.ModelState{{ + Name: "load", Version: "v1", Quality: forecasting.ModelQualityColdStart, + }} + if err := store.SaveForecastIssue(ctx, issue); err != nil { + t.Fatalf("save empty cold-start model: %v", err) + } + issues, err := store.LoadForecastIssues(ctx, 0, time.Now().Add(time.Hour).UnixMilli(), 1) + if err != nil { + t.Fatal(err) + } + if len(issues) != 1 || len(issues[0].Models) != 1 || issues[0].Models[0].Quality != forecasting.ModelQualityColdStart || + issues[0].Models[0].StateID != "" || len(issues[0].Models[0].State) != 0 { + t.Fatalf("cold-start model changed in archive: %+v", issues) + } +} + +func TestForecastIssueImmutabilityAndSliceLimit(t *testing.T) { + store := openForecastArchive(t) + ctx := context.Background() + start := time.Now().UTC().Truncate(time.Hour).Add(-time.Hour).UnixMilli() + origin := start - 2*int64(time.Hour/time.Millisecond) + one := archiveIssue("one", origin, start) + two := archiveIssue("two", origin+1, start) + if err := store.SaveForecastIssue(ctx, one); err != nil { + t.Fatal(err) + } + changed := one + changed.Series[0].Points[0].PVW++ + if err := store.SaveForecastIssue(ctx, changed); err == nil || !strings.Contains(err.Error(), "immutable") { + t.Fatalf("changed retry error=%v, want immutable", err) + } + if err := store.SaveForecastIssue(ctx, two); err != nil { + t.Fatal(err) + } + if _, err := store.LoadForecastIssues(ctx, 0, time.Now().Add(time.Hour).UnixMilli(), 1); err == nil || !strings.Contains(err.Error(), "slice limit") { + t.Fatalf("truncated slice load error=%v", err) + } +} + +func TestForecastObservationPrunesOnEveryWrite(t *testing.T) { + store := openForecastArchive(t) + ctx := context.Background() + hour := int64(time.Hour / time.Millisecond) + oldStart := time.Now().Add(-ForecastIssueRetention - 2*time.Hour).Truncate(time.Hour).UnixMilli() + old := forecasting.Observation{ + StartMS: oldStart, EndMS: oldStart + hour, AvailableAtMS: oldStart + hour, + PVW: 10, LoadW: 100, PVKnown: true, LoadKnown: true, Quality: "complete", ConfigVersion: "cfg", + } + if err := store.SaveForecastObservation(ctx, old); err != nil { + t.Fatal(err) + } + var count int + if err := store.db.QueryRow("SELECT COUNT(*) FROM forecast_observations").Scan(&count); err != nil || count != 0 { + t.Fatalf("expired observations=%d err=%v, want 0", count, err) + } +} + +func TestForecastErrorsValidateAndUseFullTieBreak(t *testing.T) { + store := openForecastArchive(t) + ctx := context.Background() + hour := int64(time.Hour / time.Millisecond) + start := time.Now().UTC().Truncate(time.Hour).Add(-2 * time.Hour).UnixMilli() + origin := start - 2*hour + a := archiveError("a", origin, origin, start) + z := archiveError("z", origin, origin, start) + z.PVErrorW = 30 + if err := store.SaveForecastErrors(ctx, []forecasting.ErrorSample{a}, time.Now().UnixMilli()); err != nil { + t.Fatal(err) + } + if err := store.SaveForecastErrors(ctx, []forecasting.ErrorSample{z}, time.Now().UnixMilli()); err != nil { + t.Fatal(err) + } + loaded, err := store.LoadForecastErrors(ctx, start-hour, time.Now().UnixMilli(), true) + if err != nil { + t.Fatal(err) + } + if len(loaded) != 1 || loaded[0].IssueID != "z" || loaded[0].PVErrorW != 30 { + t.Fatalf("stored tie winner=%+v, want issue z", loaded) + } + bad := z + bad.StartMS += hour + bad.EndMS += hour + bad.AvailableAtMS += hour + bad.Prediction.StartMS = bad.StartMS + bad.Prediction.EndMS = bad.EndMS + bad.Lead = forecasting.LeadBucket(bad.OriginMS, bad.StartMS) + bad.PVErrorW = math.NaN() + if err = store.SaveForecastErrors(ctx, []forecasting.ErrorSample{bad}, time.Now().Add(time.Hour).UnixMilli()); err == nil { + t.Fatal("nonfinite residual was stored") + } +} diff --git a/go/internal/telemetry/forecast.go b/go/internal/telemetry/forecast.go new file mode 100644 index 00000000..8ed11ddd --- /dev/null +++ b/go/internal/telemetry/forecast.go @@ -0,0 +1,306 @@ +package telemetry + +import ( + "encoding/json" + "fmt" + "math" + "sort" + "time" +) + +// ForecastPowerSample qualifies source power independently of status updates. +// OCPP publishes this in reading data under forecast_power; Lua readings without +// this marker keep their existing power receipt semantics. +type ForecastPowerSample struct { + Version int `json:"version"` + Known bool `json:"known"` + Watts float64 `json:"watts"` + MeasuredAtMS int64 `json:"measured_at_ms"` + ReceivedAtMS int64 `json:"received_at_ms"` +} + +// ForecastFlow identifies one electrical flow. FlowID joins duplicate sources +// for the same physical flow; callers must resolve those sources before training. +type ForecastFlow struct { + Driver string + DerType DerType + FlowID string +} +type ForecastOptions struct { + // HouseholdInvalidReason qualifies unresolved site topology without invalidating independent PV observations. + HouseholdInvalidReason string + PVInvalidReason string + ExpectedFlows []ForecastFlow + MaxAge time.Duration + MaxSkew time.Duration +} + +// ForecastReading is one coherent snapshot, in site signs and raw watts. +// Valid describes the household balance. PVValid only describes the PV sources. +// Neither flag claims that the instantaneous sample covers a time interval. +type ForecastReading struct { + At, Earliest, Latest, PVLatest time.Time + GridW, PVW, BatteryW, EVW, V2XW, HouseholdW float64 + Valid, PVValid bool + Reason, PVReason string +} + +// ForecastMeasurement reads power and health under one lock. A command fault +// does not invalidate a fresh meter. Missing configured flows invalidate the +// balance, including devices that have never emitted. No fuse limits house W. +func (s *Store) ForecastMeasurement(now time.Time, siteMeter string, opts ForecastOptions) ForecastReading { + out := ForecastReading{At: now, Valid: true, PVValid: true} + if s == nil { + out.Valid = false + out.PVValid = false + out.Reason = "no_telemetry" + out.PVReason = out.Reason + return out + } + if opts.MaxAge <= 0 { + opts.MaxAge = 90 * time.Second + } + if opts.MaxSkew <= 0 { + opts.MaxSkew = 30 * time.Second + } + s.mu.RLock() + defer s.mu.RUnlock() + flows := map[string]ForecastFlow{} + key := func(f ForecastFlow) string { return f.Driver + ":" + f.DerType.String() } + fail := func(reason string, pv bool) { + if out.Valid { + out.Valid = false + out.Reason = reason + } + if pv && out.PVValid { + out.PVValid = false + out.PVReason = reason + } + } + if opts.PVInvalidReason != "" { + out.PVValid = false + out.PVReason = opts.PVInvalidReason + } + if opts.HouseholdInvalidReason != "" { + fail(opts.HouseholdInvalidReason, false) + } + flows[siteMeter+":meter"] = ForecastFlow{Driver: siteMeter, DerType: DerMeter} + for _, r := range s.readings { + if r.DerType == DerPV || r.DerType == DerBattery || r.DerType == DerEV || r.DerType == DerV2X { + f := ForecastFlow{Driver: r.Driver, DerType: r.DerType} + flows[key(f)] = f + } + } + ids := map[string]ForecastFlow{} + for _, f := range opts.ExpectedFlows { + if f.DerType == DerVehicle || (f.DerType == DerMeter && f.Driver != siteMeter) { + continue + } + if f.FlowID != "" { + if old, ok := ids[f.FlowID]; ok { + fail("duplicate_flow:"+f.FlowID, f.DerType == DerPV || old.DerType == DerPV) + } + ids[f.FlowID] = f + } + flows[key(f)] = f + } + // Same charger represented as both EV and V2X must not be subtracted twice. + for _, f := range flows { + if f.DerType == DerEV { + if _, ok := flows[f.Driver+":"+DerV2X.String()]; ok { + fail("duplicate_charger:"+f.Driver, false) + } + } + } + keys := make([]string, 0, len(flows)) + for k := range flows { + keys = append(keys, k) + } + sort.Strings(keys) + var pvFirst, pvLast time.Time + pvCount := 0 + for _, k := range keys { + f := flows[k] + pv := f.DerType == DerPV + if pv { + pvCount++ + } + r := s.readings[k] + reason := "" + var powerW float64 + var powerAt time.Time + powerQualified := true + if r != nil { + powerW, powerAt = r.RawW, r.UpdatedAt + var data struct { + Power json.RawMessage `json:"forecast_power"` + } + if json.Unmarshal(r.Data, &data) == nil && len(data.Power) > 0 { + var sample ForecastPowerSample + powerQualified = json.Unmarshal(data.Power, &sample) == nil && sample.Version == 1 && sample.Known && sample.MeasuredAtMS > 0 && sample.ReceivedAtMS >= sample.MeasuredAtMS && sample.ReceivedAtMS <= now.UnixMilli() + powerW, powerAt = sample.Watts, time.UnixMilli(sample.MeasuredAtMS) + } + } + switch { + case r == nil: + reason = "missing:" + case !s.health[f.Driver].TelemetryLive(): + reason = "offline:" + case !powerQualified: + reason = "unknown_power:" + case math.IsNaN(powerW) || math.IsInf(powerW, 0): + reason = "nonfinite:" + case powerAt.IsZero() || now.Sub(powerAt) > opts.MaxAge: + reason = "stale:" + case powerAt.After(now): + reason = "future:" + case pv && powerW > 0: + reason = "invalid_sign:" + } + if reason != "" { + fail(reason+k, pv) + continue + } + if out.Earliest.IsZero() || powerAt.Before(out.Earliest) { + out.Earliest = powerAt + } + if powerAt.After(out.Latest) { + out.Latest = powerAt + } + if pv { + if pvFirst.IsZero() || powerAt.Before(pvFirst) { + pvFirst = powerAt + } + if powerAt.After(pvLast) { + pvLast = powerAt + } + } + switch f.DerType { + case DerMeter: + out.GridW = powerW + case DerPV: + out.PVW += powerW + case DerBattery: + out.BatteryW += powerW + case DerEV: + out.EVW += powerW + case DerV2X: + out.V2XW += powerW + } + } + if out.Latest.Sub(out.Earliest) > opts.MaxSkew { + fail("time_skew", false) + } + out.PVLatest = pvLast + if pvLast.Sub(pvFirst) > opts.MaxSkew { + fail("pv_time_skew", true) + } + if pvCount == 0 { + out.PVValid = false + out.PVReason = "no_pv_source" + } + if math.IsNaN(out.PVW) || math.IsInf(out.PVW, 0) { + fail("nonfinite_pv_sum", true) + } + out.HouseholdW = out.GridW - out.PVW - out.BatteryW - out.EVW - out.V2XW + if math.IsNaN(out.HouseholdW) || math.IsInf(out.HouseholdW, 0) || out.HouseholdW < 0 { + fail("invalid_balance", false) + } + return out +} + +// ForecastInterval is a fully covered quarter-hour mean. Quality is versioned +// so old history without this evidence cannot silently become training labels. +type ForecastInterval struct { + Start, End time.Time + HouseholdW, PVW float64 + Quality string + PVValid bool + LatestInputMs int64 +} + +const ForecastIntervalQuality = "complete_balance_v1" + +// ForecastAccumulator integrates consecutive valid snapshots by a trapezoid. +// Gaps over MaxGap and invalid snapshots discard the unfinished interval. +// This is interval evidence from sampled power, not a revenue-grade energy meter. +type ForecastAccumulator struct { + MaxGap time.Duration + previous *ForecastReading + start time.Time + covered, houseWS, pvWS float64 + pvValid bool +} + +func (a *ForecastAccumulator) Observe(r ForecastReading) []ForecastInterval { + if !r.Valid || r.Latest.IsZero() || r.Latest.After(r.At) { + a.previous = nil + a.covered = 0 + a.start = time.Time{} + return nil + } + maxGap := a.MaxGap + if maxGap <= 0 { + maxGap = 2 * time.Minute + } + p := a.previous + if p != nil && (!r.At.After(p.At) || !r.Latest.After(p.Latest)) { + a.previous = nil + a.covered = 0 + a.start = time.Time{} + return nil + } + a.previous = &r + if p == nil || r.At.Sub(p.At) > maxGap { + a.start = r.At.UTC().Truncate(15 * time.Minute) + a.covered = 0 + a.houseWS = 0 + a.pvWS = 0 + a.pvValid = r.PVValid + return nil + } + var out []ForecastInterval + t := p.At + span := r.At.Sub(p.At).Seconds() + for t.Before(r.At) { + start := t.UTC().Truncate(15 * time.Minute) + end := start.Add(15 * time.Minute) + if a.start != start { + a.start = start + a.covered = 0 + a.houseWS = 0 + a.pvWS = 0 + a.pvValid = r.PVValid + } + until := r.At + if end.Before(until) { + until = end + } + f0 := t.Sub(p.At).Seconds() / span + f1 := until.Sub(p.At).Seconds() / span + seconds := until.Sub(t).Seconds() + a.houseWS += (p.HouseholdW + (r.HouseholdW-p.HouseholdW)*(f0+f1)/2) * seconds + a.pvWS += (p.PVW + (r.PVW-p.PVW)*(f0+f1)/2) * seconds + a.covered += seconds + a.pvValid = a.pvValid && p.PVValid && r.PVValid + if until.Equal(end) { + if math.Abs(a.covered-900) < 0.001 { + out = append(out, ForecastInterval{Start: start, End: end, HouseholdW: a.houseWS / 900, PVW: a.pvWS / 900, Quality: ForecastIntervalQuality, PVValid: a.pvValid, LatestInputMs: r.Latest.UnixMilli()}) + } + a.start = end + a.covered = 0 + a.houseWS = 0 + a.pvWS = 0 + a.pvValid = r.PVValid + } + t = until + } + return out +} + +func (r ForecastReading) Error() error { + if r.Valid { + return nil + } + return fmt.Errorf("forecast measurement: %s", r.Reason) +} diff --git a/go/internal/telemetry/forecast_test.go b/go/internal/telemetry/forecast_test.go new file mode 100644 index 00000000..01763fc8 --- /dev/null +++ b/go/internal/telemetry/forecast_test.go @@ -0,0 +1,173 @@ +package telemetry + +import ( + "encoding/json" + "math" + "testing" + "time" +) + +func forecastStore(now time.Time, grid, pv, bat float64) *Store { + s := NewStore() + for _, v := range []struct { + d string + k DerType + w float64 + }{{"site", DerMeter, grid}, {"pv", DerPV, pv}, {"bat", DerBattery, bat}} { + s.Update(v.d, v.k, v.w, nil, nil) + s.RecordDriverSuccess(v.d) + s.readings[v.d+":"+v.k.String()].UpdatedAt = now + } + return s +} +func TestForecastCompleteBalance(t *testing.T) { + now := time.Now() + s := forecastStore(now, 4000, 0, 3000) + if r := s.ForecastMeasurement(now, "site", ForecastOptions{}); !r.Valid || r.HouseholdW != 1000 { + t.Fatalf("balance: %+v", r) + } + s.SetDriverCommandFault("bat", true, "refused") + if r := s.ForecastMeasurement(now, "site", ForecastOptions{}); !r.Valid || r.HouseholdW != 1000 { + t.Fatalf("fresh command fault: %+v", r) + } + s.health["bat"].SetOffline() + if r := s.ForecastMeasurement(now, "site", ForecastOptions{}); r.Valid || !r.PVValid { + t.Fatalf("missing battery should only invalidate household: %+v", r) + } +} +func TestForecastRejectsIncompleteAndSkewedFlows(t *testing.T) { + now := time.Now() + tests := []struct { + name string + change func(*Store) + opts ForecastOptions + }{ + {"stale PV", func(s *Store) { s.readings["pv:pv"].UpdatedAt = now.Add(-2 * time.Minute) }, ForecastOptions{}}, + {"skew", func(s *Store) { s.readings["pv:pv"].UpdatedAt = now.Add(-40 * time.Second) }, ForecastOptions{}}, + {"nonfinite", func(s *Store) { s.readings["bat:battery"].RawW = math.NaN() }, ForecastOptions{}}, + {"future", func(s *Store) { s.readings["bat:battery"].UpdatedAt = now.Add(time.Second) }, ForecastOptions{}}, + {"never emitted", func(s *Store) {}, ForecastOptions{ExpectedFlows: []ForecastFlow{{Driver: "charger", DerType: DerEV}}}}, + {"duplicate", func(s *Store) {}, ForecastOptions{ExpectedFlows: []ForecastFlow{{Driver: "pv", DerType: DerPV, FlowID: "roof"}, {Driver: "second", DerType: DerPV, FlowID: "roof"}}}}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + s := forecastStore(now, 4000, -2000, 3000) + tc.change(s) + r := s.ForecastMeasurement(now, "site", tc.opts) + if r.Valid || r.Reason == "" { + t.Fatalf("accepted %+v", r) + } + }) + } +} +func TestForecastGrossHouseCanExceedGridFuse(t *testing.T) { + now := time.Now() + s := forecastStore(now, 8000, -7000, 0) + r := s.ForecastMeasurement(now, "site", ForecastOptions{}) + if !r.Valid || r.HouseholdW != 15000 { + t.Fatalf("valid 15kW house with 8kW grid: %+v", r) + } +} +func TestForecastIntervalsCadenceAndGaps(t *testing.T) { + start := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) + for _, cadence := range []time.Duration{time.Second, 10 * time.Second, time.Minute} { + a := ForecastAccumulator{} + var intervals []ForecastInterval + for elapsed := time.Duration(0); elapsed <= 30*time.Minute; elapsed += cadence { + at := start.Add(elapsed) + r := ForecastReading{At: at, Latest: at, Valid: true, PVValid: true, HouseholdW: 1000 + elapsed.Seconds(), PVW: -2000} + intervals = append(intervals, a.Observe(r)...) + } + if len(intervals) != 2 || math.Abs(intervals[0].HouseholdW-1450) > 0.001 || !intervals[0].PVValid { + t.Fatalf("cadence %s: %+v", cadence, intervals) + } + } + a := ForecastAccumulator{} + for i := 0; i <= 15; i++ { + at := start.Add(time.Duration(i) * time.Minute) + r := ForecastReading{At: at, Latest: at, Valid: i != 5, PVValid: true, HouseholdW: 1000} + if out := a.Observe(r); len(out) > 0 { + t.Fatalf("gap produced complete interval: %+v", out) + } + } +} +func TestForecastIntervalMissingPVIsNotZeroTruth(t *testing.T) { + a := ForecastAccumulator{} + start := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) + var got []ForecastInterval + for i := 0; i <= 15; i++ { + at := start.Add(time.Duration(i) * time.Minute) + got = append(got, a.Observe(ForecastReading{At: at, Latest: at, Valid: true, PVValid: false, HouseholdW: 1000})...) + } + if len(got) != 1 || got[0].PVValid { + t.Fatalf("PV absence lost: %+v", got) + } +} + +func TestForecastDuplicateOrFutureSamplesBreakInterval(t *testing.T) { + start := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC) + for _, kind := range []string{"duplicate", "future"} { + t.Run(kind, func(t *testing.T) { + a := ForecastAccumulator{} + for i := 0; i <= 15; i++ { + at := start.Add(time.Duration(i) * time.Minute) + latest := at + if i == 7 { + if kind == "duplicate" { + latest = at.Add(-time.Minute) + } else { + latest = at.Add(time.Minute) + } + } + if out := a.Observe(ForecastReading{At: at, Latest: latest, Valid: true, PVValid: true, HouseholdW: 1000}); len(out) > 0 { + t.Fatalf("%s created a complete interval: %+v", kind, out) + } + } + }) + } +} +func BenchmarkForecastMeasurement(b *testing.B) { + now := time.Now() + s := forecastStore(now, 4000, -2000, 3000) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + s.ForecastMeasurement(now, "site", ForecastOptions{}) + } +} + +func TestForecastIndependentPVInvalidReason(t *testing.T) { + now := time.Now() + s := forecastStore(now, 2000, -1000, 0) + r := s.ForecastMeasurement(now, "site", ForecastOptions{PVInvalidReason: "unconfirmed_pv_identity"}) + if !r.Valid || r.PVValid || r.PVReason != "unconfirmed_pv_identity" { + t.Fatalf("PV qualification damaged independent balance: %+v", r) + } + r = s.ForecastMeasurement(now, "site", ForecastOptions{HouseholdInvalidReason: "unconfirmed_ev_identity"}) + if r.Valid || !r.PVValid { + t.Fatalf("household identity blocked independent PV: %+v", r) + } +} + +func TestForecastPowerMetadataUsesMeasurementNotStatus(t *testing.T) { + now := time.Now().Truncate(time.Millisecond) + good := ForecastPowerSample{Version: 1, Known: true, Watts: 700, MeasuredAtMS: now.Add(-time.Second).UnixMilli(), ReceivedAtMS: now.UnixMilli()} + for name, change := range map[string]func(*ForecastPowerSample){"real zero": func(p *ForecastPowerSample) { p.Watts = 0 }, "old": func(p *ForecastPowerSample) { p.MeasuredAtMS = now.Add(-2 * time.Minute).UnixMilli() }, "unknown": func(p *ForecastPowerSample) { p.Known = false }, "future receive": func(p *ForecastPowerSample) { p.ReceivedAtMS = now.Add(time.Second).UnixMilli() }, "future sample": func(p *ForecastPowerSample) { p.MeasuredAtMS = now.Add(time.Second).UnixMilli() }, "wrong version": func(p *ForecastPowerSample) { p.Version = 2 }} { + t.Run(name, func(t *testing.T) { + s := forecastStore(now, 5000, -1000, 0) + sample := good + change(&sample) + data, _ := json.Marshal(map[string]any{"forecast_power": sample}) + s.Update("charger", DerEV, 9999, nil, data) + s.RecordDriverSuccess("charger") + r := s.ForecastMeasurement(time.Now(), "site", ForecastOptions{}) + if name == "real zero" { + if !r.Valid || r.EVW != 0 || r.HouseholdW != 6000 { + t.Fatalf("measured zero lost to status rawW: %+v", r) + } + } else if r.Valid || !r.PVValid { + t.Fatalf("invalid power time/quality accepted or affected PV: %+v", r) + } + }) + } +} diff --git a/optimizer/native/README.md b/optimizer/native/README.md index db93900c..28a0da72 100644 --- a/optimizer/native/README.md +++ b/optimizer/native/README.md @@ -31,7 +31,7 @@ requests. Core's existing `mpc.ExternalOptimizer` starts it through an absolute path in `ExternalOptimizerConfig.Command`. Core validates all proposed plans and keeps its Go fallback. Beta releases select Energyplan when `planner.engine` is unset on a supported host. Set `planner.engine: energyplan` to select it -explicitly, or `core` / `python` to keep those engines. Stable and development +explicitly, or `core` to select Core DP. Stable and development builds keep Core as the unset default; Windows has no bundled worker. Energyplan uses the same downside PV forecast as Core. The worker gets a 500 ms @@ -45,7 +45,7 @@ Energyplan plans from the measured battery energy, including starts below the reserve or above the charge limit. Each action must hold or reduce any existing violation; after recovery the plan must stay within the configured limits. Core independently checks that recovery and validates fallback plans too. -The compiled worker updates with Core; Python sidecar updates do not replace it. +The compiled worker updates with Core. Supported requests contain one battery and at most one EV per site, with the four existing modes, physical limits, negative tariffs and an EV deadline. @@ -58,6 +58,39 @@ through its existing fallback path. can also use an absolute path supplied in `FTW_NATIVE_SOLVER`. Ordinary Go tests skip these optional process tests when that variable is unset. +## Forecast candidates and evaluation + +Energyplan 0.2.0 also accepts forecasting protocol v1. The public request and +response schemas are in `bundle/forecast-v1.schema.json` and +`bundle/forecast-v1.response.schema.json`. Core runs a separate local process +with a 2 s deadline for each model update and prediction. Forecast failure +does not replace the active planner inputs. These PV and load models gather +evidence as candidates; Core does not promote them automatically. + +PV requires the site's location and qualified PV measurements, but no panel +angles or rated power. Core saves each issued horizon with its available +weather, occupancy, model state and site binding in a bounded local archive. +Measured errors calibrate forecast intervals by horizon. The worker's own +provisional ranges remain distinct from calibrated intervals. + +To score an archive, run this from `go/`, preferably against a box backup: + +```sh +go run ./cmd/ftw-forecast-evaluate -state /path/to/state.db +``` + +The command opens SQLite read-only and writes JSON. Optional `-since` and +`-until` take RFC3339 timestamps within a 30-day window. The report compares +issued forecasts on matched outcomes, includes daylight PV errors and net +energy errors over 1/3/6/12/24 hours, and separates measured interval coverage +from cold-start and provisional ranges. Missing history cannot yield an +accuracy or savings claim. This command is a source tool; release archives +do not include a separate evaluation executable. + +`make native-solver-test` exercises both protocols and the Go forecast adapter +against the bundled host worker. Direct Go forecast tests use +`FTW_FORECAST_WORKER=/absolute/path/to/ftw-solver`. + ## Update the bundle Build and test a new version in the private repository. Copy only the complete diff --git a/optimizer/native/bundle/forecast-v1.response.schema.json b/optimizer/native/bundle/forecast-v1.response.schema.json new file mode 100644 index 00000000..5d42146b --- /dev/null +++ b/optimizer/native/bundle/forecast-v1.response.schema.json @@ -0,0 +1,396 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:sourceful:energyplan:forecast:1:response", + "title": "Energyplan forecasting response v1", + "description": "One JSON response per accepted input line. Match request_id and archive the exact immutable input snapshot plus actual completion/issue time in the caller. A forecast request error returns no replacement state. Malformed JSON can use the existing optimizer error envelope. A line larger than 2 MiB terminates the worker before a response.", + "oneOf": [ + { + "type": "object", + "additionalProperties": false, + "properties": { + "op": { + "const": "forecast" + }, + "version": { + "const": 1 + }, + "action": { + "const": "update" + }, + "request_id": { + "type": "string" + }, + "site_id": { + "type": "string" + }, + "config_revision": { + "type": "string" + }, + "origin_ms": { + "type": "integer", + "minimum": 0 + }, + "ok": { + "const": true + }, + "model_revision": { + "type": "integer", + "minimum": 0, + "maximum": 18446744073709551615, + "description": "Increments once per successful nonempty update, including skipped observations. Predict does not change it." + }, + "latest_input_ms": { + "$ref": "#/$defs/watermarks", + "description": "Last consumed interval end, including rejected-quality observations." + }, + "latest_training_ms": { + "$ref": "#/$defs/watermarks", + "description": "Last learned PV daytime-response interval or trusted household-load interval. Night-only PV evidence does not refresh this watermark." + }, + "latest_available_at_ms": { + "$ref": "#/$defs/watermarks", + "description": "Latest availability among consumed inputs, including rejected-quality observations." + }, + "state": { + "type": "object", + "description": "Opaque snapshot. Persist unchanged and associate with this site, configuration and model revision." + }, + "updates": { + "type": "object", + "additionalProperties": false, + "required": [ + "pv", + "load" + ], + "properties": { + "pv": { + "anyOf": [ + { + "type": "null" + }, + { + "$ref": "#/$defs/counts" + } + ] + }, + "load": { + "anyOf": [ + { + "type": "null" + }, + { + "$ref": "#/$defs/counts" + } + ] + } + } + } + }, + "required": [ + "op", + "version", + "action", + "request_id", + "site_id", + "config_revision", + "origin_ms", + "ok", + "model_revision", + "latest_input_ms", + "latest_training_ms", + "latest_available_at_ms", + "state", + "updates" + ] + }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "op": { + "const": "forecast" + }, + "version": { + "const": 1 + }, + "action": { + "const": "predict" + }, + "request_id": { + "type": "string" + }, + "site_id": { + "type": "string" + }, + "config_revision": { + "type": "string" + }, + "origin_ms": { + "type": "integer", + "minimum": 0 + }, + "ok": { + "const": true + }, + "model_revision": { + "type": "integer", + "minimum": 0, + "maximum": 18446744073709551615, + "description": "Increments once per successful nonempty update, including skipped observations. Predict does not change it." + }, + "latest_input_ms": { + "$ref": "#/$defs/watermarks", + "description": "Last consumed interval end, including rejected-quality observations." + }, + "latest_training_ms": { + "$ref": "#/$defs/watermarks", + "description": "Last learned PV daytime-response interval or trusted household-load interval. Night-only PV evidence does not refresh this watermark." + }, + "latest_available_at_ms": { + "$ref": "#/$defs/watermarks", + "description": "Latest availability among consumed inputs, including rejected-quality observations." + }, + "predictions": { + "type": "array", + "minItems": 1, + "maxItems": 512, + "items": { + "$ref": "#/$defs/prediction" + } + } + }, + "required": [ + "op", + "version", + "action", + "request_id", + "site_id", + "config_revision", + "origin_ms", + "ok", + "model_revision", + "latest_input_ms", + "latest_training_ms", + "latest_available_at_ms", + "predictions" + ] + }, + { + "type": "object", + "required": [ + "ok", + "error" + ], + "properties": { + "ok": { + "const": false + }, + "error": { + "type": "object", + "additionalProperties": false, + "required": [ + "code", + "message" + ], + "properties": { + "code": { + "type": "string" + }, + "message": { + "type": "string" + } + } + } + } + } + ], + "$defs": { + "watermarks": { + "type": "object", + "additionalProperties": false, + "required": [ + "pv", + "load" + ], + "properties": { + "pv": { + "type": [ + "integer", + "null" + ], + "minimum": 0 + }, + "load": { + "type": [ + "integer", + "null" + ], + "minimum": 0 + } + } + }, + "counts": { + "type": "object", + "additionalProperties": false, + "required": [ + "applied", + "skipped" + ], + "properties": { + "applied": { + "type": "integer", + "minimum": 0 + }, + "skipped": { + "type": "integer", + "minimum": 0 + } + } + }, + "estimate": { + "type": "object", + "additionalProperties": false, + "required": [ + "known", + "point_w", + "lower_w", + "upper_w", + "quality", + "uncertainty", + "coverage" + ], + "properties": { + "known": { + "type": "boolean", + "description": "A numeric point estimate exists. This includes a configured cold-start prior; it does not mean learned accuracy or measured power." + }, + "point_w": { + "type": [ + "number", + "null" + ], + "minimum": 0 + }, + "lower_w": { + "type": [ + "number", + "null" + ], + "minimum": 0 + }, + "upper_w": { + "type": [ + "number", + "null" + ], + "minimum": 0 + }, + "quality": { + "enum": [ + "unknown", + "cold_start", + "learning", + "ready" + ], + "description": "Model evidence status. Ready is not a measured accuracy guarantee." + }, + "uncertainty": { + "enum": [ + "unavailable", + "provisional" + ], + "description": "Provisional bands are error heuristics, not calibrated quantiles or a confidence level. Null bounds mean uncertainty is unavailable." + }, + "coverage": { + "type": "number", + "minimum": 0, + "maximum": 1, + "description": "Fraction of the model training-coverage target. Not a probability of correctness." + } + }, + "oneOf": [ + { + "properties": { + "known": { + "const": true + }, + "point_w": { + "type": "number", + "minimum": 0 + }, + "quality": { + "enum": [ + "cold_start", + "learning", + "ready" + ] + } + } + }, + { + "properties": { + "known": { + "const": false + }, + "point_w": { + "type": "null" + }, + "lower_w": { + "type": "null" + }, + "upper_w": { + "type": "null" + }, + "quality": { + "const": "unknown" + } + } + } + ] + }, + "prediction": { + "type": "object", + "additionalProperties": false, + "required": [ + "valid_start_ms", + "valid_end_ms", + "pv", + "load" + ], + "properties": { + "valid_start_ms": { + "type": "integer", + "minimum": 0, + "multipleOf": 900000 + }, + "valid_end_ms": { + "type": "integer", + "minimum": 900000, + "multipleOf": 900000 + }, + "pv": { + "anyOf": [ + { + "type": "null" + }, + { + "$ref": "#/$defs/estimate" + } + ], + "description": "Null when this model is disabled." + }, + "load": { + "anyOf": [ + { + "type": "null" + }, + { + "$ref": "#/$defs/estimate" + } + ], + "description": "Null when this model is disabled." + } + } + } + } +} diff --git a/optimizer/native/bundle/forecast-v1.schema.json b/optimizer/native/bundle/forecast-v1.schema.json new file mode 100644 index 00000000..1d6fdd6c --- /dev/null +++ b/optimizer/native/bundle/forecast-v1.schema.json @@ -0,0 +1,456 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "urn:sourceful:energyplan:forecast:1", + "title": "Energyplan forecasting request v1", + "description": "One JSON object per stdin line, at most 2 MiB including the newline. The caller must split update batches by encoded byte size, not just count; a larger line terminates the worker. Update consumes complete UTC-aligned 15-minute means available by origin_ms and returns an opaque model snapshot. Predict uses an immutable snapshot and returns the same 15-minute intervals. The caller supplies site-local clock fields and aggregates quarters across time-zone or DST changes. Site/config identity, interval order, state bounds and causal availability are checked at runtime. Household load excludes EV, battery and V2X. PV denotes nonnegative available AC generation, distinct from signed planner pv_w. The caller records actual completion/issue time and persists the snapshot. See forecast-v1.response.schema.json for responses.", + "type": "object", + "additionalProperties": false, + "properties": { + "op": { + "const": "forecast" + }, + "version": { + "const": 1 + }, + "action": { + "enum": [ + "update", + "predict" + ] + }, + "request_id": { + "$ref": "#/$defs/identifier" + }, + "site_id": { + "$ref": "#/$defs/identifier" + }, + "config_revision": { + "$ref": "#/$defs/identifier" + }, + "origin_ms": { + "type": "integer", + "minimum": 0 + }, + "config": { + "type": "object", + "additionalProperties": false, + "properties": { + "pv": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "latitude_deg": { + "type": "number", + "minimum": -90, + "maximum": 90 + }, + "longitude_deg": { + "type": "number", + "minimum": -180, + "maximum": 180 + }, + "ac_limit_w": { + "type": [ + "number", + "null" + ], + "exclusiveMinimum": 0, + "maximum": 1000000000000.0, + "description": "Optional verified AC power limit. Never infer this limit from the largest observed value. Normal inverter clipping at this limit remains Good available generation." + } + }, + "required": [ + "latitude_deg", + "longitude_deg" + ] + }, + "load": { + "type": [ + "object", + "null" + ], + "additionalProperties": false, + "properties": { + "cold_start_w": { + "type": "number", + "minimum": 0, + "maximum": 10000000.0, + "default": 500, + "description": "Explicit prior when recent site evidence is absent. Must not exceed max_load_w; it does not imply trained confidence." + }, + "max_load_w": { + "type": "number", + "minimum": 1, + "maximum": 10000000.0, + "default": 100000, + "description": "Configured accepted observation/estimate bound, not an inferred hardware rating." + }, + "history_days": { + "type": "integer", + "minimum": 7, + "maximum": 90, + "default": 56 + }, + "ready_days": { + "type": "integer", + "minimum": 2, + "maximum": 90, + "default": 8, + "description": "Independent local days needed for full coverage; must not exceed history_days." + }, + "stale_after_days": { + "type": "number", + "minimum": 1, + "maximum": 365, + "default": 30 + }, + "residual_decay_hours": { + "type": "number", + "minimum": 0.1, + "maximum": 24, + "default": 2 + }, + "max_residual_w": { + "type": "number", + "minimum": 0, + "maximum": 10000000.0, + "default": 3000, + "description": "Bound for short-term adjustment; must not exceed max_load_w." + }, + "max_temperature_slope_w_per_c": { + "type": "number", + "minimum": 0, + "maximum": 10000, + "default": 500 + } + } + } + }, + "anyOf": [ + { + "required": [ + "pv" + ], + "properties": { + "pv": { + "type": "object" + } + } + }, + { + "required": [ + "load" + ], + "properties": { + "load": { + "type": "object" + } + } + } + ], + "description": "Enable PV, household load, or both. Null or omitted disables a model. Restored state must match the full normalized configuration, site_id and config_revision. Changing configuration requires a new state." + }, + "state": { + "type": [ + "object", + "null" + ], + "description": "Opaque, versioned snapshot returned by update. Persist unchanged. Null or omitted starts cold. Forecast origin must not precede the snapshot update origin." + }, + "observations": { + "type": "array", + "maxItems": 4096, + "items": { + "$ref": "#/$defs/observation" + }, + "description": "Bad-quality intervals still advance the input cursor. Later corrections to consumed intervals require an explicit rebuild from an earlier snapshot or a cold state. Failed batches return no replacement state." + }, + "horizon": { + "type": "array", + "minItems": 1, + "maxItems": 512, + "items": { + "$ref": "#/$defs/horizon" + } + } + }, + "required": [ + "op", + "version", + "action", + "request_id", + "site_id", + "config_revision", + "origin_ms", + "config" + ], + "allOf": [ + { + "if": { + "properties": { + "action": { + "const": "update" + } + } + }, + "then": { + "required": [ + "observations" + ], + "not": { + "required": [ + "horizon" + ] + } + } + }, + { + "if": { + "properties": { + "action": { + "const": "predict" + } + } + }, + "then": { + "required": [ + "horizon" + ], + "not": { + "required": [ + "observations" + ] + } + } + } + ], + "$defs": { + "observation": { + "type": "object", + "additionalProperties": false, + "properties": { + "valid_start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 253402300799999, + "multipleOf": 900000 + }, + "valid_end_ms": { + "type": "integer", + "minimum": 1, + "maximum": 253402300799999, + "multipleOf": 900000 + }, + "ghi_w_m2": { + "type": [ + "number", + "null" + ], + "minimum": 0, + "maximum": 3000 + }, + "cloud_pct": { + "type": [ + "number", + "null" + ], + "minimum": 0, + "maximum": 100 + }, + "temp_c": { + "type": [ + "number", + "null" + ], + "minimum": -100, + "maximum": 80 + }, + "weather_available_at_ms": { + "type": [ + "integer", + "null" + ], + "minimum": 0, + "description": "When these weather values became available. Defaults to available_at_ms when weather exists. Must not exceed origin_ms." + }, + "local_day": { + "type": "integer", + "minimum": -1, + "maximum": 3000000, + "description": "Civil date as days since local 1970-01-01, independent of UTC date." + }, + "local_weekday": { + "type": "integer", + "minimum": 0, + "maximum": 6, + "description": "Monday=0 through Sunday=6; must equal (local_day+3) modulo 7." + }, + "local_minute": { + "type": "integer", + "minimum": 0, + "maximum": 1439, + "multipleOf": 15, + "description": "Minute of interval start in local civil time. The caller resolves timezone and DST." + }, + "home": { + "type": [ + "boolean", + "null" + ] + }, + "available_at_ms": { + "type": "integer", + "minimum": 0, + "description": "When the complete mean and its quality became available. At least valid_end_ms, and no later than origin_ms." + }, + "household_load_w": { + "type": [ + "number", + "null" + ], + "minimum": 0 + }, + "pv_available_w": { + "type": [ + "number", + "null" + ], + "minimum": 0 + }, + "load_quality": { + "enum": [ + "good", + "missing", + "stale", + "incomplete", + "curtailed", + "clipped" + ], + "description": "Good means a complete, trusted interval mean, including zero and normal inverter AC clipping. Curtailed, clipped (censored measurement), stale, missing and incomplete intervals do not train the model. Use null power with missing quality, never a fabricated zero." + }, + "pv_quality": { + "enum": [ + "good", + "missing", + "stale", + "incomplete", + "curtailed", + "clipped" + ], + "description": "Good means a complete, trusted interval mean, including zero and normal inverter AC clipping. Curtailed, clipped (censored measurement), stale, missing and incomplete intervals do not train the model. Use null power with missing quality, never a fabricated zero." + } + }, + "required": [ + "valid_start_ms", + "valid_end_ms", + "local_day", + "local_weekday", + "local_minute", + "available_at_ms", + "load_quality", + "pv_quality" + ], + "description": "Exactly 900000 ms, UTC start divisible by 900000. Slots are sorted and do not overlap. Local fields describe the interval start in the site time zone." + }, + "horizon": { + "type": "object", + "additionalProperties": false, + "properties": { + "valid_start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 253402300799999, + "multipleOf": 900000 + }, + "valid_end_ms": { + "type": "integer", + "minimum": 1, + "maximum": 253402300799999, + "multipleOf": 900000 + }, + "ghi_w_m2": { + "type": [ + "number", + "null" + ], + "minimum": 0, + "maximum": 3000 + }, + "cloud_pct": { + "type": [ + "number", + "null" + ], + "minimum": 0, + "maximum": 100 + }, + "temp_c": { + "type": [ + "number", + "null" + ], + "minimum": -100, + "maximum": 80 + }, + "weather_available_at_ms": { + "type": [ + "integer", + "null" + ], + "minimum": 0, + "description": "Required when weather fields exist; must not exceed origin_ms. Keep the forecast weather snapshot as issued." + }, + "local_day": { + "type": "integer", + "minimum": -1, + "maximum": 3000000, + "description": "Civil date as days since local 1970-01-01, independent of UTC date." + }, + "local_weekday": { + "type": "integer", + "minimum": 0, + "maximum": 6, + "description": "Monday=0 through Sunday=6; must equal (local_day+3) modulo 7." + }, + "local_minute": { + "type": "integer", + "minimum": 0, + "maximum": 1439, + "multipleOf": 15, + "description": "Minute of interval start in local civil time. The caller resolves timezone and DST." + }, + "home": { + "type": [ + "boolean", + "null" + ] + } + }, + "required": [ + "valid_start_ms", + "valid_end_ms", + "local_day", + "local_weekday", + "local_minute" + ], + "description": "Exactly 900000 ms, UTC start divisible by 900000. Slots are sorted and do not overlap. Local fields describe the interval start in the site time zone." + }, + "identifier": { + "type": "string", + "minLength": 1, + "maxLength": 128, + "allOf": [ + { + "pattern": "^[^\\u0000-\\u001F\\u007F-\\u009F]+$" + }, + { + "pattern": "\\S" + } + ], + "description": "Nonblank identifier, at most 128 UTF-8 bytes. The byte bound is checked at runtime." + } + } +} diff --git a/optimizer/native/bundle/ftw-solver-darwin-arm64 b/optimizer/native/bundle/ftw-solver-darwin-arm64 index 47cbf0c44d1fece2733c36e9a4f8828379231e31..8489a664454ae9cdde1d2a0fe13faf47ccad7d38 100755 GIT binary patch delta 333193 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

7KCh%#L&#%@bw7fR;x^cr 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%0D=f15*g4>$a6CiT@!E3x6?khHHHY`Ug4OBNd_MjP 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

}F(FfnP)?$i5EGu=xn2TfX~KP-Xb?Zwtf8 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 z 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 delta 189361 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%0DSH%^#+%(#n>bbyCRaptYwUPuHo%+4 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

4g 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

V>Ux+cHh?&cGZv4oQTyG7Qxa9}qdzlqfe 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 O1sq0pQ`kP&()kfyNHR%Bf|3Dt#Ez*l& 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 $ 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�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 TQQ0qyE)LMeZ@7p&CR_g($iY?_ delta 140493 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 z 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 diff --git a/optimizer/native/bundle/manifest.json b/optimizer/native/bundle/manifest.json index 0d878dc5..12d30edd 100644 --- a/optimizer/native/bundle/manifest.json +++ b/optimizer/native/bundle/manifest.json @@ -1,11 +1,12 @@ { "schema_version": 1, "product": "energyplan", - "version": "0.1.2", + "version": "0.2.0", "source_repository": "srcfl/energyplan", - "source_commit": "ab2917ebc3a5e47e84e7a50ca4c177e0e68f4c33", + "source_commit": "550410dff59d7e61b63b7665f8c9f502545c04e4", "rustc": "rustc 1.95.0 (59807616e 2026-04-14)", "protocol_version": 1, + "forecast_protocol_version": 1, "artifacts": { "linux-arm64": { "path": "ftw-solver-linux-arm64", @@ -29,17 +30,25 @@ "sha256": "dd245a0ed4b5e75dcc07ae7bdb0366bd60c05dfc93b6ab1f4309d9ba0a99d7e5", "bytes": 14042 }, + "forecast-v1.response.schema.json": { + "sha256": "7541c29fa28b7e1931f31681f2e8a9338fa624eca32940e858e9bcd73a13a946", + "bytes": 9957 + }, + "forecast-v1.schema.json": { + "sha256": "9e60b0942e8ec17a425d3d414f7c881c3ab13e2d43995299d420d509fcf78a1f", + "bytes": 13273 + }, "ftw-solver-darwin-arm64": { - "sha256": "1f571c38a2f0539603976ec493a1dbe6380ae8f24b3482be015731bc660e9836", - "bytes": 592384 + "sha256": "a8e4c35100f848d72be7e9cb3f9874562eaafcedf55f462f80bcbdbf6850ac51", + "bytes": 792016 }, "ftw-solver-linux-amd64": { - "sha256": "767326a25502a2688a7766f4114aa5ad31bbe2a586a073aee4663b804a9ba041", - "bytes": 756072 + "sha256": "2079a8bcc30b08b0fe21dd34010f8c6df7c8d077437df4d973fb04626df5b999", + "bytes": 1025672 }, "ftw-solver-linux-arm64": { - "sha256": "9a0fe0bdd0bbebce0fa2bb9f6e5416851d3bc94ce0966fe80edfe0f72e915962", - "bytes": 645424 + "sha256": "4862cc8d085fc6310a94ea3310c02cc0ce5c770aaacbb7e03b0fceffe1acb986", + "bytes": 859240 }, "rust-runtime/COPYRIGHT-library.html": { "sha256": "90567e2718bf7fd65a71a3a43c5596488e80e5f51ed02bfea6fec54458b5f3d1", diff --git a/optimizer/native/verify.py b/optimizer/native/verify.py index 1cd2acbb..779fce1f 100644 --- a/optimizer/native/verify.py +++ b/optimizer/native/verify.py @@ -22,6 +22,7 @@ def verify_bundle(root): manifest = json.loads((root / "manifest.json").read_text()) if (manifest.get("schema_version") != 1 or manifest.get("product") != "energyplan" or manifest.get("protocol_version") != 1 + or manifest.get("forecast_protocol_version") != 1 or manifest.get("source_repository") != "srcfl/energyplan" or not re.fullmatch(r"[0-9a-f]{40}", manifest.get("source_commit", "")) or not re.fullmatch(r"\d+\.\d+\.\d+", manifest.get("version", ""))): @@ -30,6 +31,7 @@ def verify_bundle(root): if set(artifacts) != PLATFORMS: raise ValueError("The bundle must contain every supported platform") expected = {f"ftw-solver-{name}" for name in PLATFORMS} + expected |= {"forecast-v1.schema.json", "forecast-v1.response.schema.json"} expected |= {"LICENSE.txt", "THIRD-PARTY-NOTICES.txt", "rust-runtime/COPYRIGHT-library.html"} expected |= {f"rust-runtime/licenses/{name}" for name in RUNTIME_LICENSES} if set(files) != expected: @@ -100,7 +102,7 @@ def main(): result = subprocess.run([str(binary)], input='{"type":"handshake"}\n', capture_output=True, text=True, check=True, timeout=5) reply = json.loads(result.stdout) - if reply.get("protocol_version") != 1 or reply.get("version") != manifest["version"]: + if reply.get("protocol_version") != 1 or reply.get("version") != manifest["version"] or reply.get("forecast_protocol_version") != 1: raise ValueError("Worker handshake does not match the pinned version") print(f"Verified Energyplan {manifest['version']}: {len(manifest['artifacts'])} platforms; {host_key()} handshake passed") From 6d227218e8f01a45baf0a7adddf3fceda7b9bb03 Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Mon, 7 Sep 2026 13:29:59 +0200 Subject: [PATCH 2/4] feat(forecast): select Rust predictions before legacy shadow Signed-off-by: Fredrik Ahlgren --- .changeset/forecast-learning.md | 2 +- docs/architecture.md | 30 +- go/cmd/ftw-forecast-evaluate/main.go | 14 +- go/cmd/ftw-forecast-evaluate/main_test.go | 95 +++++- go/cmd/ftw/forecast_primary_test.go | 276 ++++++++++++++++++ go/cmd/ftw/forecast_rust.go | 27 +- go/cmd/ftw/forecast_rust_test.go | 17 +- go/cmd/ftw/forecast_site.go | 3 +- go/cmd/ftw/forecast_tracking.go | 221 ++++++++++---- go/cmd/ftw/forecast_tracking_test.go | 4 - go/cmd/ftw/main.go | 6 +- go/internal/energyforecast/client.go | 4 +- go/internal/energyforecast/client_test.go | 40 +++ go/internal/energyforecast/types.go | 5 +- go/internal/forecasting/contract.go | 37 ++- go/internal/forecasting/evaluate.go | 23 +- .../forecasting/partial_evaluation_test.go | 80 +++++ go/internal/forecasting/partial_test.go | 43 +++ go/internal/forecasting/primary_test.go | 100 +++++++ go/internal/mpc/forecast_primary_test.go | 136 +++++++++ go/internal/mpc/forecast_snapshot.go | 5 + go/internal/mpc/service.go | 39 ++- optimizer/native/README.md | 72 +++-- 23 files changed, 1144 insertions(+), 135 deletions(-) create mode 100644 go/cmd/ftw/forecast_primary_test.go create mode 100644 go/internal/forecasting/partial_evaluation_test.go create mode 100644 go/internal/forecasting/partial_test.go create mode 100644 go/internal/forecasting/primary_test.go create mode 100644 go/internal/mpc/forecast_primary_test.go diff --git a/.changeset/forecast-learning.md b/.changeset/forecast-learning.md index b7e4a531..0b33fa46 100644 --- a/.changeset/forecast-learning.md +++ b/.changeset/forecast-learning.md @@ -4,4 +4,4 @@ Correct weather interval timing, panel direction and forecast energy. Train household and PV models only on fresh, complete measurements. Keep grid limits separate from household demand and let PV learn its scale without a battery-based guess. -Run Energyplan 0.2.0 PV and load models locally as forecast candidates, with no required panel geometry. Save issued forecasts and model state for causal comparison, report uncertainty by horizon, and retain the current planner forecast while gathering evidence. Add a read-only forecast evaluation command. No candidate promotion or cloud connection is required. +Use the local Energyplan PV and load models as the planner's first forecast source, with no required panel geometry. Keep the previous forecast as a shadow and use it when the new model lacks a valid prediction or its worker fails. Save issued forecasts, per-signal sources and model state for causal comparison, report uncertainty by horizon, and add a read-only forecast evaluation command. diff --git a/docs/architecture.md b/docs/architecture.md index 03c3df75..579d320a 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -3,8 +3,8 @@ FTW is a local-first home energy management system. Its architecture has three explicit modules: **core**, **drivers**, and **optimizer**. Core is the safety boundary. Drivers translate hardware protocols. The optimizer proposes -plans. A failure or upgrade outside core must never stop local measurement or -make dispatch unsafe. +plans and supplies primary forecasts. A failure or upgrade outside core must +never stop local measurement or make dispatch unsafe. ## Module boundaries @@ -12,7 +12,7 @@ make dispatch unsafe. |---|---|---|---| | Core | [`go/cmd/ftw`](../go/cmd/ftw), [`go/internal`](../go/internal), [`web`](../web) | One Go binary | Configuration, telemetry, state, API/UI, safety, control and fallback planning | | Drivers | Editable source in [`srcfl/device-drivers`](https://github.com/srcfl/device-drivers); bundled recovery in `drivers/*.lua`; host in [`go/internal/drivers`](../go/internal/drivers) | One sandboxed Lua VM per configured device | Vendor protocol, sign conversion and device commands | -| Optimizer | [`optimizer`](../optimizer), contract in [`go/internal/mpc`](../go/internal/mpc) | Compiled Energyplan worker | Solve the long-horizon mathematical plan | +| Optimizer | [`optimizer`](../optimizer), contracts in [`go/internal/mpc`](../go/internal/mpc) and [`go/internal/energyforecast`](../go/internal/energyforecast) | Compiled Energyplan worker | Solve the long-horizon plan and supply primary PV and household-load forecasts | Core can run without the optimizer. Hardware cannot be accessed without a driver, but one failed driver is isolated from the others. Optional @@ -111,6 +111,30 @@ stay in the private Energyplan repository. It updates with the Core image. The optimizer never reads hardware or issues commands, so its deployment and dependency churn do not enlarge the safety-critical runtime. +The same worker also supplies the primary PV and household-load forecast through +a separate versioned contract. At the start of each replan, Core freezes the +legacy forecast, weather, occupancy and saved model state. It calls the forecast +worker once under a deadline, outside control and dispatch locks. Core accepts +PV and load independently for each covered interval. If either signal is +missing, late, partial or invalid, Core retains the matching legacy value. The +resulting `champion` can therefore contain Energyplan PV with legacy load, or +the reverse. `legacy_shadow` keeps both legacy signals from the same frozen +capture for a fair later comparison. + +Complete qualified 15-minute observations update the local models outside +dispatch. SQLite stores the latest Energyplan state under +`forecast/energyplan_state_v1`; an update becomes visible only after its full +state has been saved, and startup restores that saved state. The learning +revision binds state to forecast inputs and stable hardware identities. A +binding or input change starts fresh learning, while a compatible program +upgrade can reuse the state. Issued forecasts use a stricter revision that also +includes the Core build, worker bytes and pipeline policy. + +Core keeps issued forecasts, frozen inputs, model-state references and qualified +truth in a bounded local archive. The read-only `ftw-forecast-evaluate` source +command defaults to matched `champion` versus `legacy_shadow` results from the +same issue. It does not treat missing or censored truth as evidence. + ## Versioning a module contract Drivers release independently. Energyplan ships with Core, but Core still diff --git a/go/cmd/ftw-forecast-evaluate/main.go b/go/cmd/ftw-forecast-evaluate/main.go index 657c402a..60e7febf 100644 --- a/go/cmd/ftw-forecast-evaluate/main.go +++ b/go/cmd/ftw-forecast-evaluate/main.go @@ -25,6 +25,8 @@ type report struct { Since string `json:"since"` IssueCount int `json:"issue_count"` TruthCount int `json:"truth_count"` + PrimarySeries string `json:"primary_series"` + ReferenceSeries string `json:"reference_series"` PerLead []forecasting.Metric `json:"per_lead"` BandCoverage []bandCoverage `json:"band_coverage"` PairedMetrics []forecasting.PairMetric `json:"paired_metrics"` @@ -68,12 +70,17 @@ func run(ctx context.Context, args []string, output io.Writer, now time.Time) er statePath := fs.String("state", "state.db", "path to state.db") sinceText := fs.String("since", "", "first issue time, RFC3339 (default: 30 days before until)") untilText := fs.String("until", "", "last issue and truth time, RFC3339 (default: now)") + primary := fs.String("primary", "champion", "actual primary series to compare") + reference := fs.String("reference", "legacy_shadow", "frozen reference series from the same issue") if err := fs.Parse(args); err != nil { return err } if fs.NArg() != 0 { return errors.New("unexpected positional arguments") } + if *primary == "" || *reference == "" || len(*primary) > 80 || len(*reference) > 80 || *primary == *reference { + return errors.New("-primary and -reference must be distinct nonempty series names of at most 80 bytes") + } until, err := parseBound(*untilText, now.UTC()) if err != nil { return fmt.Errorf("parse -until: %w", err) @@ -145,9 +152,11 @@ func run(ctx context.Context, args []string, output io.Writer, now time.Time) er Since: since.UTC().Format(time.RFC3339), IssueCount: issues, TruthCount: len(observations), + PrimarySeries: *primary, + ReferenceSeries: *reference, PerLead: forecasting.Metrics(pointSamples), BandCoverage: summarizeBands(pointSamples), - PairedMetrics: forecasting.CompareSeries(pointSamples, "champion", "energyplan"), + PairedMetrics: forecasting.CompareFrozenSeries(pointSamples, *primary, *reference), CumulativeNetError: forecasting.CumulativeMetrics(cumulativeSamples), } encoder := json.NewEncoder(output) @@ -248,6 +257,9 @@ func summarizeBands(samples []forecasting.ErrorSample) []bandCoverage { } all := make(map[key]*acc) for _, sample := range samples { + if sample.Validate() != nil { + continue + } for _, signal := range []string{"pv", "load", "net"} { actual, known, band, evidence := bandInputs(sample, signal) if !known { diff --git a/go/cmd/ftw-forecast-evaluate/main_test.go b/go/cmd/ftw-forecast-evaluate/main_test.go index 18ff13c9..3e8b5a26 100644 --- a/go/cmd/ftw-forecast-evaluate/main_test.go +++ b/go/cmd/ftw-forecast-evaluate/main_test.go @@ -139,9 +139,11 @@ func TestEvaluateDeduplicatesOriginsAndReportsAllEnergyHorizons(t *testing.T) { } } older := forecastIssue("older", start.Add(-2*time.Hour-10*time.Minute).UnixMilli(), olderPoints) - older.Series = append(older.Series, forecasting.Series{Name: "energyplan", ModelVersion: "v1", Points: olderPoints}) + older.Series = append(older.Series, forecasting.Series{Name: "legacy_shadow", ModelVersion: "v1", Points: olderPoints}) newer := forecastIssue("newer", start.Add(-2*time.Hour).UnixMilli(), newerPoints) - newer.Series = append(newer.Series, forecasting.Series{Name: "energyplan", ModelVersion: "v1", Points: energyplanPoints}) + newer.Series = append(newer.Series, + forecasting.Series{Name: "legacy_shadow", ModelVersion: "v1", Points: olderPoints}, + forecasting.Series{Name: "energyplan", ModelVersion: "v1", Points: energyplanPoints}) if err := store.SaveForecastIssue(ctx, newer); err != nil { t.Fatal(err) } @@ -184,7 +186,18 @@ func TestEvaluateDeduplicatesOriginsAndReportsAllEnergyHorizons(t *testing.T) { } } if len(got.PairedMetrics) == 0 { - t.Fatal("matched champion/energyplan targets produced no paired metrics") + t.Fatal("matched primary/legacy shadow targets produced no paired metrics") + } + if got.PrimarySeries != "champion" || got.ReferenceSeries != "legacy_shadow" { + t.Fatalf("unexpected comparison roles: %+v", got) + } + for _, metric := range got.PairedMetrics { + if metric.Champion != "champion" || metric.Candidate != "legacy_shadow" { + t.Fatalf("raw Rust diagnostic replaced the frozen reference: %+v", metric) + } + if metric.Signal == "pv" && (metric.ChampionMAEW != 100 || metric.CandidateMAEW != 200 || metric.DeltaMAEW != 100) { + t.Fatalf("composed primary/reference scores incorrect: %+v", metric) + } } } @@ -200,3 +213,79 @@ func TestEvaluateRejectsMoreThanRetentionAndBadRFC3339(t *testing.T) { t.Fatal("window beyond retention was accepted") } } + +func TestEvaluateDoesNotPairLaterPrimaryWithOlderShadow(t *testing.T) { + path, store := openArchive(t) + ctx := context.Background() + now := time.Now().UTC().Truncate(time.Hour) + start := now.Add(-2 * time.Hour) + point := forecastPoint(start.UnixMilli(), 0, 600) + point.PVSource, point.LoadSource = "energyplan", "legacy" + point.PVQuality, point.LoadQuality = "cold_start", "cold_start" + older := forecastIssue("older", start.Add(-2*time.Hour).UnixMilli(), []forecasting.Point{point}) + older.Series = append(older.Series, forecasting.Series{Name: "legacy_shadow", ModelVersion: "v1", Points: []forecasting.Point{point}}) + newer := forecastIssue("newer", start.Add(-time.Hour).UnixMilli(), []forecasting.Point{point}) + for _, issue := range []forecasting.Issue{older, newer} { + if err := store.SaveForecastIssue(ctx, issue); err != nil { + t.Fatal(err) + } + } + if err := store.SaveForecastObservation(ctx, observation(start.UnixMilli(), start.Add(time.Hour).UnixMilli(), 0, 800)); err != nil { + t.Fatal(err) + } + if err := store.Close(); err != nil { + t.Fatal(err) + } + got := runReport(t, path, start.Add(-3*time.Hour), now, now) + if len(got.PerLead) == 0 || len(got.PairedMetrics) != 0 { + t.Fatalf("latest primary must retain standalone scores without stale pair: %+v", got) + } +} + +func TestEvaluateCanSelectHistoricalReferenceExplicitly(t *testing.T) { + path, store := openArchive(t) + ctx := context.Background() + now := time.Now().UTC().Truncate(time.Hour) + start := now.Add(-2 * time.Hour) + point := forecastPoint(start.UnixMilli(), 100, 600) + issue := forecastIssue("historical", start.Add(-time.Hour).UnixMilli(), []forecasting.Point{point}) + issue.Series = append(issue.Series, forecasting.Series{Name: "energyplan", ModelVersion: "v1", Points: []forecasting.Point{point}}) + if err := store.SaveForecastIssue(ctx, issue); err != nil { + t.Fatal(err) + } + if err := store.SaveForecastObservation(ctx, observation(start.UnixMilli(), start.Add(time.Hour).UnixMilli(), 0, 800)); err != nil { + t.Fatal(err) + } + if err := store.Close(); err != nil { + t.Fatal(err) + } + got := runReport(t, path, start.Add(-2*time.Hour), now, now) + if len(got.PairedMetrics) != 0 { + t.Fatalf("historical raw Rust silently treated as legacy reference: %+v", got) + } + var output bytes.Buffer + if err := run(ctx, []string{"-state", path, "-reference", "energyplan"}, &output, now); err != nil { + t.Fatal(err) + } + if err := json.Unmarshal(output.Bytes(), &got); err != nil { + t.Fatal(err) + } + if got.ReferenceSeries != "energyplan" || len(got.PairedMetrics) != 3 { + t.Fatalf("explicit historical reference ignored: %+v", got) + } +} + +func TestBandReportExcludesRemainingInterval(t *testing.T) { + start := time.Date(2026, 9, 1, 12, 0, 0, 0, time.UTC).UnixMilli() + point := forecastPoint(start, 100, 600) + sample := forecasting.ErrorSample{Series: "champion", ConfigVersion: "cfg", IssueID: "i", + OriginMS: start - testHourMS, IssuedAtMS: start - testHourMS, StartMS: start, EndMS: start + testHourMS, + AvailableAtMS: start + testHourMS, Lead: 1, PVKnown: true, LoadKnown: true, Prediction: point} + if got := summarizeBands([]forecasting.ErrorSample{sample}); len(got) != 3 { + t.Fatalf("whole interval lost from band report: %+v", got) + } + sample.Prediction.PredictionStartMS = start + 60000 + if got := summarizeBands([]forecasting.ErrorSample{sample}); len(got) != 0 { + t.Fatalf("partial interval received band coverage credit: %+v", got) + } +} diff --git a/go/cmd/ftw/forecast_primary_test.go b/go/cmd/ftw/forecast_primary_test.go new file mode 100644 index 00000000..cfafd6f9 --- /dev/null +++ b/go/cmd/ftw/forecast_primary_test.go @@ -0,0 +1,276 @@ +package main + +import ( + "context" + "encoding/json" + "os" + "reflect" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/energyforecast" + "github.com/srcfl/ftw/go/internal/forecasting" + "github.com/srcfl/ftw/go/internal/mpc" +) + +func primaryFixture(at time.Time, exchange hostForecastExchange) *forecastTracker { + f := trackerFixture(at) + f.site = hostForecastSite + f.candidate = &rustForecast{client: energyforecast.NewClient(exchange)} + return f +} + +func primaryReply(_ context.Context, payload []byte) ([]byte, error) { + _, reply := hostForecastReply(payload) + return json.Marshal(reply) +} + +func primarySeries(t *testing.T, issue forecasting.Issue, name string) forecasting.Series { + t.Helper() + for _, s := range issue.Series { + if s.Name == name { + return s + } + } + t.Fatalf("missing %s", name) + return forecasting.Series{} +} + +func TestForecastPrimaryRustControlsSlotsAndArchivesFrozenLegacy(t *testing.T) { + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + f := primaryFixture(at, primaryReply) + weather := trackerWeather(at, at) + in := f.Snapshot(at, weather) + legacy := trackerSlots(at, 4) + base := in.Resolve(context.Background(), legacy) + if base[0].PVW != -100 || base[0].LoadW != 1100 || base[2].PVW != -300 { + t.Fatalf("Rust did not replace actual slots: %+v", base) + } + if in.PVUncertaintyW != 0 || in.PVRelativeUncertainty != 0 { + t.Fatal("primary inherited legacy uncertainty scalars") + } + planning := append([]mpc.Slot(nil), base...) + in.Risk(base, planning, 1) + if planning[0].PVW != -50 || planning[2].PVW != -250 { + t.Fatalf("risk did not use Rust provisional range: %+v", planning) + } + // These mutations happen after inference but before publication. They must + // not rewrite either model's frozen forecast or weather inputs. + legacy[0].PVW = -99999 + *weather[0].SolarWm2 = 999 + f.pv.SetRated(100000) + f.load.SetHeatingCoef(900) + in.Record(base, planning, "decision", at.Add(time.Second).UnixMilli()) + issue := (<-f.queue).issue + if err := issue.Validate(); err != nil { + t.Fatal(err) + } + champion, shadow := primarySeries(t, issue, "champion"), primarySeries(t, issue, "legacy_shadow") + if champion.Points[0].PVW != 100 || shadow.Points[0].PVW != 2000 || *issue.Weather[0].GHIWm2 != 500 { + t.Fatal("issued primary/shadow not frozen independently") + } + if champion.Points[0].LoadSource != "energyplan" || champion.Points[0].LoadQuality != "cold_start" || champion.Points[2].PVQuality != "learning" || shadow.Points[0].PVSource != "legacy" { + t.Fatal("primary source or independently earned model quality lost") + } + if primarySeries(t, issue, "planning").Points[0].PVW != 50 || primarySeries(t, issue, "energyplan").Points[0].PVW != 100 { + t.Fatal("risk adjustment overwrote issued model forecast") + } + st := hostForecastDB(t) + if err := st.SaveForecastIssue(context.Background(), issue); err != nil { + t.Fatal(err) + } +} + +func TestForecastPrimarySelectsEachSignalAndRealZero(t *testing.T) { + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + f := primaryFixture(at, func(_ context.Context, p []byte) ([]byte, error) { + _, reply := hostForecastReply(p) + rows := reply["predictions"].([]any) + rows[0].(map[string]any)["pv"] = map[string]any{"known": false, "quality": "unknown", "uncertainty": "unavailable", "coverage": 0} + rows[1].(map[string]any)["pv"] = map[string]any{"known": true, "point_w": 0, "lower_w": 0, "upper_w": 50, "quality": "cold_start", "uncertainty": "provisional", "coverage": 0} + rows[1].(map[string]any)["load"] = map[string]any{"known": false, "quality": "unknown", "uncertainty": "unavailable", "coverage": 0} + return json.Marshal(reply) + }) + in := f.Snapshot(at, trackerWeather(at, at)) + legacy := trackerSlots(at, 2) + got := in.Resolve(context.Background(), legacy) + if got[0].PVW != legacy[0].PVW || got[0].LoadW != 1100 || got[1].PVW != 0 || got[1].LoadW != legacy[1].LoadW { + t.Fatalf("signal fallback or real zero wrong: %+v", got) + } + in.Record(got, got, "decision", at.UnixMilli()) + points := primarySeries(t, (<-f.queue).issue, "champion").Points + if points[0].PVSource != "legacy" || points[0].ModelPV != nil || points[0].PVKnown || points[1].LoadSource != "legacy" || points[1].ModelLoad != nil || !points[1].PVKnown || points[1].PVQuality != "cold_start" { + t.Fatalf("fallback fabricated knowledge or retained wrong model range: %+v", points) + } +} + +func TestForecastPrimaryUnavailableRetainsLegacy(t *testing.T) { + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + for _, kind := range []string{"unsupported", "timeout", "invalid", "missing_quarter"} { + t.Run(kind, func(t *testing.T) { + f := primaryFixture(at, func(ctx context.Context, p []byte) ([]byte, error) { + if kind == "timeout" { + <-ctx.Done() + return nil, ctx.Err() + } + _, reply := hostForecastReply(p) + rows := reply["predictions"].([]any) + if kind == "invalid" { + rows[0].(map[string]any)["pv"].(map[string]any)["point_w"] = -1 + } + if kind == "missing_quarter" { + reply["predictions"] = rows[:len(rows)-1] + } + return json.Marshal(reply) + }) + if kind == "unsupported" { + f.candidate = nil + } + in := f.Snapshot(at, trackerWeather(at, at)) + legacy := trackerSlots(at, 2) + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond) + defer cancel() + got := in.Resolve(ctx, legacy) + if !reflect.DeepEqual(got, legacy) { + t.Fatalf("unavailable worker changed legacy fallback: %+v", got) + } + in.Record(got, got, "decision", at.UnixMilli()) + issue := (<-f.queue).issue + if primarySeries(t, issue, "champion").Points[0].LoadSource != "legacy" { + t.Fatal("fallback not explicit") + } + }) + } +} + +func TestForecastPrimaryPartialCurrentIntervalUsesRustRemainder(t *testing.T) { + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + at := start.Add(7 * time.Minute) + f := primaryFixture(at, primaryReply) + in := f.Snapshot(at, trackerWeather(start, at)) + legacy := trackerSlots(start, 3) + got := in.Resolve(context.Background(), legacy) + if got[0].PVW != -100 || got[0].LoadW != 1100 || got[1].PVW != -200 || got[2].LoadW != 1300 { + t.Fatalf("current interval did not use Rust remainder: %+v", got) + } + in.Record(got, got, "partial-decision", at.UnixMilli()) + issue := (<-f.queue).issue + if err := issue.Validate(); err != nil { + t.Fatal(err) + } + for _, name := range []string{"champion", "planning", "legacy_shadow", "energyplan"} { + if primarySeries(t, issue, name).Points[0].PredictionStartMS != at.UnixMilli() { + t.Fatalf("partial not explicit in %s", name) + } + } +} + +func TestForecastPrimaryNativeColdLoadUsedWithoutLegacyTrust(t *testing.T) { + binary := os.Getenv("FTW_FORECAST_WORKER") + if binary == "" { + t.Skip("set FTW_FORECAST_WORKER for native primary integration") + } + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + st := hostForecastDB(t) + r, err := newRustForecast(st, binary) + if err != nil { + t.Fatal(err) + } + defer r.Close() + f := trackerFixture(at) + f.site, f.candidate = hostForecastSite, r + in := f.Snapshot(at, trackerWeather(at, at)) + legacy := trackerSlots(at, 4) + legacy[0].LoadW = 98765 + got := in.Resolve(context.Background(), legacy) + if got[0].LoadW == legacy[0].LoadW { + t.Fatal("native cold model did not become primary") + } + in.Record(got, got, "native-decision", at.Add(time.Second).UnixMilli()) + issue := (<-f.queue).issue + point := primarySeries(t, issue, "champion").Points[0] + if point.LoadSource != "energyplan" || !point.LoadKnown || point.LoadQuality != "cold_start" || !reflect.DeepEqual(point.ModelLoad, primarySeries(t, issue, "energyplan").Points[0].ModelLoad) { + t.Fatalf("native cold primary evidence missing: %+v", point) + } + if err := st.SaveForecastIssue(context.Background(), issue); err != nil { + t.Fatal(err) + } +} + +func TestForecastPrimaryResolveUsesCapturedStateAndFeatures(t *testing.T) { + at := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + var request energyforecast.PredictRequest + f := primaryFixture(at, func(_ context.Context, p []byte) ([]byte, error) { + if err := json.Unmarshal(p, &request); err != nil { + t.Fatal(err) + } + return primaryReply(context.Background(), p) + }) + r := f.candidate.(*rustForecast) + r.saved = savedForecastState{SiteID: hostForecastSite().SiteID, ConfigRevision: hostForecastSite().Revision, + LatestAvailableMS: at.Add(-time.Minute).UnixMilli(), State: json.RawMessage(`{"epoch":1}`)} + away := false + f.away = func(time.Time) bool { return away } + weather := trackerWeather(at, at) + in := f.Snapshot(at, weather) + r.saved = savedForecastState{SiteID: hostForecastSite().SiteID, ConfigRevision: hostForecastSite().Revision, + LatestAvailableMS: at.Add(time.Minute).UnixMilli(), State: json.RawMessage(`{"epoch":2}`)} + away = true + *weather[0].SolarWm2 = 999 + got := in.Resolve(context.Background(), trackerSlots(at, 1)) + if got[0].PVW != -100 || string(request.State) != `{"epoch":1}` || request.Horizon[0].Home == nil || !*request.Horizon[0].Home || *request.Horizon[0].GHIWm2 != 500 { + t.Fatalf("live state or features leaked into primary request: %+v", request) + } + in.Record(got, got, "decision", at.Add(time.Second).UnixMilli()) + issue := (<-f.queue).issue + for _, model := range issue.Models { + if model.Name == "energyplan" && string(model.State) != `{"epoch":1}` { + t.Fatal("archive stored post-origin model") + } + } +} + +func TestForecastPrimaryNativeCurrentIntervalReplaysAfterNewObservation(t *testing.T) { + binary := os.Getenv("FTW_FORECAST_WORKER") + if binary == "" { + t.Skip("set FTW_FORECAST_WORKER to a partial-capable native worker") + } + start := time.Date(2026, 6, 15, 12, 0, 0, 0, time.UTC) + origin := start.Add(7*time.Minute + 123*time.Millisecond) + r, err := newRustForecast(hostForecastDB(t), binary) + if err != nil { + t.Fatal(err) + } + defer r.Close() + f := trackerFixture(origin) + f.site, f.candidate = hostForecastSite, r + capturedState := r.Snapshot() + in := f.Snapshot(origin, trackerWeather(start, origin)) + legacy := trackerSlots(start, 4) + got := in.Resolve(context.Background(), legacy) + if got[0].LoadW == legacy[0].LoadW { + t.Fatal("first current control interval still used legacy load") + } + in.Record(got, got, "native-partial", origin.Add(time.Second).UnixMilli()) + issue := (<-f.queue).issue + primary := primarySeries(t, issue, "champion").Points[0] + if primary.PredictionStartMS != origin.UnixMilli() || primary.LoadSource != "energyplan" { + t.Fatalf("partial first interval provenance missing: %+v", primary) + } + obs := forecasting.Observation{StartMS: start.UnixMilli(), EndMS: start.Add(15 * time.Minute).UnixMilli(), + AvailableAtMS: start.Add(15 * time.Minute).UnixMilli(), LoadW: 7500, LoadKnown: true} + if err = r.Update(context.Background(), hostForecastSite(), obs, nil, false); err != nil { + t.Fatal(err) + } + replay, err := r.Predict(context.Background(), hostForecastSite(), issue, capturedState, nil) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(replay.Series[0].Points, primarySeries(t, issue, "energyplan").Points) { + // Bands are host calibration output rather than worker inference state. + applyForecastBands(&replay, nil) + if !reflect.DeepEqual(replay.Series[0].Points, primarySeries(t, issue, "energyplan").Points) { + t.Fatal("new observation changed replayed remaining-interval forecast") + } + } +} diff --git a/go/cmd/ftw/forecast_rust.go b/go/cmd/ftw/forecast_rust.go index abd4f97e..3289c58c 100644 --- a/go/cmd/ftw/forecast_rust.go +++ b/go/cmd/ftw/forecast_rust.go @@ -176,8 +176,9 @@ func (r *rustForecast) Predict(ctx context.Context, site forecastSite, issued fo base := issued.Series[0].Points horizon := make([]energyforecast.HorizonSlot, 0) for _, p := range base { - for at := p.StartMS; at < p.EndMS; at += 900000 { - if at < issued.OriginMS || at%900000 != 0 || at+900000 > p.EndMS { + for at := p.StartMS / 900000 * 900000; at < p.EndMS; at += 900000 { + partStart, partEnd := max(at, p.StartMS, issued.OriginMS), min(at+900000, p.EndMS) + if partStart >= partEnd { continue } home, knownHome := homeByQuarter[at] @@ -196,12 +197,12 @@ func (r *rustForecast) Predict(ctx context.Context, site forecastSite, issued fo break } } - horizon = append(horizon, energyforecast.HorizonSlot{Interval: energyforecast.Interval{ValidStartMs: at, ValidEndMs: at + 900000}, + horizon = append(horizon, energyforecast.HorizonSlot{Interval: energyforecast.Interval{ValidStartMs: partStart, ValidEndMs: partEnd}, Features: rustFeatures(time.UnixMilli(at), site, home, weather)}) } } if len(horizon) == 0 { - return forecasting.Issue{}, errors.New("no future full quarter for candidate") + return forecasting.Issue{}, errors.New("no remaining forecast interval") } reply, err := r.client.Predict(ctx, energyforecast.PredictRequest{RequestContext: energyforecast.RequestContext{ RequestID: uuid.NewString(), SiteID: site.SiteID, ConfigRevision: rustConfigRevision(site), OriginMs: issued.OriginMS, @@ -241,14 +242,18 @@ func (r *rustForecast) Predict(ctx context.Context, site forecastSite, issued fo out.Models = append(out.Models, forecasting.ModelState{Name: "energyplan_metadata", Version: version, UpdatedAtMS: saved.LatestAvailableMS, Quality: quality, State: metadata}) series := forecasting.Series{Name: "energyplan", ModelVersion: version} - // Preserve the planner's interval duration. Rust v1 only predicts quarters; - // four quarters form an hourly energy mean, never an hourly maximum. + // Preserve planner slot bounds while averaging only the remaining duration. + // Complete quarters and the current partial quarter contribute by energy. for _, p := range base { - if p.StartMS < issued.OriginMS { + predictionStart := max(p.StartMS, issued.OriginMS) + if predictionStart >= p.EndMS { continue } - got := forecasting.Point{StartMS: p.StartMS, EndMS: p.EndMS, PVKnown: site.HasLocation, LoadKnown: true, PVQuality: "ready", LoadQuality: "ready"} - cursor := p.StartMS + got := forecasting.Point{StartMS: p.StartMS, EndMS: p.EndMS, PVKnown: site.HasLocation, LoadKnown: true, PVQuality: "ready", LoadQuality: "ready", PVSource: "energyplan", LoadSource: "energyplan"} + if predictionStart > p.StartMS { + got.PredictionStartMS = predictionStart + } + cursor := predictionStart parts, pvEvidence, loadEvidence := 0, 0, 0 for _, v := range reply.Predictions { if v.ValidStartMs < cursor { @@ -257,7 +262,7 @@ func (r *rustForecast) Predict(ctx context.Context, site forecastSite, issued fo if v.ValidStartMs != cursor || v.ValidEndMs > p.EndMS { break } - fraction := float64(v.ValidEndMs-v.ValidStartMs) / float64(p.EndMS-p.StartMS) + fraction := float64(v.ValidEndMs-v.ValidStartMs) / float64(p.EndMS-predictionStart) parts++ if addModelEvidence(&got.ModelPV, v.PV, fraction) { pvEvidence++ @@ -295,7 +300,7 @@ func (r *rustForecast) Predict(ctx context.Context, site forecastSite, issued fo } } if len(series.Points) == 0 { - return forecasting.Issue{}, errors.New("candidate did not cover a complete planner interval") + return forecasting.Issue{}, errors.New("candidate did not cover a remaining planner interval") } out.Series = []forecasting.Series{series} return out, nil diff --git a/go/cmd/ftw/forecast_rust_test.go b/go/cmd/ftw/forecast_rust_test.go index b12b1c44..283d36fb 100644 --- a/go/cmd/ftw/forecast_rust_test.go +++ b/go/cmd/ftw/forecast_rust_test.go @@ -3,6 +3,7 @@ package main import ( "context" "encoding/json" + "math" "os" "path/filepath" "reflect" @@ -90,11 +91,11 @@ func TestRustForecastHostQuarterEnergyAndPartialHour(t *testing.T) { if err != nil { t.Fatal(err) } - if len(captured.Horizon) != 7 { - t.Fatalf("future full quarters=%d want7", len(captured.Horizon)) + if len(captured.Horizon) != 8 { + t.Fatalf("remaining quarter parts=%d want8", len(captured.Horizon)) } for _, slot := range captured.Horizon { - if slot.ValidStartMs < issue.OriginMS || slot.ValidStartMs%900000 != 0 || slot.ValidEndMs-slot.ValidStartMs != 900000 { + if slot.ValidStartMs < issue.OriginMS || slot.ValidEndMs-slot.ValidStartMs > 900000 || slot.ValidStartMs/900000 != (slot.ValidEndMs-1)/900000 { t.Fatalf("invalid candidate quarter: %+v", slot) } if slot.Home == nil || *slot.Home == away[slot.ValidStartMs] { @@ -105,10 +106,14 @@ func TestRustForecastHostQuarterEnergyAndPartialHour(t *testing.T) { } } points := got.Series[0].Points - if len(points) != 1 || points[0].StartMS != start.Add(time.Hour).UnixMilli() { - t.Fatalf("partial current hour was published: %+v", points) + if len(points) != 2 || points[0].PredictionStartMS != issue.OriginMS || points[1].PredictionStartMS != 0 { + t.Fatalf("remaining current hour not explicit: %+v", points) } - p := points[0] + wantPartial := float64(100*8+200*15+300*15+400*15) / 53 + if math.Abs(points[0].PVW-wantPartial) > 1e-9 || math.Abs(points[0].LoadW-(wantPartial+1000)) > 1e-9 { + t.Fatalf("partial hour not weighted by remaining minutes: %+v", points[0]) + } + p := points[1] if p.PVW != 250 || p.LoadW != 1250 { t.Fatalf("quarter power not energy mean: PV=%v load=%v", p.PVW, p.LoadW) } diff --git a/go/cmd/ftw/forecast_site.go b/go/cmd/ftw/forecast_site.go index 2a21f276..f5041559 100644 --- a/go/cmd/ftw/forecast_site.go +++ b/go/cmd/ftw/forecast_site.go @@ -44,6 +44,7 @@ type forecastIdentityReceipt struct { } const forecastIdentityReceiptKey = "forecast/live_identity_v1" +const forecastPipelinePolicy = "energyplan-primary-v1" func newForecastSiteConfig(st *state.Store) *forecastSiteConfig { id, _ := st.LoadConfig("forecast/site_id") @@ -199,7 +200,7 @@ func (s *forecastSiteConfig) RefreshIdentity(now time.Time) bool { } data, _ := json.Marshal(ids) learning := fmt.Sprintf("site-v2:%x", sha256.Sum256([]byte(s.baseRevision+"/"+string(data)))) - cohort := learning + "/" + Version + "/" + s.engineVersion + cohort := learning + "/" + Version + "/" + s.engineVersion + "/" + forecastPipelinePolicy revision := fmt.Sprintf("forecast-v1:%x", sha256.Sum256([]byte(cohort))) opts := s.baseOptions if pending && opts.HouseholdInvalidReason == "" { diff --git a/go/cmd/ftw/forecast_tracking.go b/go/cmd/ftw/forecast_tracking.go index 7ee4789d..47c1a3df 100644 --- a/go/cmd/ftw/forecast_tracking.go +++ b/go/cmd/ftw/forecast_tracking.go @@ -45,10 +45,7 @@ type forecastCandidate interface { } type forecastJob struct { - issue forecasting.Issue - site forecastSite - candidateState json.RawMessage - away map[int64]bool + issue forecasting.Issue } type forecastTracker struct { @@ -118,8 +115,8 @@ func (f *forecastTracker) run(ctx context.Context) { f.mu.Lock() f.stopped = true f.mu.Unlock() - // Finish archiving already issued champion forecasts under a fresh bounded - // context. Candidate work can be recreated; issued inputs cannot. + // Finish archiving the already issued primary and shadow together under + // a fresh bounded context. Their frozen inputs cannot be recreated. drainCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 3*time.Second) defer cancel() save := func(job forecastJob) { @@ -160,22 +157,6 @@ func (f *forecastTracker) run(ctx context.Context) { continue } pending = nil - if f.candidate != nil { - workCtx, cancel := context.WithTimeout(ctx, 2*time.Second) - candidate, err := f.candidate.Predict(workCtx, job.site, job.issue, job.candidateState, job.away) - cancel() - if err != nil { - slog.Debug("forecast candidate unavailable", "err", err) - continue - } - f.applyBands(&candidate) - writeCtx, cancel = context.WithTimeout(ctx, 2*time.Second) - err = f.store.SaveForecastIssue(writeCtx, candidate) - cancel() - if err != nil { - slog.Warn("forecast archive: candidate not saved", "err", err) - } - } case now := <-tick.C: f.observe(ctx, now) } @@ -441,8 +422,7 @@ func (f *forecastTracker) Snapshot(_ time.Time, weather []state.ForecastPoint) m } return m.Predict(t, temp) } - in := mpc.ForecastInputs{PV: pvFn, PVResidualCorrect: pv.ResidualCorrect, Load: loadFn, - PVUncertaintyW: pv.ResidualStdW(origin), PVRelativeUncertainty: pv.RelativeUncertainty(), Weather: frozen} + in := mpc.ForecastInputs{PV: pvFn, PVResidualCorrect: pv.ResidualCorrect, Load: loadFn, Weather: frozen} in.PVWeight = func(t time.Time) float64 { if !site.HasPVScale { return 1 @@ -494,32 +474,9 @@ func (f *forecastTracker) Snapshot(_ time.Time, weather []state.ForecastPoint) m latest = max(latest, e.AvailableAtMS) } } - // Calibrated net error uses the same issued champion, including its actual - // blend. Prior uncertainty remains explicit until held-out evidence exists. - in.Risk = func(base, planning []mpc.Slot, k float64) { - if k <= 0 || math.IsNaN(k) || math.IsInf(k, 0) { - return - } - for i, s := range base { - net := s.LoadW + s.PVW - end := s.StartMs + int64(s.LenMin)*time.Minute.Milliseconds() - band := calibrator.BandForInterval("champion", "net", s.StartMs, end, net) - if band.Method == forecasting.BandMethodEmpirical { - extra := math.Max(0, k*(band.HighW-net)) - pvLoss := math.Min(-s.PVW, extra) - planning[i].PVW = s.PVW + pvLoss - planning[i].LoadW = s.LoadW + extra - pvLoss - } else if pv.RelativeUncertainty() <= 0 && pv.ResidualStdW(origin) <= 0 { - // An empty residual window is not certainty. This prior only - // reduces existing generation; it never creates solar at night. - loss := math.Min(-s.PVW, k*.5*(-s.PVW)) - planning[i].PVW = s.PVW + loss - } - } - } - in.Record = func(base, planning []mpc.Slot, decisionID string, issued int64) { - issue := forecasting.Issue{Schema: forecasting.Schema, ID: uuid.NewString(), DecisionID: decisionID, - OriginMS: origin.UnixMilli(), IssuedAtMS: issued, LatestInputMS: latest, ConfigVersion: site.Revision, Site: forecastSiteContext(site), Models: cloneForecastModels(models)} + makeIssue := func(base []mpc.Slot, issued int64) forecasting.Issue { + issue := forecasting.Issue{Schema: forecasting.Schema, ID: uuid.NewString(), + OriginMS: origin.UnixMilli(), IssuedAtMS: max(issued, origin.UnixMilli()), LatestInputMS: latest, ConfigVersion: site.Revision, Site: forecastSiteContext(site), Models: cloneForecastModels(models)} for i := 0; i < 193; i++ { at := start.Add(time.Duration(i) * 15 * time.Minute).UnixMilli() issue.Occupancy = append(issue.Occupancy, forecasting.Occupancy{StartMS: at, EndMS: at + 900000, AvailableAtMS: issue.OriginMS, Home: !away[at]}) @@ -541,10 +498,131 @@ func (f *forecastTracker) Snapshot(_ time.Time, weather []state.ForecastPoint) m AvailableAtMS: r.FetchedAtMs, Source: r.Source, GHIWm2: r.SolarWm2, CloudPct: r.CloudCoverPct, TempC: r.TempC, DirectPVW: directPV, EstimatedPVW: r.PVWEstimated}) } issue.Series = append(issue.Series, forecasting.Series{Name: "champion", ModelVersion: forecastModelRevision(models), Points: forecastPoints(base, frozen, site, origin, load)}) - issue.Series = append(issue.Series, forecasting.Series{Name: "planning", ModelVersion: forecastModelRevision(models), Points: forecastPoints(planning, frozen, site, origin, load)}) + return issue + } + candidate := f.candidate + var legacy []mpc.Slot + var prediction *forecasting.Issue + var selected []forecasting.Point + in.Resolve = func(ctx context.Context, base []mpc.Slot) []mpc.Slot { + legacy = append([]mpc.Slot(nil), base...) + issued := makeIssue(base, origin.UnixMilli()) + selected = append([]forecasting.Point(nil), issued.Series[0].Points...) + for i := range selected { + selected[i].PVSource, selected[i].LoadSource = "legacy", "legacy" + } + prediction = nil + if candidate == nil { + return append([]mpc.Slot(nil), base...) + } + workCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + out, err := candidate.Predict(workCtx, site, issued, candidateState, away) + if err == nil { + err = workCtx.Err() + } + if err != nil { + slog.Debug("primary forecast unavailable; using legacy", "err", err) + return append([]mpc.Slot(nil), base...) + } + // The worker client validates its wire response. The host also binds the + // completed forecast to this capture before it can alter planner inputs. + if out.OriginMS != issued.OriginMS || out.ConfigVersion != issued.ConfigVersion || out.LatestInputMS > issued.OriginMS || len(out.Series) != 1 || out.Series[0].Name != "energyplan" { + slog.Warn("primary forecast binding invalid; using legacy") + return append([]mpc.Slot(nil), base...) + } + applyForecastBandsWith(&out, calibrator) + if err := out.Validate(); err != nil { + slog.Warn("primary forecast invalid; using legacy", "err", err) + return append([]mpc.Slot(nil), base...) + } + prediction = &out + resolved := append([]mpc.Slot(nil), base...) + byStart := make(map[int64]forecasting.Point, len(out.Series[0].Points)) + for _, point := range out.Series[0].Points { + byStart[point.StartMS] = point + } + for i, slot := range base { + point, ok := byStart[slot.StartMs] + if !ok || point.EndMS != slot.StartMs+int64(slot.LenMin)*60000 { + continue + } + if point.StartMS < issued.OriginMS && point.PredictionStartMS != issued.OriginMS { + continue + } + selected[i].PredictionStartMS = point.PredictionStartMS + if usablePrimaryForecast(point.PVKnown, point.PVQuality, point.PVW) { + resolved[i].PVW = -point.PVW + selected[i].PVW, selected[i].PVKnown, selected[i].PVQuality = point.PVW, true, point.PVQuality + selected[i].PVSource, selected[i].ModelPV = "energyplan", point.ModelPV + } + if usablePrimaryForecast(point.LoadKnown, point.LoadQuality, point.LoadW) { + resolved[i].LoadW = point.LoadW + selected[i].LoadW, selected[i].LoadKnown, selected[i].LoadQuality = point.LoadW, true, point.LoadQuality + selected[i].LoadSource, selected[i].ModelLoad = "energyplan", point.ModelLoad + } + } + return resolved + } + // Calibrate the actual composed primary. A Rust prediction does not inherit + // the old model's residual spread or its training trust threshold. + in.Risk = func(base, planning []mpc.Slot, k float64) { + if k <= 0 || math.IsNaN(k) || math.IsInf(k, 0) { + return + } + for i, s := range base { + net := s.LoadW + s.PVW + end := s.StartMs + int64(s.LenMin)*time.Minute.Milliseconds() + band := calibrator.BandForInterval("champion", "net", max(s.StartMs, origin.UnixMilli()), end, net) + if band.Method == forecasting.BandMethodEmpirical { + extra := math.Max(0, k*(band.HighW-net)) + pvLoss := math.Min(-s.PVW, extra) + planning[i].PVW = s.PVW + pvLoss + planning[i].LoadW = s.LoadW + extra - pvLoss + } else if i < len(selected) && selected[i].PVSource == "energyplan" { + loss := .5 * (-s.PVW) + if evidence := selected[i].ModelPV; evidence != nil { + loss = math.Max(0, -s.PVW-evidence.LowerW) + } + planning[i].PVW = s.PVW + math.Min(-s.PVW, k*loss) + } else { + loss := .5 * (-s.PVW) + if relative := pv.RelativeUncertainty(); relative > 0 { + loss = relative * (-s.PVW) + } else if absolute := pv.ResidualStdW(origin); absolute > 0 { + loss = absolute + } + planning[i].PVW = s.PVW + math.Min(-s.PVW, k*loss) + } + } + } + in.Record = func(base, planning []mpc.Slot, decisionID string, issued int64) { + issue := makeIssue(base, issued) + issue.DecisionID = decisionID + if prediction != nil { + issue.Models = append(issue.Models, cloneForecastModels(prediction.Models)...) + issue.LatestInputMS = max(issue.LatestInputMS, prediction.LatestInputMS) + } + version := forecastModelRevision(issue.Models) + issue.Series[0].ModelVersion = version + issue.Series[0].Points = primaryForecastPoints(base, issue.Series[0].Points, selected) + issue.Series = append(issue.Series, forecasting.Series{Name: "planning", ModelVersion: version, + Points: primaryForecastPoints(planning, forecastPoints(planning, frozen, site, origin, load), selected)}) + shadow := legacy + if shadow == nil { + shadow = base // Compatibility with callers that only archive legacy. + } + shadowPoints := forecastPoints(shadow, frozen, site, origin, load) + for i := range shadowPoints { + shadowPoints[i].PVSource, shadowPoints[i].LoadSource = "legacy", "legacy" + } + issue.Series = append(issue.Series, forecasting.Series{Name: "legacy_shadow", ModelVersion: forecastModelRevision(models), Points: shadowPoints}) + if prediction != nil { + issue.Series = append(issue.Series, prediction.Series...) + } issue.Series = append(issue.Series, forecastBaselines(base, frozen, observations, site, origin)...) applyForecastBandsWith(&issue, calibrator) - job := forecastJob{issue: issue, site: site, candidateState: candidateState, away: away} + job := forecastJob{issue: issue} f.mu.Lock() defer f.mu.Unlock() if f.stopped { @@ -560,6 +638,23 @@ func (f *forecastTracker) Snapshot(_ time.Time, weather []state.ForecastPoint) m return in } +func usablePrimaryForecast(known bool, quality string, watts float64) bool { + return known && (quality == "cold_start" || quality == "learning" || quality == "ready") && watts >= 0 && !math.IsNaN(watts) && !math.IsInf(watts, 0) +} + +// Preserve the source and quality used for each signal, while recording the +// actual capped or risk-adjusted watts passed through MPC. +func primaryForecastPoints(slots []mpc.Slot, fallback, selected []forecasting.Point) []forecasting.Point { + for i, slot := range slots { + fallback[i].PVSource, fallback[i].LoadSource = "legacy", "legacy" + if i < len(selected) && selected[i].StartMS == slot.StartMs && selected[i].EndMS == slot.StartMs+int64(slot.LenMin)*60000 { + fallback[i] = selected[i] + } + fallback[i].PVW, fallback[i].LoadW = math.Max(0, -slot.PVW), math.Max(0, slot.LoadW) + } + return fallback +} + func usableTrackingWeather(rows []state.ForecastPoint, origin int64) []state.ForecastPoint { out := make([]state.ForecastPoint, 0, len(rows)) for _, r := range rows { @@ -656,7 +751,11 @@ func forecastPoints(slots []mpc.Slot, weather []state.ForecastPoint, site foreca } } } - out = append(out, forecasting.Point{StartMS: s.StartMs, EndMS: s.StartMs + int64(s.LenMin)*60000, + predictionStart := int64(0) + if s.StartMs < origin.UnixMilli() && origin.UnixMilli() < s.StartMs+int64(s.LenMin)*60000 { + predictionStart = origin.UnixMilli() + } + out = append(out, forecasting.Point{PredictionStartMS: predictionStart, StartMS: s.StartMs, EndMS: s.StartMs + int64(s.LenMin)*60000, PVW: math.Max(0, -s.PVW), LoadW: math.Max(0, s.LoadW), PVKnown: known, LoadKnown: true, PVQuality: quality, LoadQuality: loadQuality}) } @@ -730,6 +829,9 @@ func forecastBaselines(slots []mpc.Slot, weather []state.ForecastPoint, obs []fo series := forecasting.Series{Name: name, ModelVersion: "baseline-v2-local-interval"} for _, s := range slots { p := forecasting.Point{StartMS: s.StartMs, EndMS: s.StartMs + int64(s.LenMin)*60000, PVQuality: "missing", LoadQuality: "missing"} + if p.StartMS < origin.UnixMilli() && origin.UnixMilli() < p.EndMS { + p.PredictionStartMS = origin.UnixMilli() + } switch name { case "weather_prior": if row := forecastRow(weather, p.StartMS, origin.UnixMilli()); forecastPVKnown(row, site) && forecastFinite(row.PVWEstimated) { @@ -779,21 +881,16 @@ func applyForecastBandsWith(issue *forecasting.Issue, calibrator *forecasting.Ca s := &issue.Series[i] for j := range s.Points { p := &s.Points[j] - p.PVBand = calibrator.BandForInterval(s.Name, "pv", p.StartMS, p.EndMS, p.PVW) - p.LoadBand = calibrator.BandForInterval(s.Name, "load", p.StartMS, p.EndMS, p.LoadW) - p.NetBand = calibrator.BandForInterval(s.Name, "net", p.StartMS, p.EndMS, p.LoadW-p.PVW) + start := max(p.StartMS, p.PredictionStartMS) + p.PVBand = calibrator.BandForInterval(s.Name, "pv", start, p.EndMS, p.PVW) + p.LoadBand = calibrator.BandForInterval(s.Name, "load", start, p.EndMS, p.LoadW) + p.NetBand = calibrator.BandForInterval(s.Name, "net", start, p.EndMS, p.LoadW-p.PVW) } } } func applyForecastBands(issue *forecasting.Issue, history []forecasting.ErrorSample) { applyForecastBandsWith(issue, forecasting.NewCalibrator(history, issue.ConfigVersion, issue.OriginMS)) } -func (f *forecastTracker) applyBands(issue *forecasting.Issue) { - f.mu.RLock() - history := f.errors - f.mu.RUnlock() - applyForecastBands(issue, history) -} func forecastSiteContext(site forecastSite) *forecasting.SiteContext { if !site.HasLocation { diff --git a/go/cmd/ftw/forecast_tracking_test.go b/go/cmd/ftw/forecast_tracking_test.go index c4228d70..54f81193 100644 --- a/go/cmd/ftw/forecast_tracking_test.go +++ b/go/cmd/ftw/forecast_tracking_test.go @@ -201,10 +201,6 @@ func TestForecastOriginFollowsCandidateCapture(t *testing.T) { if job.issue.OriginMS != clock.UnixMilli() { t.Fatal("origin preceded candidate snapshot") } - c.snapshot[0] = 'x' - if !json.Valid(job.candidateState) { - t.Fatal("candidate snapshot aliased") - } } func TestForecastIndependentPVIntervalsAndCurtailment(t *testing.T) { f := &forecastTracker{} diff --git a/go/cmd/ftw/main.go b/go/cmd/ftw/main.go index 2d908065..885afe39 100644 --- a/go/cmd/ftw/main.go +++ b/go/cmd/ftw/main.go @@ -1475,7 +1475,8 @@ func main() { } // Archive observations even when price planning is disabled. The Rust - // candidate runs on a separate worker and never delays physical dispatch. + // primary forecast runs on a separate worker during replanning, outside + // physical dispatch. The previous forecast remains its shadow and fallback. forecastTrackerSvc := &forecastTracker{refreshIdentity: refreshForecastIdentity, configMu: &forecastConfigMu, store: st, tele: tel, pv: pvSvc, load: loadSvc, site: func() forecastSite { site := forecastSettings.Snapshot() @@ -1492,9 +1493,10 @@ func main() { } if energyplanSupported(runtime.GOOS, runtime.GOARCH) { if candidate, err := newRustForecast(st, resolveEnergyplanBinary()); err != nil { - slog.Warn("forecast candidate unavailable", "err", err) + slog.Warn("primary forecast worker unavailable; using legacy fallback", "err", err) } else { forecastTrackerSvc.candidate = candidate + slog.Info("forecast pipeline configured", "primary", "energyplan", "shadow", "legacy", "policy", forecastPipelinePolicy) } } if err := forecastTrackerSvc.Start(ctx); err != nil { diff --git a/go/internal/energyforecast/client.go b/go/internal/energyforecast/client.go index d334c312..bb690057 100644 --- a/go/internal/energyforecast/client.go +++ b/go/internal/energyforecast/client.go @@ -45,7 +45,7 @@ func (c *Client) Update(ctx context.Context, request UpdateRequest) (UpdateReply if err := validateInterval(o.Interval); err != nil { return reply, fmt.Errorf("observation %d: %w", i, err) } - if o.ValidEndMs-o.ValidStartMs != 900000 { + if o.ValidEndMs-o.ValidStartMs != 900000 || o.ValidStartMs%900000 != 0 { return reply, errors.New("forecast observation must cover a complete quarter-hour") } if i > 0 && o.ValidStartMs < previousEnd { @@ -320,7 +320,7 @@ func validateState(state json.RawMessage, required bool) error { } func validateInterval(i Interval) error { - if i.ValidStartMs < 0 || i.ValidEndMs <= i.ValidStartMs || i.ValidEndMs-i.ValidStartMs != 900000 || i.ValidStartMs%900000 != 0 { + if i.ValidStartMs < 0 || i.ValidEndMs <= i.ValidStartMs || i.ValidEndMs-i.ValidStartMs > 900000 || i.ValidStartMs/900000 != (i.ValidEndMs-1)/900000 { return errors.New("invalid forecast interval") } return nil diff --git a/go/internal/energyforecast/client_test.go b/go/internal/energyforecast/client_test.go index f0856629..40e5bdaa 100644 --- a/go/internal/energyforecast/client_test.go +++ b/go/internal/energyforecast/client_test.go @@ -282,3 +282,43 @@ func TestClientBoundsAndTimeout(t *testing.T) { } }) } + +func TestClientPredictionAcceptsOnlyCausalQuarterPortions(t *testing.T) { + for _, tc := range []struct { + name string + startDelta, endDelta int64 + valid bool + }{ + {"remainder", 7 * 60000, 900000, true}, + {"millisecond remainder", 899999, 900000, true}, + {"future portion", 900000 + 120000, 1800000, true}, + {"before origin", 0, 900000, false}, + {"crosses quarter", 7 * 60000, 900001, false}, + {"longer than quarter", 7 * 60000, 1800000, false}, + {"empty", 900000, 900000, false}, + } { + t.Run(tc.name, func(t *testing.T) { + r := predictionRequest() + start := r.OriginMs + r.OriginMs += 7 * 60000 + r.Horizon[0].Interval = Interval{start + tc.startDelta, start + tc.endDelta} + _, err := replying(nil).Predict(context.Background(), r) + if (err == nil) != tc.valid { + t.Fatalf("valid=%v err=%v", tc.valid, err) + } + }) + } +} + +func TestClientNeverTrainsOnPartialObservation(t *testing.T) { + r := updateRequest() + r.Observations[0].ValidStartMs += 7 * 60000 + called := false + c := NewClient(exchangeFunc(func(context.Context, []byte) ([]byte, error) { + called = true + return nil, nil + })) + if _, err := c.Update(context.Background(), r); err == nil || called { + t.Fatal("partial observation reached training worker") + } +} diff --git a/go/internal/energyforecast/types.go b/go/internal/energyforecast/types.go index 9d58ae48..870e9196 100644 --- a/go/internal/energyforecast/types.go +++ b/go/internal/energyforecast/types.go @@ -41,13 +41,16 @@ type RequestContext struct { State json.RawMessage `json:"state,omitempty"` } +// Interval is a full UTC quarter for observations. Predictions may cover a +// future portion within one UTC quarter, including the remainder after origin. type Interval struct { ValidStartMs int64 `json:"valid_start_ms"` ValidEndMs int64 `json:"valid_end_ms"` } // Features describe the civil schedule and the weather available at origin. -// LocalDay counts civil dates since 1970; Monday is weekday zero. +// LocalDay counts civil dates since 1970; Monday is weekday zero. Calendar +// features describe the containing quarter, including for partial predictions. type Features struct { LocalDay int64 `json:"local_day"` LocalWeekday int `json:"local_weekday"` diff --git a/go/internal/forecasting/contract.go b/go/internal/forecasting/contract.go index 8cf9cce7..28b20c5e 100644 --- a/go/internal/forecasting/contract.go +++ b/go/internal/forecasting/contract.go @@ -49,20 +49,27 @@ type ModelEstimateEvidence struct { // Point contains interval mean power in W. PV is available AC generation, // positive here; Load excludes independently planned EV and battery flows. // Net load is LoadW-PVW. This contract never contains hardware commands. +// PredictionStartMS is set when watts describe only the remaining part of a +// planner interval. Such points are excluded from full-interval evaluation. type Point struct { - StartMS int64 `json:"valid_start_ms"` - EndMS int64 `json:"valid_end_ms"` - PVW float64 `json:"pv_available_w"` - LoadW float64 `json:"household_load_w"` - PVKnown bool `json:"pv_known"` - LoadKnown bool `json:"load_known"` - PVQuality string `json:"pv_quality"` - LoadQuality string `json:"load_quality"` - PVBand Band `json:"pv_band"` - LoadBand Band `json:"load_band"` - NetBand Band `json:"net_band"` - ModelPV *ModelEstimateEvidence `json:"model_pv,omitempty"` - ModelLoad *ModelEstimateEvidence `json:"model_load,omitempty"` + PredictionStartMS int64 `json:"prediction_start_ms,omitempty"` + StartMS int64 `json:"valid_start_ms"` + EndMS int64 `json:"valid_end_ms"` + PVW float64 `json:"pv_available_w"` + LoadW float64 `json:"household_load_w"` + PVKnown bool `json:"pv_known"` + LoadKnown bool `json:"load_known"` + PVQuality string `json:"pv_quality"` + LoadQuality string `json:"load_quality"` + // Sources identify the selected model per signal, including fallback. + // Empty sources remain valid for archives written before provenance existed. + PVSource string `json:"pv_source,omitempty"` + LoadSource string `json:"load_source,omitempty"` + PVBand Band `json:"pv_band"` + LoadBand Band `json:"load_band"` + NetBand Band `json:"net_band"` + ModelPV *ModelEstimateEvidence `json:"model_pv,omitempty"` + ModelLoad *ModelEstimateEvidence `json:"model_load,omitempty"` } type Series struct { @@ -195,8 +202,10 @@ func validBand(b Band) bool { func validPoint(p Point) bool { return validInterval(p.StartMS, p.EndMS) && + (p.PredictionStartMS == 0 || (p.PredictionStartMS > p.StartMS && p.PredictionStartMS < p.EndMS)) && finite(p.PVW) && finite(p.LoadW) && p.PVW >= 0 && p.LoadW >= 0 && p.PVQuality != "" && p.LoadQuality != "" && + len(p.PVSource) <= 80 && len(p.LoadSource) <= 80 && validBand(p.PVBand) && validBand(p.LoadBand) && validBand(p.NetBand) && validModelEstimate(p.ModelPV) && validModelEstimate(p.ModelLoad) } @@ -232,7 +241,7 @@ func (r Issue) Validate() error { names[s.Name] = true var end int64 for _, p := range s.Points { - if !validPoint(p) || p.StartMS < end { + if !validPoint(p) || p.StartMS < end || (p.PredictionStartMS != 0 && p.PredictionStartMS < r.OriginMS) { return fmt.Errorf("invalid interval in %s", s.Name) } end = p.EndMS diff --git a/go/internal/forecasting/evaluate.go b/go/internal/forecasting/evaluate.go index 1d4ee806..13eeef59 100644 --- a/go/internal/forecasting/evaluate.go +++ b/go/internal/forecasting/evaluate.go @@ -55,7 +55,7 @@ func (e ErrorSample) Validate() error { e.IssueID == "" || len(e.IssueID) > 128 || e.OriginMS <= 0 || e.IssuedAtMS < e.OriginMS || e.IssuedAtMS > e.StartMS || !validInterval(e.StartMS, e.EndMS) || e.AvailableAtMS < e.EndMS || e.Lead != LeadBucket(e.OriginMS, e.StartMS) || !finite(e.PVErrorW) || !finite(e.LoadErrorW) || - !validPoint(e.Prediction) || e.Prediction.StartMS != e.StartMS || e.Prediction.EndMS != e.EndMS { + !validPoint(e.Prediction) || e.Prediction.PredictionStartMS != 0 || e.Prediction.StartMS != e.StartMS || e.Prediction.EndMS != e.EndMS { return errors.New("invalid forecast error sample") } return nil @@ -156,7 +156,9 @@ func scoreAll(issues []Issue, observations []Observation, asOf int64) []ErrorSam } for _, series := range issue.Series { for _, p := range series.Points { - if p.StartMS < issue.IssuedAtMS || p.EndMS > asOf { + // A remaining-interval mean cannot be scored against whole-interval + // truth, even if an imported issue has an earlier origin or receipt. + if p.PredictionStartMS != 0 || p.StartMS < issue.IssuedAtMS || p.EndMS > asOf { continue } coverage, ok := coverPoint(index, issue.ConfigVersion, p) @@ -663,6 +665,8 @@ func CumulativeMetrics(samples []CumulativeEnergySample) []CumulativeMetric { return out } +// PairMetric retains its original JSON names. Champion and Candidate identify +// the selected series, not fixed model implementations or promotion status. type PairMetric struct { Champion string `json:"champion"` Candidate string `json:"candidate"` @@ -691,6 +695,17 @@ func sameActual(a, b ErrorSample, signal string) bool { // CompareSeries scores champion and candidate only on common targets with the // same config and lead bucket. Mismatched outcomes are excluded. func CompareSeries(samples []ErrorSample, champion, candidate string) []PairMetric { + return compareSeries(samples, champion, candidate, false) +} + +// CompareFrozenSeries compares the primary with a shadow captured in the same +// issue. A newer primary without a matching shadow is omitted, never compared +// with a shadow made from older inputs. Series names carry no model assumption. +func CompareFrozenSeries(samples []ErrorSample, primary, shadow string) []PairMetric { + return compareSeries(samples, primary, shadow, true) +} + +func compareSeries(samples []ErrorSample, champion, candidate string, sameIssue bool) []PairMetric { type targetKey struct { config string start, end int64 @@ -722,6 +737,10 @@ func CompareSeries(samples []ErrorSample, champion, candidate string) []PairMetr if !ok { continue } + if sameIssue && (championSample.IssueID != candidateSample.IssueID || + championSample.OriginMS != candidateSample.OriginMS || championSample.IssuedAtMS != candidateSample.IssuedAtMS) { + continue + } for _, signal := range []string{"pv", "pv_daylight", "load", "net"} { if !sameActual(championSample, candidateSample, signal) { continue diff --git a/go/internal/forecasting/partial_evaluation_test.go b/go/internal/forecasting/partial_evaluation_test.go new file mode 100644 index 00000000..c6892658 --- /dev/null +++ b/go/internal/forecasting/partial_evaluation_test.go @@ -0,0 +1,80 @@ +package forecasting + +import ( + "testing" + "time" +) + +func TestRemainingIntervalNeverEarnsHeldOutOrCumulativeScore(t *testing.T) { + start := time.Date(2026, 9, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + points := make([]Point, 24) + truth := make([]Observation, len(points)) + for i := range points { + at := start + int64(i)*hourMS + points[i] = testPoint(at, at+hourMS, 100, 1000) + truth[i] = testObservation("cfg", at, at+hourMS, 100, 1000) + } + // Deliberately old origin/receipt: the explicit partial marker must protect + // held-out scores even when the ordinary timestamp guard would accept it. + points[0].PredictionStartMS = start + 10*60*1000 + issue := testIssue("remaining", "cfg", "champion", start-hourMS, start-hourMS, points) + for _, name := range []string{"planning", "legacy_shadow", "energyplan", "last_day", "last_week", "persistence", "generic"} { + issue.Series = append(issue.Series, Series{Name: name, ModelVersion: "v1", Points: append([]Point(nil), points...)}) + } + if err := issue.Validate(); err != nil { + t.Fatal(err) + } + errors := Errors([]Issue{issue}, truth, start+24*hourMS) + if len(errors) != 23*MaxSeries { + t.Fatalf("full future intervals lost or partial included: %d", len(errors)) + } + for _, e := range errors { + if e.StartMS == start { + t.Fatalf("partial received whole-hour score: %+v", e) + } + } + for _, m := range CompareFrozenSeries(errors, "champion", "legacy_shadow") { + if m.Samples == 0 { + t.Fatal("future whole intervals should still compare") + } + } + cumulative := CumulativeNetEnergy([]Issue{issue}, truth, start+24*hourMS) + if len(cumulative) == 0 { + t.Fatal("remaining whole-hour windows must still score") + } + for _, sample := range cumulative { + if sample.StartMS == start || sample.Hours == 24 { + t.Fatalf("cumulative window included partial forecast: %+v", sample) + } + } +} + +func TestImportedPartialErrorsCannotCalibrateOrCompare(t *testing.T) { + base := time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC).UnixMilli() + var full, partial []ErrorSample + for day := 0; day < 7; day++ { + for hour := 0; hour < 8; hour++ { + start := base + int64(day*24+hour)*hourMS + e := testError("champion", "cfg", "capture", float64(start), float64(start-2*hourMS), 100, 100) + full = append(full, e) + e.Prediction.PredictionStartMS = start + 60000 + partial = append(partial, e) + shadow := e + shadow.Series = "legacy_shadow" + partial = append(partial, shadow) + } + } + origin := base + 8*24*hourMS + if b := NewCalibrator(full, "cfg", origin).Band("champion", "pv", origin+2*hourMS, 500); b.Method != BandMethodEmpirical { + t.Fatalf("fixture lacks full calibration coverage: %+v", b) + } + if err := partial[0].Validate(); err == nil { + t.Fatal("partial error was accepted for archive/calibration") + } + if b := NewCalibrator(partial, "cfg", origin).Band("champion", "pv", origin+2*hourMS, 500); b.Method != BandMethodColdStart || b.Samples != 0 { + t.Fatalf("imported partial errors earned empirical confidence: %+v", b) + } + if len(Metrics(partial)) != 0 || len(CompareSeries(partial, "champion", "legacy_shadow")) != 0 || len(CompareFrozenSeries(partial, "champion", "legacy_shadow")) != 0 { + t.Fatal("imported partial errors produced held-out metrics") + } +} diff --git a/go/internal/forecasting/partial_test.go b/go/internal/forecasting/partial_test.go new file mode 100644 index 00000000..e0bbad59 --- /dev/null +++ b/go/internal/forecasting/partial_test.go @@ -0,0 +1,43 @@ +package forecasting + +import ( + "encoding/json" + "testing" + "time" +) + +func TestIssueBoundsPartialPredictionSupport(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + origin := start + 7*60000 + for _, tc := range []struct { + name string + predictionStart int64 + valid bool + }{ + {"remainder", origin, true}, + {"legacy record", 0, true}, + {"negative", -1, false}, + {"before slot", start - 1, false}, + {"same as slot", start, false}, + {"before origin", origin - 1, false}, + {"at end", start + 900000, false}, + {"after end", start + 900001, false}, + } { + t.Run(tc.name, func(t *testing.T) { + point := testPoint(start, start+900000, 1000, 500) + point.PredictionStartMS = tc.predictionStart + issue := testIssue("i", "cfg", "champion", origin, origin, []Point{point}) + if err := issue.Validate(); (err == nil) != tc.valid { + t.Fatalf("valid=%v err=%v", tc.valid, err) + } + data, err := json.Marshal(issue) + if err != nil { + t.Fatal(err) + } + var decoded Issue + if err = json.Unmarshal(data, &decoded); err != nil || decoded.Series[0].Points[0].PredictionStartMS != tc.predictionStart { + t.Fatal("partial provenance lost on archive roundtrip") + } + }) + } +} diff --git a/go/internal/forecasting/primary_test.go b/go/internal/forecasting/primary_test.go new file mode 100644 index 00000000..1b4e4045 --- /dev/null +++ b/go/internal/forecasting/primary_test.go @@ -0,0 +1,100 @@ +package forecasting + +import ( + "encoding/json" + "strings" + "testing" + "time" +) + +func TestPrimarySourcesRoundTripWithoutChangingKnownOrQuality(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + p := testPoint(start, start+hourMS, 0, 600) + p.PVSource, p.LoadSource = "energyplan", "legacy" + p.PVQuality, p.LoadQuality = "cold_start", "cold_start" + issue := testIssue("mixed", "cfg", "champion", start-hourMS, start-hourMS, []Point{p}) + raw, err := json.Marshal(issue) + if err != nil { + t.Fatal(err) + } + var restored Issue + if err := json.Unmarshal(raw, &restored); err != nil || restored.Validate() != nil { + t.Fatalf("mixed primary did not survive archive: %v, %+v", err, restored) + } + if restored.Series[0].Points[0] != p { + t.Fatalf("source or cold-start quality changed: %+v", restored.Series[0].Points[0]) + } + for _, field := range []string{"pv", "load"} { + bad := p + if field == "pv" { + bad.PVSource = strings.Repeat("x", 81) + } else { + bad.LoadSource = strings.Repeat("x", 81) + } + if validPoint(bad) { + t.Fatalf("unbounded %s source accepted", field) + } + } + p.PVSource, p.LoadSource = "", "" + if !validPoint(p) { + t.Fatal("historical record without source rejected") + } +} + +func TestFrozenComparisonScoresMixedPrimaryAndKnownColdZero(t *testing.T) { + start := time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli() + primary := testPoint(start, start+hourMS, 0, 600) + primary.PVSource, primary.LoadSource = "energyplan", "legacy" + primary.PVQuality, primary.LoadQuality = "cold_start", "cold_start" + shadow := testPoint(start, start+hourMS, 500, 600) + shadow.PVSource, shadow.LoadSource = "legacy", "legacy" + issue := testIssue("mixed", "cfg", "champion", start-hourMS, start-hourMS, []Point{primary}) + issue.Series = append(issue.Series, Series{Name: "legacy_shadow", ModelVersion: "v1", Points: []Point{shadow}}) + truth := testObservation("cfg", start, start+hourMS, 0, 800) + samples := Errors([]Issue{issue}, []Observation{truth}, start+hourMS) + metrics := CompareFrozenSeries(samples, "champion", "legacy_shadow") + if len(metrics) != 3 { + t.Fatalf("known cold-start zero or default load lost: %+v", metrics) + } + for _, m := range metrics { + if m.Signal == "pv" && (m.ChampionMAEW != 0 || m.CandidateMAEW != 500 || m.DeltaMAEW != 500) { + t.Fatalf("primary/shadow roles reversed: %+v", m) + } + if m.Signal == "load" && (m.ChampionMAEW != 200 || m.CandidateMAEW != 200 || m.CandidateWinRate != .5) { + t.Fatalf("shared legacy load fallback must tie: %+v", m) + } + } + issue.Series[0].Points[0].PVKnown = false + issue.Series[0].Points[0].PVQuality = "unknown" + metrics = CompareFrozenSeries(Errors([]Issue{issue}, []Observation{truth}, start+hourMS), "champion", "legacy_shadow") + if len(metrics) != 1 || metrics[0].Signal != "load" { + t.Fatalf("unknown numeric zero was scored as available PV: %+v", metrics) + } +} + +func TestFrozenComparisonRejectsUnmatchedCapture(t *testing.T) { + start := float64(time.Date(2026, 9, 7, 12, 0, 0, 0, time.UTC).UnixMilli()) + primary := testError("champion", "cfg", "capture", start, start-2*float64(hourMS), 100, 100) + shadow := primary + shadow.Series = "legacy_shadow" + for name, change := range map[string]func(*ErrorSample){ + "different issue": func(e *ErrorSample) { e.IssueID = "other" }, + "different origin": func(e *ErrorSample) { e.OriginMS-- }, + "different receipt": func(e *ErrorSample) { e.IssuedAtMS++ }, + "different site config": func(e *ErrorSample) { e.ConfigVersion = "new" }, + } { + t.Run(name, func(t *testing.T) { + other := shadow + change(&other) + if got := CompareFrozenSeries([]ErrorSample{primary, other}, "champion", "legacy_shadow"); len(got) != 0 { + t.Fatalf("unmatched captures produced comparison: %+v", got) + } + }) + } + newer := primary + newer.OriginMS, newer.IssuedAtMS = primary.OriginMS+1, primary.IssuedAtMS+1 + newer.IssueID = "newer" + if got := CompareFrozenSeries([]ErrorSample{primary, shadow, newer}, "champion", "legacy_shadow"); len(got) != 0 { + t.Fatalf("new primary paired with stale shadow: %+v", got) + } +} diff --git a/go/internal/mpc/forecast_primary_test.go b/go/internal/mpc/forecast_primary_test.go new file mode 100644 index 00000000..2c91db4b --- /dev/null +++ b/go/internal/mpc/forecast_primary_test.go @@ -0,0 +1,136 @@ +package mpc + +import ( + "context" + "encoding/json" + "sync/atomic" + "testing" + "time" + + "github.com/srcfl/ftw/go/internal/state" +) + +func TestNativePrimaryForecastReachesSolverBeforeRisk(t *testing.T) { + worker := nativeWorker(t, 500*time.Millisecond) + t.Cleanup(func() { _ = worker.Close() }) + svc := shadowTestService(t) + t.Cleanup(func() { svc.replanWG.Wait(); svc.shadowWG.Wait() }) + svc.Optimizer = &EnergyplanOptimizer{ExternalOptimizer: worker} + svc.PVForecastSafetyK = 1 + var legacy, archivedBase, archivedPlanning []Slot + svc.ForecastSnapshot = func(time.Time, []state.ForecastPoint) ForecastInputs { + return ForecastInputs{ + Resolve: func(ctx context.Context, slots []Slot) []Slot { + if _, bounded := ctx.Deadline(); !bounded { + t.Error("forecast resolution has no deadline") + } + legacy = append([]Slot(nil), slots...) + for i := range slots { + slots[i].PVW, slots[i].LoadW = -2400, 700 + // Selection cannot change market data or hardware limits. + slots[i].PriceOre = -9999 + } + return slots + }, + Risk: func(base, planning []Slot, _ float64) { + for i := range base { + if base[i].PVW != -2400 || base[i].LoadW != 700 { + t.Errorf("risk received legacy forecast: %+v", base[i]) + } + planning[i].PVW, planning[i].LoadW = -2000, 800 + } + }, + Record: func(base, planning []Slot, decisionID string, issuedAtMS int64) { + if decisionID == "" || issuedAtMS <= 0 { + t.Error("forecast archived before a plan was published") + } + archivedBase = append([]Slot(nil), base...) + archivedPlanning = append([]Slot(nil), planning...) + }, + } + } + plan := svc.Replan(context.Background()) + if plan == nil || plan.Solver == nil || plan.Solver.Fallback { + t.Fatalf("native primary plan missing: %+v", plan) + } + var input externalRequest + if err := json.Unmarshal(plan.OptimizerInput, &input); err != nil { + t.Fatal(err) + } + if len(input.Slots) == 0 || len(input.Slots) != len(archivedBase) || len(input.Slots) != len(legacy) { + t.Fatal("forecast or archive lost the planner horizon") + } + for i, slot := range input.Slots { + if slot.PVW != -2000 || slot.LoadW != 800 { + t.Fatalf("solver did not receive primary downside: %+v", slot) + } + if legacy[i].LoadW != 500 || archivedBase[i].LoadW != 700 || archivedBase[i].PVW != -2400 { + t.Fatalf("point forecast and legacy shadow were conflated: %+v / %+v", legacy[i], archivedBase[i]) + } + if archivedPlanning[i].LoadW != slot.LoadW || archivedPlanning[i].PVW != slot.PVW { + t.Fatal("planning archive differs from actual solver input") + } + if archivedBase[i].PriceOre != legacy[i].PriceOre { + t.Fatal("forecast selection changed prices") + } + } + if svc.plannedPredictions != nil { + t.Fatal("legacy shadow controls the primary drift trigger") + } +} + +func TestPrimaryForecastDoesNotLockDispatchAndCancelsSupersededWork(t *testing.T) { + svc := shadowTestService(t) + t.Cleanup(func() { svc.replanWG.Wait(); svc.shadowWG.Wait() }) + started, canceled := make(chan struct{}), make(chan struct{}) + var calls atomic.Int32 + svc.ForecastSnapshot = func(time.Time, []state.ForecastPoint) ForecastInputs { + return ForecastInputs{Resolve: func(ctx context.Context, slots []Slot) []Slot { + if calls.Add(1) == 1 { + close(started) + <-ctx.Done() + close(canceled) + for i := range slots { + slots[i].LoadW = 9999 + } + } else { + for i := range slots { + slots[i].LoadW = 650 + } + } + return slots + }} + } + svc.RequestReplan("old") + select { + case <-started: + case <-time.After(time.Second): + t.Fatal("primary forecast did not start") + } + readDone := make(chan struct{}) + go func() { + _ = svc.Latest() + svc.RequestReplan("new") + close(readDone) + }() + select { + case <-readDone: + case <-time.After(500 * time.Millisecond): + t.Fatal("forecast resolution holds the service lock") + } + select { + case <-canceled: + case <-time.After(time.Second): + t.Fatal("superseded forecast did not receive cancellation") + } + waitFor(t, "new primary plan", func() bool { return svc.Latest() != nil && !svc.IsReplanning() }) + d := svc.Diagnose() + if d == nil || len(svc.lastSlots) == 0 { + t.Fatal("new primary plan was not published") + } + for _, slot := range svc.lastSlots { + if slot.LoadW != 650 { + t.Fatalf("superseded forecast reached active plan: %+v", slot) + } + } +} diff --git a/go/internal/mpc/forecast_snapshot.go b/go/internal/mpc/forecast_snapshot.go index b0449cab..db3a296b 100644 --- a/go/internal/mpc/forecast_snapshot.go +++ b/go/internal/mpc/forecast_snapshot.go @@ -1,6 +1,7 @@ package mpc import ( + "context" "time" "github.com/srcfl/ftw/go/internal/state" @@ -16,6 +17,10 @@ type ForecastInputs struct { PVWeight func(time.Time) float64 PVUncertaintyW float64 PVRelativeUncertainty float64 + // Resolve selects primary forecasts for the complete price horizon. It runs + // once during replanning, outside the service lock, under a bounded context. + // Only PVW and LoadW may change; the host retains a frozen legacy shadow. + Resolve func(context.Context, []Slot) []Slot // Risk may replace the legacy PV margin using calibrated joint net errors. // It must preserve slot times/prices/limits and never add forecast PV. Risk func(base, planning []Slot, k float64) diff --git a/go/internal/mpc/service.go b/go/internal/mpc/service.go index 976fa21f..673583e6 100644 --- a/go/internal/mpc/service.go +++ b/go/internal/mpc/service.go @@ -1389,6 +1389,33 @@ func (s *Service) runReplan(request replanRequest) *Plan { } } slots := buildSlots(prices, forecasts, s.BaseLoad, now.UnixMilli(), pv, correct, load, captured.PVWeight) + // Resolve receives the complete legacy forecast, including verified limits, + // so its frozen shadow matches what the previous pipeline would have used. + slots = capSlotsPVToNameplate(slots, s.PVNameplateW) + slots = capSlotsLoad(slots, 0, s.LoadMaxW) + if captured.Resolve != nil && len(slots) > 0 { + if request.wasCanceledByService() { + return s.canceledReplan(request, "forecast-start") + } + forecastCtx, cancelForecast := context.WithTimeout(ctx, 2*time.Second) + resolved := captured.Resolve(forecastCtx, append([]Slot(nil), slots...)) + cancelForecast() + if request.wasCanceledByService() { + return s.canceledReplan(request, "forecast-resolve") + } + if len(resolved) != len(slots) { + slog.Error("mpc: forecast changed horizon length; keeping previous plan") + return s.Latest() + } + for i := range slots { + if resolved[i].StartMs != slots[i].StartMs || resolved[i].LenMin != slots[i].LenMin { + slog.Error("mpc: forecast changed interval; keeping previous plan", "slot", i) + return s.Latest() + } + // Forecast selection cannot replace market data or physical limits. + slots[i].PVW, slots[i].LoadW = resolved[i].PVW, resolved[i].LoadW + } + } slots = capSlotsPVToNameplate(slots, s.PVNameplateW) slots = capSlotsLoad(slots, 0, s.LoadMaxW) // Qualified load models own their level. Unqualified historic daily @@ -1473,6 +1500,9 @@ func (s *Service) runReplan(request replanRequest) *Plan { if captured.Risk != nil { captured.Risk(slots, fallbackSlots, p.PVForecastSafetyK) } + // Keep the point forecast distinct from the downside inputs passed to the + // solver. Calibrating point errors against the risk adjustment biases them. + baseForecastSlots := append([]Slot(nil), slots...) // Default terminal valuation. Mode-dependent because self-consumption // is a constrained game: the battery can only offset local load, not @@ -1736,7 +1766,12 @@ func (s *Service) runReplan(request replanRequest) *Plan { // timestamps buildSlots used. forecasts cloud lookup mirrors the // path buildSlots takes for the PV predictor so the snapshot is // apples-to-apples with what's re-sampled later. - pp := s.snapshotPredictions(slots, forecasts, pv, load) + var pp *plannedPredictions + if captured.Resolve == nil { + pp = s.snapshotPredictions(slots, forecasts, pv, load) + } + // The legacy shadow must not trigger drift replans for a primary forecast + // it did not produce. Scheduled and live-power replan triggers still apply. s.mu.Lock() if s.stopping || request.wasCanceledByService() { @@ -1769,7 +1804,7 @@ func (s *Service) runReplan(request replanRequest) *Plan { saveDiag := s.SaveDiag s.mu.Unlock() if captured.Record != nil { - captured.Record(slots, fallbackSlots, plan.DecisionID, replanAtMs) + captured.Record(baseForecastSlots, fallbackSlots, plan.DecisionID, replanAtMs) } // Horizon statistics — surfaced in logs so operators can // reconstruct "what did the DP know?" without pulling the full diff --git a/optimizer/native/README.md b/optimizer/native/README.md index 28a0da72..0641fce8 100644 --- a/optimizer/native/README.md +++ b/optimizer/native/README.md @@ -58,19 +58,46 @@ through its existing fallback path. can also use an absolute path supplied in `FTW_NATIVE_SOLVER`. Ordinary Go tests skip these optional process tests when that variable is unset. -## Forecast candidates and evaluation - -Energyplan 0.2.0 also accepts forecasting protocol v1. The public request and -response schemas are in `bundle/forecast-v1.schema.json` and -`bundle/forecast-v1.response.schema.json`. Core runs a separate local process -with a 2 s deadline for each model update and prediction. Forecast failure -does not replace the active planner inputs. These PV and load models gather -evidence as candidates; Core does not promote them automatically. - -PV requires the site's location and qualified PV measurements, but no panel -angles or rated power. Core saves each issued horizon with its available -weather, occupancy, model state and site binding in a bounded local archive. -Measured errors calibrate forecast intervals by horizon. The worker's own +## Forecast primary, fallback and evaluation + +A verified worker that advertises forecasting protocol v1 supplies the primary +PV and household-load forecast. The public request and response schemas are in +`bundle/forecast-v1.schema.json` and `bundle/forecast-v1.response.schema.json`. +Core calls a separate local worker with a 2 s deadline for each model update +and prediction. Prediction runs during replanning, outside the control and +dispatch locks. + +One replan freezes the legacy forecast, weather, occupancy and model state +before it calls the worker. The returned PV and load values must match that +capture and cover the planner interval. Core selects each signal separately: +a valid Energyplan PV value can run with legacy load, or a valid Energyplan load +value can run with legacy PV. A missing, late, partial or invalid value falls +back to the matching legacy signal for that slot. The `champion` archive series +records the values used by the planner and names each signal's source. The +`legacy_shadow` series records the unchanged legacy forecast from the same +capture. Forecast work can change planner inputs, but it never sends a hardware +command; Core still validates the resulting plan before dispatch. + +PV learning requires the site's location and qualified PV measurements, but no +panel angles or rated power. Core forms qualified PV and household-load labels +from complete 15-minute measurements. It excludes missing or unsafe evidence, +including PV intervals affected by commanded curtailment. Model updates run +outside dispatch and do not alter an issued forecast. + +The latest Energyplan forecast state is stored locally in SQLite under +`forecast/energyplan_state_v1`. Core saves the complete update atomically before +it exposes the new state to planning, then loads it on restart. A change to the +model input configuration or stable hardware binding starts a new learning +revision and an empty model. A compatible Core or worker program upgrade keeps +the learning revision and can reuse the saved state. The issued-forecast +revision still records the exact Core version, worker bytes and pipeline policy, +so evaluation does not join results from different program builds. + +Core saves each issued horizon with the same frozen weather, occupancy, model +state and site binding in a bounded 30-day local archive. Large model snapshots +are stored once by content hash and referenced by each issue. Row counts, +expanded sizes and compressed storage all have hard limits. Measured errors +calibrate forecast intervals by horizon and interval length. The worker's own provisional ranges remain distinct from calibrated intervals. To score an archive, run this from `go/`, preferably against a box backup: @@ -80,12 +107,13 @@ go run ./cmd/ftw-forecast-evaluate -state /path/to/state.db ``` The command opens SQLite read-only and writes JSON. Optional `-since` and -`-until` take RFC3339 timestamps within a 30-day window. The report compares -issued forecasts on matched outcomes, includes daylight PV errors and net -energy errors over 1/3/6/12/24 hours, and separates measured interval coverage -from cold-start and provisional ranges. Missing history cannot yield an -accuracy or savings claim. This command is a source tool; release archives -do not include a separate evaluation executable. +`-until` take RFC3339 timestamps within a 30-day window. By default it compares +`champion` with `legacy_shadow` only where both came from the same frozen issue +and have the same truth. The report includes per-lead PV, load and net errors, +daylight PV errors, net energy errors over 1/3/6/12/24 hours, measured interval +coverage, and separate cold-start and provisional ranges. Missing, late or +censored truth cannot yield an accuracy or savings claim. This command is a +source tool; release archives do not include a separate evaluation executable. `make native-solver-test` exercises both protocols and the Go forecast adapter against the bundled host worker. Direct Go forecast tests use @@ -94,7 +122,11 @@ against the bundled host worker. Direct Go forecast tests use ## Update the bundle Build and test a new version in the private repository. Copy only the complete -output of its binary packaging tool into `bundle/`, then run +output of its binary packaging tool into `bundle/`. Before changing the pin, +verify that every target has the same declared worker version and forecast +protocol, and that the manifest pins the source commit, size and SHA-256 of each +binary. The integration checks must cover a partly elapsed first forecast +interval and a fresh model with no saved state. Then run `make native-solver-test` and `make verify`. Submit the binaries, manifest, license and notices together. Never add Rust source, Cargo files, source archives or build tools to this public directory. From b198044ccb891b9765adf9663a6233c9c3c3635a Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Mon, 7 Sep 2026 13:31:40 +0200 Subject: [PATCH 3/4] ci: exercise native forecasting when its adapter changes Signed-off-by: Fredrik Ahlgren --- .github/workflows/native-solver.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/native-solver.yml b/.github/workflows/native-solver.yml index 1c3530c0..bc766673 100644 --- a/.github/workflows/native-solver.yml +++ b/.github/workflows/native-solver.yml @@ -5,6 +5,9 @@ on: paths: - 'optimizer/native/**' - 'go/internal/mpc/**' + - 'go/internal/energyforecast/**' + - 'go/cmd/ftw/forecast*.go' + - 'go/cmd/ftw/main.go' - 'Makefile' - '.github/workflows/native-solver.yml' push: @@ -12,6 +15,9 @@ on: paths: - 'optimizer/native/**' - 'go/internal/mpc/**' + - 'go/internal/energyforecast/**' + - 'go/cmd/ftw/forecast*.go' + - 'go/cmd/ftw/main.go' - 'Makefile' - '.github/workflows/native-solver.yml' From 9475683c4e2c133aef7982af447c11cd6b3b7c08 Mon Sep 17 00:00:00 2001 From: Fredrik Ahlgren Date: Mon, 7 Sep 2026 13:39:58 +0200 Subject: [PATCH 4/4] build: bundle Energyplan 0.2.1 for primary forecasts Signed-off-by: Fredrik Ahlgren --- go/internal/mpc/energyplan_test.go | 2 +- .../bundle/forecast-v1.response.schema.json | 53 ++++++++++++++++-- .../native/bundle/forecast-v1.schema.json | 14 ++--- .../native/bundle/ftw-solver-darwin-arm64 | Bin 792016 -> 825040 bytes .../native/bundle/ftw-solver-linux-amd64 | Bin 1025672 -> 1035304 bytes .../native/bundle/ftw-solver-linux-arm64 | Bin 859240 -> 867432 bytes optimizer/native/bundle/manifest.json | 24 ++++---- 7 files changed, 66 insertions(+), 27 deletions(-) diff --git a/go/internal/mpc/energyplan_test.go b/go/internal/mpc/energyplan_test.go index 2020e0d8..e6844cfe 100644 --- a/go/internal/mpc/energyplan_test.go +++ b/go/internal/mpc/energyplan_test.go @@ -60,7 +60,7 @@ func TestNativeEnergyplanDownsideAndAsyncShadow(t *testing.T) { svc := shadowTestService(t) svc.Optimizer = &EnergyplanOptimizer{ExternalOptimizer: o} info, err := svc.Optimizer.(*EnergyplanOptimizer).Health(context.Background()) - if err != nil || info.Name != "ftw-solver" || info.Version != "0.2.0" { + if err != nil || info.Name != "ftw-solver" || info.Version != "0.2.1" { t.Fatalf("bundled worker health: %+v %v", info, err) } start := time.Now().UTC().Truncate(time.Hour) diff --git a/optimizer/native/bundle/forecast-v1.response.schema.json b/optimizer/native/bundle/forecast-v1.response.schema.json index 5d42146b..a8370357 100644 --- a/optimizer/native/bundle/forecast-v1.response.schema.json +++ b/optimizer/native/bundle/forecast-v1.response.schema.json @@ -299,7 +299,7 @@ "unavailable", "provisional" ], - "description": "Provisional bands are error heuristics, not calibrated quantiles or a confidence level. Null bounds mean uncertainty is unavailable." + "description": "Provisional bands are paired error heuristics, not calibrated quantiles or a confidence level. Unavailable means both lower_w and upper_w are null." }, "coverage": { "type": "number", @@ -346,6 +346,48 @@ } } } + ], + "allOf": [ + { + "if": { + "properties": { + "uncertainty": { + "const": "unavailable" + } + } + }, + "then": { + "properties": { + "lower_w": { + "type": "null" + }, + "upper_w": { + "type": "null" + } + } + } + }, + { + "if": { + "properties": { + "uncertainty": { + "const": "provisional" + } + } + }, + "then": { + "properties": { + "lower_w": { + "type": "number", + "minimum": 0 + }, + "upper_w": { + "type": "number", + "minimum": 0 + } + } + } + } ] }, "prediction": { @@ -360,13 +402,11 @@ "properties": { "valid_start_ms": { "type": "integer", - "minimum": 0, - "multipleOf": 900000 + "minimum": 0 }, "valid_end_ms": { "type": "integer", - "minimum": 900000, - "multipleOf": 900000 + "minimum": 1 }, "pv": { "anyOf": [ @@ -390,7 +430,8 @@ ], "description": "Null when this model is disabled." } - } + }, + "description": "Power estimates over the actual requested future segment, which stays within one UTC quarter-hour. Segment energy in Wh is point_w times its actual duration in hours." } } } diff --git a/optimizer/native/bundle/forecast-v1.schema.json b/optimizer/native/bundle/forecast-v1.schema.json index 1d6fdd6c..2487b9dc 100644 --- a/optimizer/native/bundle/forecast-v1.schema.json +++ b/optimizer/native/bundle/forecast-v1.schema.json @@ -2,7 +2,7 @@ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "urn:sourceful:energyplan:forecast:1", "title": "Energyplan forecasting request v1", - "description": "One JSON object per stdin line, at most 2 MiB including the newline. The caller must split update batches by encoded byte size, not just count; a larger line terminates the worker. Update consumes complete UTC-aligned 15-minute means available by origin_ms and returns an opaque model snapshot. Predict uses an immutable snapshot and returns the same 15-minute intervals. The caller supplies site-local clock fields and aggregates quarters across time-zone or DST changes. Site/config identity, interval order, state bounds and causal availability are checked at runtime. Household load excludes EV, battery and V2X. PV denotes nonnegative available AC generation, distinct from signed planner pv_w. The caller records actual completion/issue time and persists the snapshot. See forecast-v1.response.schema.json for responses.", + "description": "One JSON object per stdin line, at most 2 MiB including the newline. The caller must split update batches by encoded byte size, not just count; a larger line terminates the worker. Update consumes complete UTC-aligned 15-minute means available by origin_ms and returns an opaque model snapshot. Predict uses an immutable snapshot. Each requested future segment lasts 1..900000 ms and stays within one UTC quarter-hour; full aligned quarters remain valid. Returned bounds are the actual requested segment. For prediction, site-local clock, weather and occupancy fields refer to the containing quarter-hour start. The caller splits longer spans at each UTC quarter boundary and handles timezone or DST changes. Site/config identity, interval order, state bounds and causal availability are checked at runtime. Household load excludes EV, battery and V2X. PV denotes nonnegative available AC generation, distinct from signed planner pv_w. The caller records actual completion/issue time and persists the snapshot. See forecast-v1.response.schema.json for responses.", "type": "object", "additionalProperties": false, "properties": { @@ -362,14 +362,12 @@ "valid_start_ms": { "type": "integer", "minimum": 0, - "maximum": 253402300799999, - "multipleOf": 900000 + "maximum": 253402300799999 }, "valid_end_ms": { "type": "integer", "minimum": 1, - "maximum": 253402300799999, - "multipleOf": 900000 + "maximum": 253402300799999 }, "ghi_w_m2": { "type": [ @@ -407,7 +405,7 @@ "type": "integer", "minimum": -1, "maximum": 3000000, - "description": "Civil date as days since local 1970-01-01, independent of UTC date." + "description": "Civil date at the containing quarter-hour start, as days since local 1970-01-01." }, "local_weekday": { "type": "integer", @@ -420,7 +418,7 @@ "minimum": 0, "maximum": 1439, "multipleOf": 15, - "description": "Minute of interval start in local civil time. The caller resolves timezone and DST." + "description": "Minute of the containing quarter-hour start in local civil time, including for a partial first segment. The caller resolves timezone and DST." }, "home": { "type": [ @@ -436,7 +434,7 @@ "local_weekday", "local_minute" ], - "description": "Exactly 900000 ms, UTC start divisible by 900000. Slots are sorted and do not overlap. Local fields describe the interval start in the site time zone." + "description": "Future segment of 1..900000 ms contained in one UTC quarter-hour: floor(valid_start_ms/900000) equals floor((valid_end_ms-1)/900000). Segments are sorted, do not overlap and start at or after origin_ms. Local clock, weather and occupancy describe the containing quarter-hour start. Duration and containment are checked at runtime." }, "identifier": { "type": "string", diff --git a/optimizer/native/bundle/ftw-solver-darwin-arm64 b/optimizer/native/bundle/ftw-solver-darwin-arm64 index 8489a664454ae9cdde1d2a0fe13faf47ccad7d38..e657e916175f213b5c0f7a332843bfb3c3a7b779 100755 GIT binary patch delta 182382 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⪼B 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

      0zg{)aI$^X{H3bXV9 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 delta 174842 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�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

      ogGBLrL|w1`-GKRDNe54miBu8%P1Ls>?v80H^%` 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

      u+sdwh3UM3nv%VQyfbxOPEBJMKj9 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 z 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ï>y1J&!7X5KWl{#-Hp9yG8O<9hZaU?#y~+&$PhudA z|6Bx!-$!Wm@_+e?{33;`;U?|>Tx2;_V@$oH8w6076cON*^rE0qN(N9?im2pzW4JB9 z!c{D0=M>@NIEzzs1+m32rwL*{7^HyaM;^R)(Xu;s%LZ-z|mh7pEYs*oEPoVA$OEc@xm!3M9vO_G$6ja%0Aw6>haDk0}@VCL!EYB=w6 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 z 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

      5G^y82Sb1 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 SnJ9*NI}h+KamC$KMfo4ggG&|w delta 245779 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 z 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�@T0C5!ER-jRISZAJ?BX4M%OLouIN|3z9)1C>Fx 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

      &HF2 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
      Um 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