2026-08-06 12:00:56 +08:00
|
|
|
package basic
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"math"
|
|
|
|
|
"strings"
|
|
|
|
|
"testing"
|
|
|
|
|
"time"
|
|
|
|
|
)
|
|
|
|
|
|
2026-09-17 12:27:40 +08:00
|
|
|
func TestPlanetOccultationCombinedPositionMatchesSeparateEphemerides(t *testing.T) {
|
|
|
|
|
tt := occultationTimeToTT(time.Date(2025, time.February, 1, 4, 0, 48, 0, time.UTC))
|
|
|
|
|
for _, planet := range []OccultationPlanet{
|
|
|
|
|
OccultationMercury,
|
|
|
|
|
OccultationVenus,
|
|
|
|
|
OccultationMars,
|
|
|
|
|
OccultationJupiter,
|
|
|
|
|
OccultationSaturn,
|
|
|
|
|
OccultationUranus,
|
|
|
|
|
OccultationNeptune,
|
|
|
|
|
} {
|
|
|
|
|
config, ok := planetOccultationConfigFor(planet)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatalf("%s occultation config is unavailable", planet)
|
|
|
|
|
}
|
|
|
|
|
wantRA, wantDec := config.apparentRaDecN(tt, -1)
|
|
|
|
|
wantDistance := config.earthDistanceN(tt, -1)
|
|
|
|
|
gotRA, gotDec, distance := planetOccultationApparentPositionAndDistanceN(tt, config, -1)
|
|
|
|
|
if gotRA != wantRA || gotDec != wantDec || distance != wantDistance {
|
|
|
|
|
t.Fatalf("%s combined position = %.15g %.15g %.15g, want %.15g %.15g %.15g",
|
|
|
|
|
planet, gotRA, gotDec, distance, wantRA, wantDec, wantDistance)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationEventCacheReusesStateAndContactFrames(t *testing.T) {
|
|
|
|
|
config, ok := planetOccultationConfigFor(OccultationSaturn)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn occultation config is unavailable")
|
|
|
|
|
}
|
|
|
|
|
tt := occultationTimeToTT(time.Date(2024, time.August, 21, 2, 41, 36, 0, time.UTC))
|
|
|
|
|
cache := newPlanetOccultationEventCache(config)
|
|
|
|
|
|
|
|
|
|
wantOuter, wantOuterOK := planetOccultationPathFrameAt(tt, config)
|
|
|
|
|
wantTotal, wantTotalOK := planetOccultationTotalPathFrameAt(tt, config)
|
|
|
|
|
for iteration := 0; iteration < 2; iteration++ {
|
|
|
|
|
gotOuter, gotOuterOK := cache.outerFrameAt(tt)
|
|
|
|
|
gotTotal, gotTotalOK := cache.totalFrameAt(tt)
|
|
|
|
|
_ = cache.riseSetContextAt(tt)
|
|
|
|
|
if gotOuterOK != wantOuterOK || !occultationPathFrameGeometryEqual(gotOuter, wantOuter) {
|
|
|
|
|
t.Fatalf("cached outer frame differs on iteration %d", iteration)
|
|
|
|
|
}
|
|
|
|
|
if gotTotalOK != wantTotalOK || !occultationPathFrameGeometryEqual(gotTotal, wantTotal) {
|
|
|
|
|
t.Fatalf("cached total frame differs on iteration %d", iteration)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if len(cache.states) != 1 || len(cache.outerFrames) != 1 || len(cache.totalFrames) != 1 {
|
|
|
|
|
t.Fatalf("cache sizes = states:%d outer:%d total:%d, want one entry each",
|
|
|
|
|
len(cache.states), len(cache.outerFrames), len(cache.totalFrames))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestOccultationPathFramesReuseMoonDistanceForAngularRadius(t *testing.T) {
|
|
|
|
|
tt := occultationTimeToTT(time.Date(2025, time.February, 1, 4, 0, 48, 0, time.UTC))
|
|
|
|
|
want := MoonSemidiameter(tt) * math.Pi / (180 * 3600)
|
|
|
|
|
starFrame, ok := starOccultationPathFrameAt(tt, StarCoordinate{
|
|
|
|
|
RA: 0, Dec: 0, Epoch: time.Date(2000, time.January, 1, 12, 0, 0, 0, time.UTC), Frame: CoordinateFrameJ2000,
|
|
|
|
|
})
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("stellar occultation frame is unavailable")
|
|
|
|
|
}
|
|
|
|
|
if difference := math.Abs(starFrame.moonRadius - want); difference > 1e-15 {
|
|
|
|
|
t.Fatalf("stellar cached lunar radius differs by %.15g radians", difference)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
config, _ := planetOccultationConfigFor(OccultationSaturn)
|
|
|
|
|
planetFrame, ok := planetOccultationPathFrameAt(tt, config)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("planet occultation frame is unavailable")
|
|
|
|
|
}
|
|
|
|
|
if difference := math.Abs(planetFrame.moonRadius - want); difference > 1e-15 {
|
|
|
|
|
t.Fatalf("planet cached lunar radius differs by %.15g radians", difference)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationCanDisableInstantaneousFootprints(t *testing.T) {
|
|
|
|
|
start := time.Date(2024, time.August, 21, 0, 0, 0, 0, time.UTC)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationSaturn,
|
|
|
|
|
OccultationPathOptions{Step: 10 * time.Minute, DisableFootprints: true},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
path := paths[0]
|
|
|
|
|
if len(path.PartialFootprints) != 0 || len(path.TotalFootprints) != 0 {
|
|
|
|
|
t.Fatalf("disabled footprint counts partial=%d total=%d, want zero", len(path.PartialFootprints), len(path.TotalFootprints))
|
|
|
|
|
}
|
|
|
|
|
if len(path.PartialBandFootprints) == 0 || len(path.TotalBandFootprints) == 0 {
|
|
|
|
|
t.Fatalf("compact band support counts partial=%d total=%d, want both nonzero", len(path.PartialBandFootprints), len(path.TotalBandFootprints))
|
|
|
|
|
}
|
|
|
|
|
if len(path.RiseSetCurves) != 6 {
|
|
|
|
|
t.Fatalf("rise/set curve count=%d, want six", len(path.RiseSetCurves))
|
|
|
|
|
}
|
|
|
|
|
if len(path.TotalRiseSetCurves) != 6 {
|
|
|
|
|
t.Fatalf("total rise/set curve count=%d, want six", len(path.TotalRiseSetCurves))
|
|
|
|
|
}
|
|
|
|
|
if len(path.CenterLine) == 0 || len(path.NorthernLimit) == 0 || len(path.SouthernLimit) == 0 {
|
|
|
|
|
t.Fatal("disabled footprints removed the center line or outer limits")
|
|
|
|
|
}
|
|
|
|
|
if !path.HasTotalBand || len(path.NorthernTotalLimit) == 0 || len(path.SouthernTotalLimit) == 0 {
|
|
|
|
|
t.Fatal("disabled footprints removed the total-occultation band")
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationCompactBandCanIncludeLowFrequencyTimeline(t *testing.T) {
|
|
|
|
|
start := time.Date(2025, time.January, 5, 0, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60))
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationSaturn,
|
|
|
|
|
OccultationPathOptions{
|
|
|
|
|
Step: 20 * time.Minute, DisableFootprints: true,
|
|
|
|
|
IncludeFootprintTimeline: true, FootprintTimelineStep: 5 * time.Minute,
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
path := paths[0]
|
|
|
|
|
if len(path.PartialBandFootprints) == 0 || len(path.PartialFootprints) == 0 {
|
|
|
|
|
t.Fatalf("partial compact/timeline counts=%d/%d, want both", len(path.PartialBandFootprints), len(path.PartialFootprints))
|
|
|
|
|
}
|
|
|
|
|
if len(path.TotalBandFootprints) == 0 || len(path.TotalFootprints) == 0 {
|
|
|
|
|
t.Fatalf("total compact/timeline counts=%d/%d, want both", len(path.TotalBandFootprints), len(path.TotalFootprints))
|
|
|
|
|
}
|
|
|
|
|
if len(path.PartialFootprints) > 50 || len(path.TotalFootprints) > 50 {
|
|
|
|
|
t.Fatalf("five-minute timeline is unexpectedly dense: partial=%d total=%d", len(path.PartialFootprints), len(path.TotalFootprints))
|
|
|
|
|
}
|
|
|
|
|
timelinePoints := 0
|
|
|
|
|
for _, footprints := range [][]PlanetOccultationFootprint{path.PartialFootprints, path.TotalFootprints} {
|
|
|
|
|
for _, footprint := range footprints {
|
|
|
|
|
for polygonIndex, polygon := range footprint.Polygons {
|
|
|
|
|
if len(polygon) < 4 || occultationPathDistanceKM(polygon[0], polygon[len(polygon)-1]) > 0.001 {
|
|
|
|
|
t.Fatalf("timeline footprint at %v polygon %d is not closed", footprint.Time, polygonIndex)
|
|
|
|
|
}
|
|
|
|
|
timelinePoints += len(polygon)
|
|
|
|
|
for pointIndex := 1; pointIndex < len(polygon); pointIndex++ {
|
|
|
|
|
if distance := occultationPathDistanceKM(polygon[pointIndex-1], polygon[pointIndex]); distance > 301 {
|
|
|
|
|
t.Fatalf("timeline footprint at %v polygon %d edge %d spans %.1f km, want at most 301 km",
|
|
|
|
|
footprint.Time, polygonIndex, pointIndex-1, distance)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if timelinePoints > 15000 {
|
|
|
|
|
t.Fatalf("timeline contains %d polygon points, want at most 15000", timelinePoints)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestStarOccultationCompactBandUsesIndependentTimeline(t *testing.T) {
|
|
|
|
|
start := time.Date(2025, time.June, 5, 0, 0, 0, 0, time.UTC)
|
|
|
|
|
paths, err := FindStarOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), hr4799OccultationCoordinateForTest(),
|
|
|
|
|
OccultationPathOptions{
|
|
|
|
|
Step: 20 * time.Minute, TargetSpacingKM: 900,
|
|
|
|
|
DisableFootprints: true, IncludeFootprintTimeline: true,
|
|
|
|
|
FootprintTimelineStep: 5 * time.Minute,
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindStarOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
path := paths[0]
|
|
|
|
|
if len(path.BandFootprints) == 0 || len(path.Footprints) == 0 {
|
|
|
|
|
t.Fatalf("compact/timeline counts=%d/%d, want both", len(path.BandFootprints), len(path.Footprints))
|
|
|
|
|
}
|
|
|
|
|
for _, footprint := range path.Footprints {
|
|
|
|
|
for polygonIndex, polygon := range footprint.Polygons {
|
|
|
|
|
if len(polygon) < 4 || occultationPathDistanceKM(polygon[0], polygon[len(polygon)-1]) > 0.001 {
|
|
|
|
|
t.Fatalf("timeline footprint at %v polygon %d is not closed", footprint.Time, polygonIndex)
|
|
|
|
|
}
|
|
|
|
|
for pointIndex := 1; pointIndex < len(polygon); pointIndex++ {
|
|
|
|
|
if distance := occultationPathDistanceKM(polygon[pointIndex-1], polygon[pointIndex]); distance > 301 {
|
|
|
|
|
t.Fatalf("timeline footprint at %v polygon %d edge %d spans %.1f km, want at most 301 km",
|
|
|
|
|
footprint.Time, polygonIndex, pointIndex-1, distance)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestOccultationPathPointBudgetIsBounded(t *testing.T) {
|
|
|
|
|
options := normalizeOccultationPathOptions(OccultationPathOptions{})
|
|
|
|
|
got := occultationPathEstimatedPointCount(0, 0.2, 0, 0, false, 0, 0, false, 0.1, options)
|
|
|
|
|
if got <= 0 || got > occultationPathMaxOutputPointCount {
|
|
|
|
|
t.Fatalf("default occultation point estimate=%d, want within positive budget", got)
|
|
|
|
|
}
|
|
|
|
|
dense := normalizeOccultationPathOptions(OccultationPathOptions{Step: time.Second})
|
|
|
|
|
got = occultationPathEstimatedPointCount(0, 2, 0, 2, true, 0, 2, true, 1, dense)
|
|
|
|
|
if got <= occultationPathFootprintPointBudget || got > occultationPathMaxOutputPointCount {
|
|
|
|
|
t.Fatalf("dense occultation point estimate=%d, want footprint-aware value within budget %d",
|
|
|
|
|
got, occultationPathMaxOutputPointCount)
|
|
|
|
|
}
|
|
|
|
|
if overflow := occultationPathAccumulatePointEstimate(occultationPathMaxOutputPointCount-10, 20); overflow <= occultationPathMaxOutputPointCount {
|
|
|
|
|
t.Fatalf("overflow estimate=%d, want sentinel above %d", overflow, occultationPathMaxOutputPointCount)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultation19621010TotalBandIsNarrowerThanOuterBand(t *testing.T) {
|
|
|
|
|
start := time.Date(1962, time.October, 10, 0, 0, 0, 0, time.UTC)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationJupiter,
|
|
|
|
|
OccultationPathOptions{Step: 10 * time.Minute, DisableFootprints: true, DisableRiseSet: true},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
path := paths[0]
|
|
|
|
|
if !path.HasTotalBand || path.GreatestTotalWidthKM <= 0 || path.GreatestTotalWidthKM >= path.Greatest.WidthKM {
|
|
|
|
|
t.Fatalf("widths outer=%.3f total=%.3f hasTotal=%v, want a narrower positive total band",
|
|
|
|
|
path.Greatest.WidthKM, path.GreatestTotalWidthKM, path.HasTotalBand)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultation20240725CompactBandRefinesContactsAndBoundaryPairing(t *testing.T) {
|
|
|
|
|
zone := time.FixedZone("UTC+8", 8*60*60)
|
|
|
|
|
start := time.Date(2024, time.July, 25, 0, 0, 0, 0, zone)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationSaturn,
|
|
|
|
|
OccultationPathOptions{
|
|
|
|
|
Step: 20 * time.Minute, TargetSpacingKM: 900,
|
|
|
|
|
DisableFootprints: true,
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
path := paths[0]
|
|
|
|
|
for _, test := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
footprints []PlanetOccultationFootprint
|
|
|
|
|
start, end time.Time
|
|
|
|
|
}{
|
|
|
|
|
{name: "partial", footprints: path.PartialBandFootprints, start: path.Start.Time, end: path.End.Time},
|
|
|
|
|
{name: "total", footprints: path.TotalBandFootprints, start: path.TotalStart.Time, end: path.TotalEnd.Time},
|
|
|
|
|
} {
|
|
|
|
|
if len(test.footprints) < 2 {
|
|
|
|
|
t.Fatalf("%s compact support count=%d, want at least two", test.name, len(test.footprints))
|
|
|
|
|
}
|
|
|
|
|
if gap := test.footprints[0].Time.Sub(test.start); gap > 30*time.Second {
|
|
|
|
|
t.Errorf("%s compact support starts %s after contact, want at most 30s", test.name, gap)
|
|
|
|
|
}
|
|
|
|
|
if gap := test.end.Sub(test.footprints[len(test.footprints)-1].Time); gap > 30*time.Second {
|
|
|
|
|
t.Errorf("%s compact support ends %s before contact, want at most 30s", test.name, gap)
|
|
|
|
|
}
|
|
|
|
|
for footprintIndex, footprint := range test.footprints {
|
|
|
|
|
if footprintIndex > 0 {
|
|
|
|
|
previous := test.footprints[footprintIndex-1]
|
|
|
|
|
if previous.Closed && footprint.Closed && footprint.Time.Sub(previous.Time) <= time.Second {
|
|
|
|
|
t.Errorf("%s compact support retains duplicate closed footprints at %s and %s",
|
|
|
|
|
test.name, previous.Time, footprint.Time)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
for polygonIndex, polygon := range footprint.Polygons {
|
|
|
|
|
for pointIndex := 1; pointIndex < len(polygon); pointIndex++ {
|
|
|
|
|
if distance := occultationPathDistanceKM(polygon[pointIndex-1], polygon[pointIndex]); distance > 150 {
|
|
|
|
|
t.Errorf("%s compact support[%d].polygon[%d] edge %d spans %.1f km, want at most 150 km",
|
|
|
|
|
test.name, footprintIndex, polygonIndex, pointIndex-1, distance)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
for _, test := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
first, second []OccultationPathPoint
|
|
|
|
|
}{
|
|
|
|
|
{name: "partial", first: path.NorthernLimit, second: path.SouthernLimit},
|
|
|
|
|
{name: "total", first: path.NorthernTotalLimit, second: path.SouthernTotalLimit},
|
|
|
|
|
} {
|
|
|
|
|
for index := 1; index < len(test.first); index++ {
|
|
|
|
|
direct := math.Max(
|
|
|
|
|
occultationPathDistanceKM(test.first[index-1], test.first[index]),
|
|
|
|
|
occultationPathDistanceKM(test.second[index-1], test.second[index]),
|
|
|
|
|
)
|
|
|
|
|
swapped := math.Max(
|
|
|
|
|
occultationPathDistanceKM(test.first[index-1], test.second[index]),
|
|
|
|
|
occultationPathDistanceKM(test.second[index-1], test.first[index]),
|
|
|
|
|
)
|
|
|
|
|
if direct > 2000 && swapped < 750 {
|
|
|
|
|
t.Errorf("%s boundary sample %d keeps a %.1f km direct pairing although the swapped pairing is %.1f km",
|
|
|
|
|
test.name, index, direct, swapped)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultation20250105CompactBandRefinesVisibilityTransitions(t *testing.T) {
|
|
|
|
|
zone := time.FixedZone("UTC+8", 8*60*60)
|
|
|
|
|
start := time.Date(2025, time.January, 5, 0, 0, 0, 0, zone)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationSaturn,
|
|
|
|
|
OccultationPathOptions{
|
|
|
|
|
Step: 20 * time.Minute, TargetSpacingKM: 900,
|
|
|
|
|
DisableRiseSet: true, DisableFootprints: true,
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
for _, test := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
footprints []PlanetOccultationFootprint
|
|
|
|
|
}{
|
|
|
|
|
{name: "partial", footprints: paths[0].PartialBandFootprints},
|
|
|
|
|
{name: "total", footprints: paths[0].TotalBandFootprints},
|
|
|
|
|
} {
|
|
|
|
|
transitions := 0
|
|
|
|
|
for index := 1; index < len(test.footprints); index++ {
|
|
|
|
|
previous, current := test.footprints[index-1], test.footprints[index]
|
|
|
|
|
if previous.Closed == current.Closed {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
transitions++
|
|
|
|
|
if gap := current.Time.Sub(previous.Time); gap > 150*time.Millisecond {
|
|
|
|
|
t.Errorf("%s visibility transition %d spans %s, want at most 150ms", test.name, transitions, gap)
|
|
|
|
|
}
|
|
|
|
|
open := previous
|
|
|
|
|
if open.Closed {
|
|
|
|
|
open = current
|
|
|
|
|
}
|
|
|
|
|
if len(open.Boundaries) != 1 || len(open.Boundaries[0]) < 2 {
|
|
|
|
|
t.Fatalf("%s visibility transition %d has no open boundary", test.name, transitions)
|
|
|
|
|
}
|
|
|
|
|
// Boundaries contain the visible contact arc, not a closed ring. Its
|
|
|
|
|
// endpoints may remain far apart at the geocentric open/closed
|
|
|
|
|
// transition because station parallax changes the topology. The physical
|
|
|
|
|
// contract is that both endpoints lie on the lunar horizon and the
|
|
|
|
|
// separately exported polygon closes them with the horizon arc.
|
|
|
|
|
boundary := open.Boundaries[0]
|
|
|
|
|
for _, endpoint := range []OccultationPathPoint{boundary[0], boundary[len(boundary)-1]} {
|
|
|
|
|
if math.Abs(endpoint.MoonAltitude) > 1e-5 {
|
|
|
|
|
t.Errorf("%s visibility transition %d endpoint altitude=%g deg, want horizon root",
|
|
|
|
|
test.name, transitions, endpoint.MoonAltitude)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if len(open.Polygons) == 0 || len(open.Polygons[0]) < len(boundary)+2 {
|
|
|
|
|
t.Errorf("%s visibility transition %d has no horizon-closed polygon", test.name, transitions)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if transitions != 2 {
|
|
|
|
|
t.Errorf("%s visibility transition count=%d, want 2", test.name, transitions)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-08-06 12:00:56 +08:00
|
|
|
func TestPlanetOccultationFiniteDiskExpandsOuterAndContractsTotalPath(t *testing.T) {
|
|
|
|
|
config, ok := planetOccultationConfigFor(OccultationSaturn)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn occultation config is unavailable")
|
|
|
|
|
}
|
|
|
|
|
tt := occultationTimeToTT(time.Date(2024, time.August, 21, 2, 41, 36, 0, time.UTC))
|
|
|
|
|
frameAt := func(tt float64) (occultationPathFrame, bool) {
|
|
|
|
|
return planetOccultationPathFrameAt(tt, config)
|
|
|
|
|
}
|
|
|
|
|
_, _, finiteWidth, finiteOK := occultationPathLimitsAndWidthForFrame(tt, frameAt)
|
|
|
|
|
if !finiteOK {
|
|
|
|
|
t.Fatal("finite-disk path limits are unavailable")
|
|
|
|
|
}
|
|
|
|
|
pointFrameAt := func(tt float64) (occultationPathFrame, bool) {
|
|
|
|
|
frame, valid := planetOccultationPathFrameAt(tt, config)
|
|
|
|
|
frame.targetRadius = 0
|
|
|
|
|
return frame, valid
|
|
|
|
|
}
|
|
|
|
|
_, _, pointWidth, pointOK := occultationPathLimitsAndWidthForFrame(tt, pointFrameAt)
|
|
|
|
|
if !pointOK {
|
|
|
|
|
t.Fatal("point-source comparison limits are unavailable")
|
|
|
|
|
}
|
|
|
|
|
if finiteWidth <= pointWidth {
|
|
|
|
|
t.Fatalf("finite-disk outer width = %.6f km, want greater than point-source width %.6f km", finiteWidth, pointWidth)
|
|
|
|
|
}
|
|
|
|
|
if finiteWidth-pointWidth < 1 {
|
|
|
|
|
t.Fatalf("finite-disk expansion = %.6f km, want a measurable planetary-radius contribution", finiteWidth-pointWidth)
|
|
|
|
|
}
|
|
|
|
|
innerFrameAt := func(tt float64) (occultationPathFrame, bool) {
|
|
|
|
|
return planetOccultationTotalPathFrameAt(tt, config)
|
|
|
|
|
}
|
|
|
|
|
_, _, totalWidth, totalOK := occultationPathLimitsAndWidthForFrame(tt, innerFrameAt)
|
|
|
|
|
if !totalOK {
|
|
|
|
|
t.Fatal("finite-disk total-occultation limits are unavailable")
|
|
|
|
|
}
|
|
|
|
|
if totalWidth >= pointWidth {
|
|
|
|
|
t.Fatalf("finite-disk total width = %.6f km, want less than point-source width %.6f km", totalWidth, pointWidth)
|
|
|
|
|
}
|
|
|
|
|
if pointWidth-totalWidth < 1 {
|
|
|
|
|
t.Fatalf("finite-disk contraction = %.6f km, want a measurable planetary-radius contribution", pointWidth-totalWidth)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationConesUseTwoSphereCommonTangents(t *testing.T) {
|
|
|
|
|
config, ok := planetOccultationConfigFor(OccultationSaturn)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn occultation config is unavailable")
|
|
|
|
|
}
|
|
|
|
|
tt := occultationTimeToTT(time.Date(2025, time.February, 1, 4, 0, 48, 0, time.UTC))
|
|
|
|
|
outer, ok := planetOccultationPathFrameAt(tt, config)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn outer-contact cone is unavailable")
|
|
|
|
|
}
|
|
|
|
|
inner, ok := planetOccultationTotalPathFrameAt(tt, config)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn inner-contact cone is unavailable")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
planetRA, planetDec := config.apparentRaDecN(tt, -1)
|
|
|
|
|
planetDistance := config.earthDistanceN(tt, -1) * occultationPathAstronomicalUnitKM
|
|
|
|
|
target := occultationPathRaDecVector(planetRA, planetDec, planetDistance)
|
|
|
|
|
moonToTargetDistance := occultationPathNorm(occultationPathSub(target, outer.moon))
|
|
|
|
|
moonRadiusKM := occultationPathNorm(outer.moon) * math.Sin(outer.moonRadius)
|
|
|
|
|
wantOuter := math.Asin((moonRadiusKM + config.equatorialRadiusKM) / moonToTargetDistance)
|
|
|
|
|
wantInner := math.Asin((moonRadiusKM - config.equatorialRadiusKM) / moonToTargetDistance)
|
|
|
|
|
if difference := math.Abs(outer.targetRadius - wantOuter); difference > 1e-15 {
|
|
|
|
|
t.Fatalf("outer-contact cone angle = %.15g rad, want %.15g (difference %.3g)", outer.targetRadius, wantOuter, difference)
|
|
|
|
|
}
|
|
|
|
|
if difference := math.Abs(inner.targetRadius - wantInner); difference > 1e-15 {
|
|
|
|
|
t.Fatalf("inner-contact cone angle = %.15g rad, want %.15g (difference %.3g)", inner.targetRadius, wantInner, difference)
|
|
|
|
|
}
|
|
|
|
|
for _, contact := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
frame occultationPathFrame
|
|
|
|
|
}{
|
|
|
|
|
{name: "outer", frame: outer},
|
|
|
|
|
{name: "inner", frame: inner},
|
|
|
|
|
} {
|
|
|
|
|
origin, direction, rayOK := occultationPathBoundaryRay(contact.frame, 0.73)
|
|
|
|
|
if !rayOK {
|
|
|
|
|
t.Fatalf("%s-contact boundary ray is unavailable", contact.name)
|
|
|
|
|
}
|
|
|
|
|
moonNormal := occultationPathSub(origin, contact.frame.moon)
|
|
|
|
|
if difference := math.Abs(occultationPathNorm(moonNormal) - moonRadiusKM); difference > 1e-6 {
|
|
|
|
|
t.Fatalf("%s-contact lunar tangency radius differs by %.9f km", contact.name, difference)
|
|
|
|
|
}
|
|
|
|
|
if residual := math.Abs(occultationPathDot(moonNormal, direction)); residual > 1e-6 {
|
|
|
|
|
t.Fatalf("%s-contact ray/lunar-radius dot product = %.9f km", contact.name, residual)
|
|
|
|
|
}
|
|
|
|
|
targetParameter := occultationPathDot(occultationPathSub(target, origin), direction)
|
|
|
|
|
targetTangent := occultationPathAdd(origin, occultationPathScale(direction, targetParameter))
|
|
|
|
|
targetNormal := occultationPathSub(targetTangent, target)
|
|
|
|
|
if difference := math.Abs(occultationPathNorm(targetNormal) - config.equatorialRadiusKM); difference > 1e-5 {
|
|
|
|
|
t.Fatalf("%s-contact planetary tangency radius differs by %.9f km", contact.name, difference)
|
|
|
|
|
}
|
|
|
|
|
if residual := math.Abs(occultationPathDot(targetNormal, direction)); residual > 1e-5 {
|
|
|
|
|
t.Fatalf("%s-contact ray/planet-radius dot product = %.9f km", contact.name, residual)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationInnerConeUsesSignedTargetRadius(t *testing.T) {
|
|
|
|
|
config, ok := planetOccultationConfigFor(OccultationSaturn)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn occultation config is unavailable")
|
|
|
|
|
}
|
|
|
|
|
tt := occultationTimeToTT(time.Date(2025, time.February, 1, 4, 0, 48, 0, time.UTC))
|
|
|
|
|
frame, ok := planetOccultationTotalPathFrameAt(tt, config)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn inner-contact cone is unavailable")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for index := 0; index < occultationPathBoundaryScanPoints; index++ {
|
|
|
|
|
theta := 2 * math.Pi * float64(index) / float64(occultationPathBoundaryScanPoints)
|
|
|
|
|
want, _, wantOK := occultationPathBoundaryVector(frame, theta)
|
|
|
|
|
if !wantOK {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
discriminant, _, scale, lineOK := occultationPathBoundaryLine(frame, theta)
|
|
|
|
|
if !lineOK || discriminant < 0 {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
got, _, gotOK := occultationPathBoundaryIntersection(frame, theta, 1e-12*math.Max(scale, 1))
|
|
|
|
|
if !gotOK {
|
|
|
|
|
t.Fatalf("signed inner-cone intersection is unavailable at theta %.9f", theta)
|
|
|
|
|
}
|
|
|
|
|
if difference := occultationPathNorm(occultationPathSub(got, want)); difference > 1e-6 {
|
|
|
|
|
t.Fatalf("inner-cone intersection differs by %.6f km at theta %.9f", difference, theta)
|
|
|
|
|
}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
t.Fatal("no comparable Saturn inner-cone boundary point found")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestOccultationPathBoundaryTangentFindsBetweenSamples(t *testing.T) {
|
|
|
|
|
const boundaryRadiusKM = 1737.4
|
|
|
|
|
theta := math.Pi / float64(occultationPathBoundaryScanPoints)
|
|
|
|
|
offset := occultationPathEarthEquatorialRadiusKM + boundaryRadiusKM - 0.01
|
|
|
|
|
moon := occultationPathVector{
|
|
|
|
|
x: 384000,
|
|
|
|
|
y: -offset * math.Cos(theta),
|
|
|
|
|
z: -offset * math.Sin(theta),
|
|
|
|
|
}
|
|
|
|
|
frame := occultationPathFrame{
|
|
|
|
|
moon: moon,
|
|
|
|
|
axis: occultationPathVector{x: -1},
|
|
|
|
|
first: occultationPathVector{y: 1},
|
|
|
|
|
second: occultationPathVector{z: 1},
|
|
|
|
|
moonRadius: math.Asin(boundaryRadiusKM / occultationPathNorm(moon)),
|
|
|
|
|
}
|
|
|
|
|
for _, sampledTheta := range []float64{0, 2 * math.Pi / float64(occultationPathBoundaryScanPoints)} {
|
|
|
|
|
if _, _, ok := occultationPathBoundaryVector(frame, sampledTheta); ok {
|
|
|
|
|
t.Fatalf("fixture is not narrower than the old sample spacing at theta %.9f", sampledTheta)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
point, tangentTheta, ok := occultationPathBoundaryTangent(frame)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("continuous boundary tangency was not found between scan points")
|
|
|
|
|
}
|
|
|
|
|
if math.Abs(tangentTheta-theta) > 5e-5 {
|
|
|
|
|
t.Fatalf("tangent theta = %.9f, want %.9f", tangentTheta, theta)
|
|
|
|
|
}
|
|
|
|
|
polarRatioSquared := occultationPathEarthPolarRatio * occultationPathEarthPolarRatio
|
|
|
|
|
ellipsoidResidual := point.x*point.x + point.y*point.y + point.z*point.z/polarRatioSquared -
|
|
|
|
|
occultationPathEarthEquatorialRadiusKM*occultationPathEarthEquatorialRadiusKM
|
|
|
|
|
if math.Abs(ellipsoidResidual) > 1e-3 {
|
|
|
|
|
t.Fatalf("tangent point ellipsoid residual = %.9f", ellipsoidResidual)
|
|
|
|
|
}
|
|
|
|
|
frameAt := func(float64) (occultationPathFrame, bool) { return frame, true }
|
|
|
|
|
if _, _, centerOK := occultationEarthLineIntersection(frame.moon, frame.axis); centerOK {
|
|
|
|
|
t.Fatal("synthetic center line unexpectedly intersects Earth")
|
|
|
|
|
}
|
|
|
|
|
north, south, width, limitsOK := occultationPathLimitsAndWidthForFrame(2451545, frameAt)
|
|
|
|
|
if !limitsOK {
|
|
|
|
|
t.Fatal("boundary-only event did not produce path limits")
|
|
|
|
|
}
|
|
|
|
|
if separation := occultationPathNorm(occultationPathSub(north, south)); separation <= 1e-6 {
|
|
|
|
|
t.Fatalf("boundary-only path limits collapsed to one point: separation=%.12f km", separation)
|
|
|
|
|
}
|
|
|
|
|
if width <= 0 {
|
|
|
|
|
t.Fatalf("boundary-only path width = %.12f km, want positive", width)
|
|
|
|
|
}
|
|
|
|
|
greatest, greatestOK := occultationPathBoundaryPointForFrame(2451545, frameAt, time.UTC)
|
|
|
|
|
if !greatestOK {
|
|
|
|
|
t.Fatal("boundary-only event did not produce a greatest surface point")
|
|
|
|
|
}
|
|
|
|
|
if greatest.WidthKM <= 0 {
|
|
|
|
|
t.Fatalf("boundary-only greatest width = %.12f km, want positive", greatest.WidthKM)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationSaturnLimitsRemainContinuous(t *testing.T) {
|
|
|
|
|
location := time.FixedZone("UTC+8", 8*3600)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
time.Date(2025, time.February, 1, 0, 0, 0, 0, location),
|
|
|
|
|
time.Date(2025, time.February, 2, 0, 0, 0, 0, location),
|
|
|
|
|
OccultationSaturn,
|
|
|
|
|
OccultationPathOptions{Step: 2 * time.Minute},
|
|
|
|
|
)
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() error = %v", err)
|
|
|
|
|
}
|
|
|
|
|
if len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() returned %d paths, want 1", len(paths))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for _, limit := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
points []OccultationPathPoint
|
|
|
|
|
}{
|
|
|
|
|
{name: "outer northern", points: paths[0].NorthernLimit},
|
|
|
|
|
{name: "outer southern", points: paths[0].SouthernLimit},
|
|
|
|
|
{name: "total northern", points: paths[0].NorthernTotalLimit},
|
|
|
|
|
{name: "total southern", points: paths[0].SouthernTotalLimit},
|
|
|
|
|
} {
|
|
|
|
|
for index := 1; index < len(limit.points); index++ {
|
|
|
|
|
distance := occultationPathDistanceKM(limit.points[index-1], limit.points[index])
|
|
|
|
|
if distance > 1000 {
|
|
|
|
|
t.Fatalf("%s limit jumps %.1f km between %v and %v", limit.name, distance,
|
|
|
|
|
limit.points[index-1].Time, limit.points[index].Time)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestRefinedPlanetOccultationCenterLineRespectsWidthTolerance(t *testing.T) {
|
|
|
|
|
start := time.Date(2025, time.February, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationSaturn,
|
|
|
|
|
OccultationPathOptions{Step: 5 * time.Minute, TargetSpacingKM: 50},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
config, ok := planetOccultationConfigFor(OccultationSaturn)
|
|
|
|
|
if !ok {
|
|
|
|
|
t.Fatal("Saturn occultation config is unavailable")
|
|
|
|
|
}
|
|
|
|
|
frameAt := func(tt float64) (occultationPathFrame, bool) {
|
|
|
|
|
return planetOccultationPathFrameAt(tt, config)
|
|
|
|
|
}
|
|
|
|
|
for index, point := range paths[0].CenterLine {
|
|
|
|
|
exact, pointOK := occultationPathCenterPointForFrame(centerTimeTT(point.Time), frameAt, time.UTC)
|
|
|
|
|
if !pointOK {
|
|
|
|
|
t.Fatalf("exact center point %d is unavailable", index)
|
|
|
|
|
}
|
|
|
|
|
if difference := math.Abs(point.WidthKM - exact.WidthKM); difference > occultationPathWidthToleranceKM {
|
|
|
|
|
t.Fatalf("center point %d width differs from exact value by %.9f km: got %.9f want %.9f",
|
|
|
|
|
index, difference, point.WidthKM, exact.WidthKM)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestPlanetOccultationSaturnLimitsDoNotDependOnStep(t *testing.T) {
|
|
|
|
|
location := time.FixedZone("UTC+8", 8*3600)
|
|
|
|
|
start := time.Date(2024, time.August, 21, 0, 0, 0, 0, location)
|
|
|
|
|
end := time.Date(2024, time.August, 22, 0, 0, 0, 0, location)
|
|
|
|
|
fine := findSinglePlanetOccultationPath(t, start, end, 30*time.Second)
|
|
|
|
|
coarse := findSinglePlanetOccultationPath(t, start, end, 2*time.Minute)
|
|
|
|
|
|
|
|
|
|
for _, limits := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
fine, coarse []OccultationPathPoint
|
|
|
|
|
}{
|
|
|
|
|
{name: "outer northern", fine: fine.NorthernLimit, coarse: coarse.NorthernLimit},
|
|
|
|
|
{name: "outer southern", fine: fine.SouthernLimit, coarse: coarse.SouthernLimit},
|
|
|
|
|
{name: "total northern", fine: fine.NorthernTotalLimit, coarse: coarse.NorthernTotalLimit},
|
|
|
|
|
{name: "total southern", fine: fine.SouthernTotalLimit, coarse: coarse.SouthernTotalLimit},
|
|
|
|
|
} {
|
|
|
|
|
assertOccultationPathCommonSamplesEqual(t, limits.name, limits.fine, limits.coarse)
|
|
|
|
|
for index := 1; index+1 < len(limits.coarse); index++ {
|
|
|
|
|
paired := coarse.SouthernLimit
|
|
|
|
|
if strings.HasPrefix(limits.name, "total") {
|
|
|
|
|
paired = coarse.SouthernTotalLimit
|
|
|
|
|
}
|
|
|
|
|
if strings.HasSuffix(limits.name, "southern") {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
if distance := occultationPathDistanceKM(limits.coarse[index], paired[index]); distance < 0.001 {
|
|
|
|
|
t.Fatalf("%s and southern limit collapse at %v", limits.name, limits.coarse[index].Time)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func findSinglePlanetOccultationPath(t *testing.T, start, end time.Time, step time.Duration) PlanetOccultationPath {
|
|
|
|
|
t.Helper()
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(start, end, OccultationSaturn, OccultationPathOptions{Step: step})
|
|
|
|
|
if err != nil {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths(step=%v) error = %v", step, err)
|
|
|
|
|
}
|
|
|
|
|
if len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths(step=%v) returned %d paths, want 1", step, len(paths))
|
|
|
|
|
}
|
|
|
|
|
if !paths[0].HasTotalBand {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths(step=%v) has no total band", step)
|
|
|
|
|
}
|
|
|
|
|
return paths[0]
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func assertOccultationPathCommonSamplesEqual(t *testing.T, name string, fine, coarse []OccultationPathPoint) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
matched := 0
|
|
|
|
|
fineIndex := 0
|
|
|
|
|
for _, coarsePoint := range coarse[1 : len(coarse)-1] {
|
|
|
|
|
for fineIndex+1 < len(fine) && fine[fineIndex].Time.Before(coarsePoint.Time.Add(-20*time.Millisecond)) {
|
|
|
|
|
fineIndex++
|
|
|
|
|
}
|
|
|
|
|
nearest := -1
|
|
|
|
|
nearestDelta := math.Inf(1)
|
|
|
|
|
for candidateIndex := fineIndex - 2; candidateIndex <= fineIndex+2; candidateIndex++ {
|
|
|
|
|
if candidateIndex < 0 || candidateIndex >= len(fine) {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
delta := math.Abs(fine[candidateIndex].Time.Sub(coarsePoint.Time).Seconds())
|
|
|
|
|
if delta < nearestDelta {
|
|
|
|
|
nearest = candidateIndex
|
|
|
|
|
nearestDelta = delta
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if nearest < 0 || nearestDelta > 0.00001 {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
matched++
|
|
|
|
|
if distance := occultationPathDistanceKM(fine[nearest], coarsePoint); distance > 5 {
|
|
|
|
|
t.Fatalf("%s differs by %.1f km at common time %v (sample delta %.6f s)",
|
|
|
|
|
name, distance, coarsePoint.Time, nearestDelta)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if matched < 10 {
|
|
|
|
|
t.Fatalf("%s compared only %d common samples, want at least 10", name, matched)
|
|
|
|
|
}
|
|
|
|
|
}
|
2026-09-17 12:27:40 +08:00
|
|
|
|
|
|
|
|
func TestPlanetOccultation20250114MarsBandContourTimesIncrease(t *testing.T) {
|
|
|
|
|
zone := time.FixedZone("UTC+8", 8*60*60)
|
|
|
|
|
start := time.Date(2025, time.January, 14, 0, 0, 0, 0, zone)
|
|
|
|
|
paths, err := FindPlanetOccultationPaths(
|
|
|
|
|
start, start.Add(24*time.Hour), OccultationMars,
|
|
|
|
|
OccultationPathOptions{
|
|
|
|
|
Step: 20 * time.Minute, TargetSpacingKM: 900,
|
|
|
|
|
DisableFootprints: true, IncludeFootprintTimeline: true,
|
|
|
|
|
FootprintTimelineStep: 5 * time.Minute, RiseSetStep: time.Minute,
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
if err != nil || len(paths) != 1 {
|
|
|
|
|
t.Fatalf("FindPlanetOccultationPaths() paths=%d err=%v, want one", len(paths), err)
|
|
|
|
|
}
|
|
|
|
|
for _, band := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
contours [][]OccultationPathPoint
|
|
|
|
|
}{
|
|
|
|
|
{name: "partial", contours: paths[0].PartialBandContours},
|
|
|
|
|
{name: "total", contours: paths[0].TotalBandContours},
|
|
|
|
|
} {
|
|
|
|
|
for contourIndex, contour := range band.contours {
|
|
|
|
|
for pointIndex := 1; pointIndex < len(contour); pointIndex++ {
|
|
|
|
|
previous, current := contour[pointIndex-1], contour[pointIndex]
|
|
|
|
|
if !current.Time.After(previous.Time) {
|
|
|
|
|
t.Fatalf(
|
|
|
|
|
"%s contour %d times do not increase at %d: %s then %s (delta=%s, distance=%.6f km)",
|
|
|
|
|
band.name, contourIndex, pointIndex,
|
|
|
|
|
previous.Time.Format(time.RFC3339Nano), current.Time.Format(time.RFC3339Nano),
|
|
|
|
|
current.Time.Sub(previous.Time), occultationPathDistanceKM(previous, current),
|
|
|
|
|
)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
