gemma: pkg/controllers/gauges.go comparison

comparison pkg/controllers/gauges.go @ 3088:09d1ffce3d00

Reworked Nash-Sutcliffe calculation.

author	Sascha L. Teichmann <sascha.teichmann@intevation.de>
date	Sun, 21 Apr 2019 18:59:00 +0200
parents	cf6f595af2cb
children	813309225e35

comparison

equal deleted inserted replaced

-:014be2194bd1
+:09d1ffce3d00
 //  * Sascha L. Teichmann <sascha.teichmann@intevation.de>
 package controllers
 import (
+	"context"
 	"database/sql"
 	"encoding/csv"
 	"fmt"
 	"log"
 	"math"
 const (
 	selectPredictedObserveredSQL = `
 SELECT
 measure_date,
+date_issue,
 predicted,
 water_level
 FROM waterway.gauge_measurements
 WHERE
 fk_gauge_id = (
 		// Too late for an HTTP error code.
 		return
 	}
 }
+func parseISRS(code string) (*models.Isrs, error) {
+	isrs, err := models.IsrsFromString(code)
+	if err != nil {
+		return nil, JSONError{
+			Code:    http.StatusBadRequest,
+			Message: fmt.Sprintf("error: Invalid ISRS code: %v", err),
+		}
+	}
+	return isrs, nil
+}
+type observedPredictedValues struct {
+	when      time.Time
+	observed  float64
+	predicted common.TimedValues
+}
+func loadNashSutcliffeData(
+	ctx context.Context,
+	conn *sql.Conn,
+	gauge *models.Isrs,
+	when time.Time,
+) ([]observedPredictedValues, error) {
+	var rows *sql.Rows
+	var err error
+	if rows, err = conn.QueryContext(
+		ctx,
+		selectPredictedObserveredSQL,
+		gauge.CountryCode,
+		gauge.LoCode,
+		gauge.FairwaySection,
+		gauge.Orc,
+		gauge.Hectometre,
+		when,
+	); err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var (
+		hasCurrent bool
+		current    observedPredictedValues
+		values     []observedPredictedValues
+	)
+	for rows.Next() {
+		var (
+			measureDate time.Time
+			issueDate   time.Time
+			predicted   bool
+			value       float64
+		)
+		if err := rows.Scan(
+			&measureDate,
+			&issueDate,
+			&predicted,
+			&value,
+		); err != nil {
+			return nil, err
+		}
+		measureDate = measureDate.UTC()
+		issueDate = issueDate.UTC()
+		if hasCurrent {
+			if !current.when.Equal(measureDate) {
+				if !math.IsNaN(current.observed) {
+					values = append(values, current)
+				}
+				current = observedPredictedValues{
+					observed: math.NaN(),
+					when:     measureDate,
+				}
+			}
+		} else {
+			hasCurrent = true
+			current = observedPredictedValues{
+				observed: math.NaN(),
+				when:     measureDate,
+			}
+		}
+		if predicted {
+			current.predicted = append(
+				current.predicted,
+				common.TimedValue{When: issueDate, Value: value},
+			)
+		} else {
+			current.observed = value
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	if hasCurrent && !math.IsNaN(current.observed) {
+		values = append(values, current)
+	}
+	return values, nil
+}
 func nashSutcliffe(
 	_ interface{},
 	req *http.Request,
 	conn *sql.Conn,
 ) (jr JSONResult, err error) {
 	gauge := mux.Vars(req)["gauge"]
 	var isrs *models.Isrs
-	if isrs, err = models.IsrsFromString(gauge); err != nil {
+	if isrs, err = parseISRS(gauge); err != nil {
-		err = JSONError{
-			Code:    http.StatusBadRequest,
-			Message: fmt.Sprintf("error: Invalid ISRS code: %v", err),
-		}
 		return
 	}
 	var when time.Time
 	if w := req.FormValue("when"); w != "" {
 			return
 		}
 	} else {
 		when = time.Now()
 	}
+	when = when.UTC()
 	ctx := req.Context()
-	var rows *sql.Rows
+	var values []observedPredictedValues
-	if rows, err = conn.QueryContext(
-		ctx,
+	if values, err = loadNashSutcliffeData(ctx, conn, isrs, when); err != nil {
-		selectPredictedObserveredSQL,
+		return
-		isrs.CountryCode,
+	}
-		isrs.LoCode,
-		isrs.FairwaySection,
+	log.Printf("info: found %d value(s) for Nash Sutcliffe.\n", len(values))
-		isrs.Orc,
-		isrs.Hectometre,
-		when,
-	); err != nil {
-		return
-	}
-	defer rows.Close()
-	var measurements []common.NSMeasurement
-	invalid := common.NSMeasurement{
-		Predicted: math.NaN(),
-		Observed:  math.NaN(),
-	}
-	current := invalid
-	for rows.Next() {
-		var (
-			when      time.Time
-			predicted bool
-			value     float64
-		)
-		if err = rows.Scan(
-			&when,
-			&predicted,
-			&value,
-		); err != nil {
-			return
-		}
-		if !when.Equal(current.When) {
-			if current.Valid() {
-				measurements = append(measurements, current)
-			}
-			current = invalid
-		}
-		if predicted {
-			current.Predicted = value
-		} else {
-			current.Observed = value
-		}
-	}
-	if err = rows.Err(); err != nil {
-		return
-	}
-	if current.Valid() {
-		measurements = append(measurements, current)
-	}
 	type coeff struct {
 		Value   float64 `json:"value"`
 		Samples int     `json:"samples"`
 		Hours   int     `json:"hours"`
 	type coeffs struct {
 		When   models.ImportTime `json:"when"`
 		Coeffs []coeff           `json:"coeffs"`
 	}
+	var measurements []common.NSMeasurement
 	cs := make([]coeff, 3)
 	for i := range cs {
 		cs[i].Hours = (i + 1) * 24
+		back := when.Add(time.Duration(-cs[i].Hours) * time.Hour)
+		for j := range values {
+			if predicted, ok := values[j].predicted.Interpolate(back); ok {
+				measurements = append(measurements, common.NSMeasurement{
+					Observed:  values[i].observed,
+					Predicted: predicted,
+				})
+			}
+		}
 		cs[i].Value, cs[i].Samples = common.NashSutcliffe(
 			measurements,
 			when,
-			when.Add(time.Duration(-cs[i].Hours)*time.Hour),
+			back,
 		)
+		measurements = measurements[:0]
 	}
 	jr = JSONResult{
 		Result: &coeffs{
 			When:   models.ImportTime{when},

Mercurial > gemma

comparison pkg/controllers/gauges.go @ 3088:09d1ffce3d00