feat: refactor

cmd/compare_prediction/main.go

@@ -0,0 +1,195 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"net/http"
+	"os"
+	"time"
+
+	"predictor-refactored/internal/dataset"
+	"predictor-refactored/internal/downloader"
+	"predictor-refactored/internal/prediction"
+
+	"go.uber.org/zap"
+)
+
+// Downloads a few forecast steps and runs a prediction, then compares
+// against the public Tawhiri API.
+func main() {
+	log, _ := zap.NewDevelopment()
+
+	cfg := &downloader.Config{
+		DataDir:  os.TempDir(),
+		Parallel: 4,
+	}
+	dl := downloader.NewDownloader(cfg, log)
+
+	ctx := context.Background()
+
+	// Find latest run
+	run, err := dl.FindLatestRun(ctx)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FindLatestRun: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Using run: %s\n", run.Format("2006010215"))
+
+	// Create dataset and download first 10 steps (0-27 hours, enough for a prediction)
+	dsPath := fmt.Sprintf("/tmp/pred_test_%s.bin", run.Format("2006010215"))
+	defer os.Remove(dsPath)
+
+	ds, err := dataset.Create(dsPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Create: %v\n", err)
+		os.Exit(1)
+	}
+
+	date := run.Format("20060102")
+	runHour := run.Hour()
+	stepsToDownload := []int{0, 3, 6, 9, 12, 15, 18, 21, 24, 27}
+
+	fmt.Printf("Downloading %d steps...\n", len(stepsToDownload))
+	for _, step := range stepsToDownload {
+		hourIdx := dataset.HourIndex(step)
+		fmt.Printf("  step %d (hour idx %d)...\n", step, hourIdx)
+
+		urlA := dataset.GribURL(date, runHour, step)
+		if err := dl.DownloadAndBlit(ctx, ds, urlA, hourIdx, dataset.LevelSetA); err != nil {
+			fmt.Fprintf(os.Stderr, "  pgrb2 step %d: %v\n", step, err)
+			os.Exit(1)
+		}
+
+		urlB := dataset.GribURLB(date, runHour, step)
+		if err := dl.DownloadAndBlit(ctx, ds, urlB, hourIdx, dataset.LevelSetB); err != nil {
+			fmt.Fprintf(os.Stderr, "  pgrb2b step %d: %v\n", step, err)
+			os.Exit(1)
+		}
+	}
+	ds.Flush()
+	fmt.Println("Download complete")
+
+	// Set dataset time
+	ds.DSTime = run
+
+	// Run our prediction
+	launchLat := 52.2135
+	launchLon := 0.0964 // already in [0, 360)
+	launchAlt := 0.0
+	ascentRate := 5.0
+	burstAlt := 30000.0
+	descentRate := 5.0
+
+	// Launch 3 hours into the forecast
+	launchTime := run.Add(3 * time.Hour)
+	launchTimestamp := float64(launchTime.Unix())
+	dsEpoch := float64(run.Unix())
+
+	warnings := &prediction.Warnings{}
+	stages := prediction.StandardProfile(ascentRate, burstAlt, descentRate, ds, dsEpoch, warnings, nil)
+	results := prediction.RunPrediction(launchTimestamp, launchLat, launchLon, launchAlt, stages)
+
+	fmt.Printf("\n=== Our prediction ===\n")
+	for i, sr := range results {
+		stage := "ascent"
+		if i == 1 {
+			stage = "descent"
+		}
+		first := sr.Points[0]
+		last := sr.Points[len(sr.Points)-1]
+		fmt.Printf("  %s: %d points, start=(%.4f, %.4f, %.0fm) end=(%.4f, %.4f, %.0fm)\n",
+			stage, len(sr.Points),
+			first.Lat, first.Lng, first.Alt,
+			last.Lat, last.Lng, last.Alt)
+	}
+
+	// Get landing point
+	var ourLandLat, ourLandLon float64
+	if len(results) >= 2 {
+		last := results[1].Points[len(results[1].Points)-1]
+		ourLandLat = last.Lat
+		ourLandLon = last.Lng
+		if ourLandLon > 180 {
+			ourLandLon -= 360
+		}
+	}
+	fmt.Printf("  Landing: lat=%.4f, lon=%.4f\n", ourLandLat, ourLandLon)
+
+	// Compare against public Tawhiri API
+	fmt.Printf("\n=== Tawhiri API comparison ===\n")
+	tawhiriLandLat, tawhiriLandLon, err := queryTawhiri(launchLat, launchLon, launchAlt, launchTime, ascentRate, burstAlt, descentRate)
+	if err != nil {
+		fmt.Printf("  Tawhiri API error: %v\n", err)
+		fmt.Println("  (Cannot compare — Tawhiri may use a different dataset)")
+		ds.Close()
+		return
+	}
+	fmt.Printf("  Tawhiri landing: lat=%.4f, lon=%.4f\n", tawhiriLandLat, tawhiriLandLon)
+
+	dist := haversine(ourLandLat, ourLandLon, tawhiriLandLat, tawhiriLandLon)
+	fmt.Printf("  Distance between landing points: %.2f km\n", dist/1000)
+
+	if dist < 1000 {
+		fmt.Println("  CLOSE MATCH (< 1 km)")
+	} else if dist < 50000 {
+		fmt.Printf("  MODERATE DIFFERENCE (%.1f km) — likely different datasets\n", dist/1000)
+	} else {
+		fmt.Printf("  LARGE DIFFERENCE (%.1f km) — possible bug\n", dist/1000)
+	}
+
+	ds.Close()
+}
+
+func queryTawhiri(lat, lon, alt float64, launchTime time.Time, ascentRate, burstAlt, descentRate float64) (landLat, landLon float64, err error) {
+	url := fmt.Sprintf(
+		"https://api.v2.sondehub.org/tawhiri?launch_latitude=%.4f&launch_longitude=%.4f&launch_altitude=%.0f&launch_datetime=%s&ascent_rate=%.1f&burst_altitude=%.0f&descent_rate=%.1f",
+		lat, lon, alt, launchTime.Format(time.RFC3339), ascentRate, burstAlt, descentRate)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return 0, 0, err
+	}
+	defer resp.Body.Close()
+
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 {
+		return 0, 0, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
+	}
+
+	var result struct {
+		Prediction []struct {
+			Stage      string `json:"stage"`
+			Trajectory []struct {
+				Latitude  float64 `json:"latitude"`
+				Longitude float64 `json:"longitude"`
+				Altitude  float64 `json:"altitude"`
+			} `json:"trajectory"`
+		} `json:"prediction"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		return 0, 0, err
+	}
+
+	for _, stage := range result.Prediction {
+		if stage.Stage == "descent" && len(stage.Trajectory) > 0 {
+			last := stage.Trajectory[len(stage.Trajectory)-1]
+			return last.Latitude, last.Longitude, nil
+		}
+	}
+
+	return 0, 0, fmt.Errorf("no descent stage found")
+}
+
+func haversine(lat1, lon1, lat2, lon2 float64) float64 {
+	const R = 6371000.0
+	phi1 := lat1 * math.Pi / 180
+	phi2 := lat2 * math.Pi / 180
+	dphi := (lat2 - lat1) * math.Pi / 180
+	dlam := (lon2 - lon1) * math.Pi / 180
+	a := math.Sin(dphi/2)*math.Sin(dphi/2) + math.Cos(phi1)*math.Cos(phi2)*math.Sin(dlam/2)*math.Sin(dlam/2)
+	return R * 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
+}