update

persistence/mongodb.go

@@ -109,6 +109,25 @@ func NormalsFindFirstByYearAndLocation(location entities.Location) entities.Norm
 	return n
 }
 
+func GetLastNormalsYearly(location entities.Location) []entities.Gdd {
+	coll := Session.Collection("gdd")
+
+	filter := buildLocationRequest(location, nil)
+	filter["year"] = bson.M{"$gte": 1991, "$lte": 2020}
+
+	var n []entities.Gdd
+	cursor, err := coll.Find(Session.Ctx, filter, options.Find().SetLimit(30))
+	if err != nil {
+		panic(config.NO_DATA_FOUND.PutDetail("reason", "normal_gdd"))
+	}
+
+	if err = cursor.All(Session.Ctx, &n); err != nil {
+		panic(config.INTERNAL_SERVER_STANDARD_ERROR.AddLogDetails(err.Error()))
+	}
+
+	return n
+}
+
 func GefsFindAllByLocation(location entities.Location) []entities.GefsGdd {
 	coll := Session.Collection("gefs")
 

services/confidence_interval_service.go

@@ -2,72 +2,91 @@ package services
 
 import (
 	"math"
-	"time"
 
 	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models"
-	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models/enums"
 	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
 	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/utils"
+	"gonum.org/v1/gonum/stat"
 )
 
 func GetConfidenceInterval(request models.ConfidenceIntervalRequest) models.ConfidenceIntervalResposne {
-	g := persistence.NormalsFindFirstByYearAndLocation(request.BuildLocation())
+	// g := persistence.NormalsFindFirstByYearAndLocation(request.BuildLocation())
 
-	var minTemps []float64
-	var maxTemps []float64
+	// var minTemps []float64
+	// var maxTemps []float64
 
-	var minVariance []float64
-	var maxVariance []float64
+	// var minVariance []float64
+	// var maxVariance []float64
 
-	var lowerBound []float64
-	var upperBound []float64
+	// var lowerBound []float64
+	// var upperBound []float64
 
-	var gddMinSum float64
-	var gddMaxSum float64
+	// var gddMinSum float64
+	// var gddMaxSum float64
 
-	if request.Product == enums.ProductType.CORN {
-		minTemps = g.MinTempsCorn
-		maxTemps = g.MaxTempsCorn
+	// if request.Product == enums.ProductType.CORN {
+	// 	minTemps = g.MinTempsCorn
+	// 	maxTemps = g.MaxTempsCorn
 
-		minVariance = g.MinVarianceCorn
-		maxVariance = g.MaxVarianceCorn
-	} else {
-		minTemps = g.MinTemps
-		maxTemps = g.MaxTemps
+	// 	minVariance = g.MinVarianceCorn
+	// 	maxVariance = g.MaxVarianceCorn
+	// } else {
+	// 	minTemps = g.MinTemps
+	// 	maxTemps = g.MaxTemps
 
-		minVariance = g.MinVariance
-		maxVariance = g.MaxVariance
-	}
+	// 	minVariance = g.MinVariance
+	// 	maxVariance = g.MaxVariance
+	// }
 
-	totalYears := float64(time.Now().Year() - 1991)
+	// totalYears := float64(time.Now().Year() - 1991)
 
-	zScore := models.IntervalConvert[request.Interval]
+	// for i := 0; i < len(minTemps); i++ {
 
-	for i := 0; i < len(minTemps); i++ {
+	// 	variance := (minVariance[i] + maxVariance[i])
+	// 	variance *= math.Pow(0.5, 2)
+	// 	std := math.Pow(variance, 0.5)
 
-		variance := (minVariance[i] + maxVariance[i])
-		variance *= math.Pow(0.5, 2)
-		std := math.Pow(variance, 0.5)
+	// 	gddValue := utils.CalculateSingleGdd(minTemps[i], maxTemps[i], request.Product)
 
-		gddValue := utils.CalculateSingleGdd(minTemps[i], maxTemps[i], request.Product)
+	// 	maxGddValue := (gddValue + (std / (math.Pow(totalYears, 0.5)) * zScore))
+	// 	minGddValue := (gddValue - (std / (math.Pow(totalYears, 0.5)) * zScore))
 
-		maxGddValue := (gddValue + (std / (math.Pow(totalYears, 0.5)) * zScore))
-		minGddValue := (gddValue - (std / (math.Pow(totalYears, 0.5)) * zScore))
+	// 	minGddValue = utils.ClipMinFloat(minGddValue, 0)
+	// 	maxGddValue = utils.ClipMinFloat(maxGddValue, 0)
 
-		minGddValue = utils.ClipMinFloat(minGddValue, 0)
-		maxGddValue = utils.ClipMinFloat(maxGddValue, 0)
+	// 	gddMinSum += minGddValue
+	// 	gddMaxSum += maxGddValue
 
-		gddMinSum += minGddValue
-		gddMaxSum += maxGddValue
+	// 	lowerBound = append(lowerBound, gddMinSum)
+	// 	upperBound = append(upperBound, gddMaxSum)
+	// }
 
-		lowerBound = append(lowerBound, gddMinSum)
-		upperBound = append(upperBound, gddMaxSum)
-	}
+	gs := persistence.GetLastNormalsYearly(request.BuildLocation())
+	product := request.Product
+	zScore := models.IntervalConvert[request.Interval]
 
+	var lowerBound []float64
+	var upperBound []float64
+
+	rows := [][]float64{}
+	for i := 0; i < len(gs[0].MinTemps); i++ {
+		row := []float64{}
+		for j := 0; j < len(gs); j++ {
+			row = append(row, utils.CalculateSingleGdd(gs[j].MinTemps[i], gs[j].MaxTemps[i], product))
+			if i > 0 {
+				row[j] += rows[len(rows)-1][j]
+			}
+		}
+		rows = append(rows, row)
+		mean, std := stat.MeanStdDev(row, nil)
+		moe := math.Pow(std/30, 0.5) * zScore
+		upperBound = append(upperBound, utils.ClipMinFloat(mean+moe, 0))
+		lowerBound = append(lowerBound, utils.ClipMinFloat(mean-moe, 0))
+	}
 	return models.ConfidenceIntervalResposne{
 		LowerBound:       lowerBound,
 		UpperBound:       upperBound,
-		ClosestLatitude:  g.Location.Coordinates[1],
-		ClosestLongitude: g.Location.Coordinates[0],
+		ClosestLatitude:  gs[0].Location.Coordinates[1],
+		ClosestLongitude: gs[0].Location.Coordinates[0],
 	}
 }

services/gdd_service.go

@@ -9,6 +9,7 @@ import (
 	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
 	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence/entities"
 	"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/utils"
+	"gonum.org/v1/gonum/stat"
 )
 
 func GetFullYearGddValues(ctx common.DawnCtx, request models.GddRequest) models.GddResponse {
@@ -52,22 +53,29 @@ func GetGddValues(ctx common.DawnCtx, request models.GddRequest) models.GddRespo
 
 func GetNormalValues(request models.GddRequest) models.GddResponse {
 	product := enums.GetProductFromString(request.Product)
-	g := persistence.NormalsFindFirstByYearAndLocation(request.BuildLocation())
+	gs := persistence.GetLastNormalsYearly(request.BuildLocation())
 	var returnGdds models.GddResponse
-	if product == enums.ProductType.CORN {
-		returnGdds = models.GddResponse{
-			Product:          product.Name,
-			ClosestLatitude:  g.Location.Coordinates[1],
-			ClosestLongitude: g.Location.Coordinates[0],
-			GddValues:        utils.CalculateGddValues(g.MinTempsCorn, g.MaxTempsCorn, product, request.Accumulate),
-		}
-	} else {
-		returnGdds = models.GddResponse{
-			Product:          product.Name,
-			ClosestLatitude:  g.Location.Coordinates[1],
-			ClosestLongitude: g.Location.Coordinates[0],
-			GddValues:        utils.CalculateGddValues(g.MinTemps, g.MaxTemps, product, request.Accumulate),
+	var gdds []float64
+	rows := [][]float64{}
+	for i := 0; i < len(gs[0].MinTemps); i++ {
+		row := []float64{}
+		for j := 0; j < len(gs); j++ {
+			row = append(row, utils.CalculateSingleGdd(gs[j].MinTemps[i], gs[j].MaxTemps[i], product))
+			if request.Accumulate && i > 0 {
+				row[j] += rows[len(rows)-1][j]
+			}
 		}
+		rows = append(rows, row)
+		mean := stat.Mean(row, nil)
+		gdds = append(gdds, mean)
+	}
+
+	returnGdds = models.GddResponse{
+		Product:          product.Name,
+		ClosestLatitude:  gs[0].Location.Coordinates[1],
+		ClosestLongitude: gs[0].Location.Coordinates[0],
+		GddValues:        gdds,
 	}
+
 	return returnGdds
 }