490 lines
22 KiB
Go
490 lines
22 KiB
Go
|
package basic
|
||
|
|
|
||
|
|
import (
|
||
|
|
"math"
|
||
|
|
"testing"
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"b612.me/astro/internal/geodata"
|
||
|
|
"b612.me/astro/moon/limb"
|
||
|
|
)
|
||
|
|
|
||
|
|
// recordingLunarLimb 记录最后一次查询参数，返回固定半径。
|
||
|
|
type recordingLunarLimb struct {
|
||
|
|
lon, lat, angle float64
|
||
|
|
radiusKM float64
|
||
|
|
}
|
||
|
|
|
||
|
|
func (limb *recordingLunarLimb) LimbRadiusKM(lon, lat, angle float64) (float64, bool) {
|
||
|
|
limb.lon, limb.lat, limb.angle = lon, lat, angle
|
||
|
|
return limb.radiusKM, true
|
||
|
|
}
|
||
|
|
|
||
|
|
func lunarLimbAngleDiff(a, b float64) float64 {
|
||
|
|
d := math.Mod(a-b, 360)
|
||
|
|
if d > 180 {
|
||
|
|
d -= 360
|
||
|
|
}
|
||
|
|
if d < -180 {
|
||
|
|
d += 360
|
||
|
|
}
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
|
||
|
|
// 地心观测者所见的月面经纬必须还原该时刻的总天平动；目标位于月球北极投影方向时位置角为 0，
|
||
|
|
// 向天东转 90° 时为 90°。
|
||
|
|
func TestLunarLimbFrameRoundTrip(t *testing.T) {
|
||
|
|
for _, jde := range []float64{2460409.25, 2451545.0, 2462000.7} {
|
||
|
|
_, moon := solarEclipseSunMoonEquatorial(jde)
|
||
|
|
moonXYZ := solarEclipseLLRToXYZ(moon[0], moon[1], moon[2])
|
||
|
|
limb := &recordingLunarLimb{radiusKM: 1737.4}
|
||
|
|
frame := newLunarLimbFrame(limb, jde, moonXYZ)
|
||
|
|
if !frame.valid {
|
||
|
|
t.Fatalf("jde %v: frame invalid", jde)
|
||
|
|
}
|
||
|
|
physical := MoonPhysical(jde)
|
||
|
|
moonUnit, _ := lunarLimbNormalize(moonXYZ)
|
||
|
|
north, east, _ := lunarLimbSkyBasis(moonUnit)
|
||
|
|
|
||
|
|
for _, offset := range []float64{0, 90, 200} {
|
||
|
|
pa := (physical.PositionAngle + offset) * rad
|
||
|
|
// 目标放在月心旁 0.5° 处、位置角为 P + offset。
|
||
|
|
sky := lunarLimbCombine(math.Cos(pa), north, math.Sin(pa), east)
|
||
|
|
target := lunarLimbCombine(math.Cos(0.5*rad), moonUnit, math.Sin(0.5*rad), sky)
|
||
|
|
target = [3]float64{target[0] * 1.5e8, target[1] * 1.5e8, target[2] * 1.5e8}
|
||
|
|
if _, ok := frame.radiusKM(moonXYZ, target, false); !ok {
|
||
|
|
t.Fatalf("jde %v: radiusKM failed", jde)
|
||
|
|
}
|
||
|
|
if d := lunarLimbAngleDiff(limb.lon, physical.LibrationLongitude); math.Abs(d) > 1e-6 {
|
||
|
|
t.Errorf("jde %v: libration longitude %.9f, want %.9f", jde, limb.lon, physical.LibrationLongitude)
|
||
|
|
}
|
||
|
|
if d := limb.lat - physical.LibrationLatitude; math.Abs(d) > 1e-6 {
|
||
|
|
t.Errorf("jde %v: libration latitude %.9f, want %.9f", jde, limb.lat, physical.LibrationLatitude)
|
||
|
|
}
|
||
|
|
if d := lunarLimbAngleDiff(limb.angle, -offset); math.Abs(d) > 1e-6 {
|
||
|
|
t.Errorf("jde %v offset %v: position angle %.9f", jde, offset, limb.angle)
|
||
|
|
}
|
||
|
|
if _, ok := frame.radiusKM(moonXYZ, target, true); !ok {
|
||
|
|
t.Fatalf("jde %v: away radiusKM failed", jde)
|
||
|
|
}
|
||
|
|
if d := lunarLimbAngleDiff(limb.angle, 180-offset); math.Abs(d) > 1e-6 {
|
||
|
|
t.Errorf("jde %v offset %v: away position angle %.9f", jde, offset, limb.angle)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// 参考球半径等于 k·R⊕ 的常数月缘只能让结果在末位附近变化，用来确认替换路径本身不引入偏差。
|
||
|
|
func TestLocalSolarEclipseConstantLimbMatchesCircular(t *testing.T) {
|
||
|
|
const seed, lon, lat = 2460409.25, -96.8, 32.8 // 2024-04-08，达拉斯附近
|
||
|
|
options := SolarEclipseOptions{RadiusModel: SolarEclipseModelIAUSingleK}
|
||
|
|
circular := LocalSolarEclipseWithOptionsWithInstance(seed, lon, lat, 0, options, nil)
|
||
|
|
if !circular.HasTotal {
|
||
|
|
t.Fatalf("expected total eclipse, got %v", circular.Type)
|
||
|
|
}
|
||
|
|
options.LunarLimb = &recordingLunarLimb{
|
||
|
|
radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseIAUSingleRadiusK * localSolarMoonRadiusScale,
|
||
|
|
}
|
||
|
|
limbed := LocalSolarEclipseWithOptionsWithInstance(seed, lon, lat, 0, options, nil)
|
||
|
|
for _, pair := range [][2]float64{
|
||
|
|
{circular.PartialStart, limbed.PartialStart},
|
||
|
|
{circular.CentralStart, limbed.CentralStart},
|
||
|
|
{circular.CentralEnd, limbed.CentralEnd},
|
||
|
|
{circular.PartialEnd, limbed.PartialEnd},
|
||
|
|
} {
|
||
|
|
if d := math.Abs(pair[0]-pair[1]) * 86400; d > 1e-3 {
|
||
|
|
t.Errorf("contact moved by %.6f s with a constant limb", d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestLunarEclipseConstantLimbMatchesCircular(t *testing.T) {
|
||
|
|
limb := &recordingLunarLimb{radiusKM: lunarMoonRadiusScale}
|
||
|
|
for _, chauvenet := range []bool{false, true} {
|
||
|
|
circular := LunarEclipseDanjonWithInstance(2460926.0, nil)
|
||
|
|
if chauvenet {
|
||
|
|
circular = LunarEclipseChauvenetWithInstance(2460926.0, nil)
|
||
|
|
}
|
||
|
|
limbed := LunarEclipseWithLunarLimb(circular, limb, nil)
|
||
|
|
for _, pair := range [][2]float64{
|
||
|
|
{circular.PenumbralStart, limbed.PenumbralStart},
|
||
|
|
{circular.PartialStart, limbed.PartialStart},
|
||
|
|
{circular.TotalStart, limbed.TotalStart},
|
||
|
|
{circular.TotalEnd, limbed.TotalEnd},
|
||
|
|
{circular.PartialEnd, limbed.PartialEnd},
|
||
|
|
{circular.PenumbralEnd, limbed.PenumbralEnd},
|
||
|
|
} {
|
||
|
|
if d := math.Abs(pair[0]-pair[1]) * 86400; d > 0.05 {
|
||
|
|
t.Errorf("chauvenet=%v: contact moved by %.4f s with a constant limb", chauvenet, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if limbed.Maximum != circular.Maximum || limbed.Magnitude != circular.Magnitude {
|
||
|
|
t.Error("maximum or magnitude changed")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if got := LunarEclipseWithLunarLimb(LunarEclipseDanjonWithInstance(2460926.0, nil), nil, nil); got != LunarEclipseDanjonWithInstance(2460926.0, nil) {
|
||
|
|
t.Error("nil limb must return the input unchanged")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestOccultationConstantLimbMatchesCircular(t *testing.T) {
|
||
|
|
limb := &recordingLunarLimb{radiusKM: moonEquatorialRadiusKM}
|
||
|
|
start := time.Date(2024, time.August, 21, 1, 30, 0, 0, time.UTC)
|
||
|
|
end := time.Date(2024, time.August, 21, 4, 0, 0, 0, time.UTC)
|
||
|
|
observer := Observer{Longitude: -30.072, Latitude: 16.21}
|
||
|
|
plain, err := FindPlanetOccultationsWithInstance(start, end, OccultationSaturn,
|
||
|
|
observer.Longitude, observer.Latitude, 0, OccultationSearchOptions{}, nil)
|
||
|
|
if err != nil || len(plain) != 1 {
|
||
|
|
t.Fatalf("circular planet search: %v, %d events", err, len(plain))
|
||
|
|
}
|
||
|
|
limbed, err := FindPlanetOccultationsWithInstance(start, end, OccultationSaturn,
|
||
|
|
observer.Longitude, observer.Latitude, 0, OccultationSearchOptions{LunarLimb: limb}, nil)
|
||
|
|
if err != nil || len(limbed) != 1 {
|
||
|
|
t.Fatalf("limb planet search: %v, %d events", err, len(limbed))
|
||
|
|
}
|
||
|
|
a, b := plain[0], limbed[0]
|
||
|
|
for i, pair := range [][2]time.Time{
|
||
|
|
{a.ExternalImmersion, b.ExternalImmersion}, {a.InternalImmersion, b.InternalImmersion},
|
||
|
|
{a.InternalEmersion, b.InternalEmersion}, {a.ExternalEmersion, b.ExternalEmersion},
|
||
|
|
} {
|
||
|
|
if d := math.Abs(pair[0].Sub(pair[1]).Seconds()); d > 0.01 {
|
||
|
|
t.Errorf("planet contact %d moved by %.4f s with a constant limb", i, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !a.Greatest.Equal(b.Greatest) || a.Type != b.Type {
|
||
|
|
t.Error("greatest or type changed")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestGlobalSolarEclipseConstantLimbMatchesCircular(t *testing.T) {
|
||
|
|
// IAU Single-K 的内外 k 相同，常数月缘可同时复现外切与内切半径。
|
||
|
|
limb := &recordingLunarLimb{radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseIAUSingleRadiusK * localSolarMoonRadiusScale}
|
||
|
|
options := SolarEclipseOptions{RadiusModel: SolarEclipseModelIAUSingleK}
|
||
|
|
for _, seed := range []float64{2460409.0, 2460232.0} {
|
||
|
|
circular := SolarEclipseWithOptionsWithInstance(seed, options, nil)
|
||
|
|
withLimb := options
|
||
|
|
withLimb.LunarLimb = limb
|
||
|
|
limbed := SolarEclipseWithOptionsWithInstance(seed, withLimb, nil)
|
||
|
|
for i, pair := range [][2]float64{
|
||
|
|
{circular.PartialBeginOnEarth, limbed.PartialBeginOnEarth},
|
||
|
|
{circular.PartialEndOnEarth, limbed.PartialEndOnEarth},
|
||
|
|
} {
|
||
|
|
if d := math.Abs(pair[0]-pair[1]) * 86400; d > 0.05 {
|
||
|
|
t.Errorf("seed %.0f contact %d moved by %.4f s with a constant limb", seed, i, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if limbed.GreatestEclipse != circular.GreatestEclipse || limbed.Type != circular.Type ||
|
||
|
|
limbed.CentralBeginOnEarth != circular.CentralBeginOnEarth || limbed.PathWidthKM != circular.PathWidthKM {
|
||
|
|
t.Errorf("seed %.0f: non-contact fields changed", seed)
|
||
|
|
}
|
||
|
|
if d := math.Abs(limbed.CentralDurationDays-circular.CentralDurationDays) * 86400; d > 0.05 {
|
||
|
|
t.Errorf("seed %.0f: central duration moved by %.4f s with a constant limb", seed, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestCentralPathConstantLimbKeepsLimits(t *testing.T) {
|
||
|
|
limb := &recordingLunarLimb{radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseUmbralK * localSolarMoonRadiusScale}
|
||
|
|
for _, seed := range []float64{2460409.0, 2460232.0} {
|
||
|
|
circular := SolarEclipseCentralPathNASABulletinSplitKWithInstance(seed, SolarEclipsePathOptions{}, nil)
|
||
|
|
limbed := SolarEclipseCentralPathNASABulletinSplitKWithInstance(seed, SolarEclipsePathOptions{LunarLimb: limb}, nil)
|
||
|
|
if len(circular.NorthernLimit) == 0 || len(limbed.NorthernLimit) != len(circular.NorthernLimit) ||
|
||
|
|
len(limbed.SouthernLimit) != len(circular.SouthernLimit) {
|
||
|
|
t.Fatalf("seed %.0f: limit lengths %d/%d vs %d/%d", seed,
|
||
|
|
len(limbed.NorthernLimit), len(limbed.SouthernLimit), len(circular.NorthernLimit), len(circular.SouthernLimit))
|
||
|
|
}
|
||
|
|
worst := 0.0
|
||
|
|
for _, pair := range [][2][]SolarEclipsePathPoint{{circular.NorthernLimit, limbed.NorthernLimit}, {circular.SouthernLimit, limbed.SouthernLimit}} {
|
||
|
|
for i := range pair[0] {
|
||
|
|
d := math.Hypot((pair[0][i].Longitude-pair[1][i].Longitude)*math.Cos(pair[0][i].Latitude*rad), pair[0][i].Latitude-pair[1][i].Latitude) * 111.2
|
||
|
|
worst = math.Max(worst, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if worst > 0.05 {
|
||
|
|
t.Errorf("seed %.0f: constant limb moved a limit by %.3f km", seed, worst)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestOccultationPathConstantLimbKeepsLimits(t *testing.T) {
|
||
|
|
limb := &recordingLunarLimb{radiusKM: moonEquatorialRadiusKM}
|
||
|
|
star := StarCoordinate{
|
||
|
|
ID: "HR 4799", RA: 189.1975, Dec: -5.831944444444,
|
||
|
|
Epoch: time.Date(2000, 1, 1, 12, 0, 0, 0, time.UTC), Frame: CoordinateFrameJ2000,
|
||
|
|
ProperMotionRACosDecMasPerYear: -28, ProperMotionDecMasPerYear: -18,
|
||
|
|
}
|
||
|
|
start := time.Date(2025, 6, 4, 16, 0, 0, 0, time.UTC)
|
||
|
|
end := time.Date(2025, 6, 5, 16, 0, 0, 0, time.UTC)
|
||
|
|
options := OccultationPathOptions{Step: 5 * time.Minute, TargetSpacingKM: 200, DisableFootprints: true, DisableRiseSet: true}
|
||
|
|
circular, err := FindStarOccultationPathsWithInstance(start, end, star, options, nil)
|
||
|
|
if err != nil || len(circular) != 1 {
|
||
|
|
t.Fatalf("circular: %v %d", err, len(circular))
|
||
|
|
}
|
||
|
|
options.LunarLimb = limb
|
||
|
|
limbed, err := FindStarOccultationPathsWithInstance(start, end, star, options, nil)
|
||
|
|
if err != nil || len(limbed) != 1 {
|
||
|
|
t.Fatalf("limbed: %v %d", err, len(limbed))
|
||
|
|
}
|
||
|
|
worst := 0.0
|
||
|
|
for _, pair := range [][2][]OccultationPathPoint{{circular[0].NorthernLimit, limbed[0].NorthernLimit}, {circular[0].SouthernLimit, limbed[0].SouthernLimit}} {
|
||
|
|
if len(pair[0]) == 0 || len(pair[0]) != len(pair[1]) {
|
||
|
|
t.Fatalf("limit lengths %d vs %d", len(pair[0]), len(pair[1]))
|
||
|
|
}
|
||
|
|
for i := range pair[0] {
|
||
|
|
d := math.Hypot((pair[0][i].Longitude-pair[1][i].Longitude)*math.Cos(pair[0][i].Latitude*rad), pair[0][i].Latitude-pair[1][i].Latitude) * 111.2
|
||
|
|
worst = math.Max(worst, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if worst > 0.05 {
|
||
|
|
t.Errorf("constant limb moved a graze limit by %.3f km", worst)
|
||
|
|
}
|
||
|
|
if limbed[0].LunarLimbApplied {
|
||
|
|
t.Fatal("constant circular limb set LunarLimbApplied = true")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestCentralPathConstantLimbKeepsWidthsAndBand(t *testing.T) {
|
||
|
|
limb := &recordingLunarLimb{radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseUmbralK * localSolarMoonRadiusScale}
|
||
|
|
for _, seed := range []float64{2460409.0, 2460232.0} {
|
||
|
|
circular := SolarEclipseCentralPathNASABulletinSplitKWithInstance(seed, SolarEclipsePathOptions{}, nil)
|
||
|
|
limbed := SolarEclipseCentralPathNASABulletinSplitKWithInstance(seed, SolarEclipsePathOptions{LunarLimb: limb}, nil)
|
||
|
|
if len(limbed.CenterLine) != len(circular.CenterLine) || len(limbed.CentralBandSegments) != len(circular.CentralBandSegments) {
|
||
|
|
t.Fatalf("seed %.0f: sample counts changed", seed)
|
||
|
|
}
|
||
|
|
worstWidth := 0.0
|
||
|
|
for i := range circular.CenterLine {
|
||
|
|
worstWidth = math.Max(worstWidth, math.Abs(limbed.CenterLine[i].WidthKM-circular.CenterLine[i].WidthKM))
|
||
|
|
}
|
||
|
|
if worstWidth > 0.1 {
|
||
|
|
t.Errorf("seed %.0f: constant limb moved a width by %.3f km", seed, worstWidth)
|
||
|
|
}
|
||
|
|
if d := math.Abs(limbed.Greatest.WidthKM - circular.Greatest.WidthKM); d > 0.1 {
|
||
|
|
t.Errorf("seed %.0f: greatest width moved by %.3f km", seed, d)
|
||
|
|
}
|
||
|
|
if d := math.Abs(limbed.MaxCentralDurationDays-circular.MaxCentralDurationDays) * 86400; d > 0.05 {
|
||
|
|
t.Errorf("seed %.0f: max duration moved by %.4f s", seed, d)
|
||
|
|
}
|
||
|
|
worstBand := 0.0
|
||
|
|
for s := range circular.CentralBandSegments {
|
||
|
|
if len(limbed.CentralBandSegments[s]) != len(circular.CentralBandSegments[s]) {
|
||
|
|
t.Fatalf("seed %.0f: band segment %d length changed", seed, s)
|
||
|
|
}
|
||
|
|
for i, a := range circular.CentralBandSegments[s] {
|
||
|
|
b := limbed.CentralBandSegments[s][i]
|
||
|
|
d := math.Hypot((a.Longitude-b.Longitude)*math.Cos(a.Latitude*rad), a.Latitude-b.Latitude) * 111.2
|
||
|
|
worstBand = math.Max(worstBand, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if worstBand > 0.1 {
|
||
|
|
t.Errorf("seed %.0f: constant limb moved a band vertex by %.3f km", seed, worstBand)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// failingLunarLimb 处处无值：月缘修正必须整体退回圆月面且不置 LunarLimbApplied。
|
||
|
|
type failingLunarLimb struct{}
|
||
|
|
|
||
|
|
func (failingLunarLimb) LimbRadiusKM(_, _, _ float64) (float64, bool) { return 0, false }
|
||
|
|
|
||
|
|
func TestFailingLimbKeepsEclipsesCircular(t *testing.T) {
|
||
|
|
const seed, lon, lat = 2460409.25, -96.8, 32.8 // 2024-04-08，达拉斯附近
|
||
|
|
limb := failingLunarLimb{}
|
||
|
|
for _, model := range []SolarEclipseRadiusModel{SolarEclipseModelNASABulletinSplitK, SolarEclipseModelIAUSingleK} {
|
||
|
|
options := SolarEclipseOptions{RadiusModel: model}
|
||
|
|
withLimb := options
|
||
|
|
withLimb.LunarLimb = limb
|
||
|
|
|
||
|
|
circularLocal := LocalSolarEclipseWithOptionsWithInstance(seed, lon, lat, 0, options, nil)
|
||
|
|
limbedLocal := LocalSolarEclipseWithOptionsWithInstance(seed, lon, lat, 0, withLimb, nil)
|
||
|
|
if limbedLocal != circularLocal {
|
||
|
|
t.Errorf("model %v: failing limb changed the local result", model)
|
||
|
|
}
|
||
|
|
|
||
|
|
circularGlobal := SolarEclipseWithOptionsWithInstance(seed, options, nil)
|
||
|
|
limbedGlobal := SolarEclipseWithOptionsWithInstance(seed, withLimb, nil)
|
||
|
|
if limbedGlobal.LunarLimbApplied ||
|
||
|
|
limbedGlobal.PartialBeginOnEarth != circularGlobal.PartialBeginOnEarth ||
|
||
|
|
limbedGlobal.PartialEndOnEarth != circularGlobal.PartialEndOnEarth ||
|
||
|
|
limbedGlobal.CentralDurationDays != circularGlobal.CentralDurationDays {
|
||
|
|
t.Errorf("model %v: failing limb changed the global result or set LunarLimbApplied", model)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
circularLunar := LunarEclipseDanjonWithInstance(2460926.0, nil)
|
||
|
|
if got := LunarEclipseWithLunarLimb(circularLunar, limb, nil); got != circularLunar {
|
||
|
|
t.Error("failing limb changed the lunar eclipse result")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestPartialBoundaryLimbCorrection(t *testing.T) {
|
||
|
|
const seed = 2460409.25 // 2024-04-08
|
||
|
|
circularOptions := SolarEclipsePartialFootprintOptions{}
|
||
|
|
circular := solarEclipsePartialFootprints(seed, SolarEclipseModelIAUSingleK, circularOptions, nil)
|
||
|
|
if len(circular.PartialBandContours) == 0 || len(circular.RiseSetCurves) == 0 {
|
||
|
|
t.Fatal("circular partial boundary missing")
|
||
|
|
}
|
||
|
|
samePoints := func(a, b []SolarEclipsePathPoint, toleranceKM float64) float64 {
|
||
|
|
worst := 0.0
|
||
|
|
for index := range a {
|
||
|
|
km := math.Hypot(signedAngleDifference(a[index].Longitude, b[index].Longitude)*111.19*math.Cos(a[index].Latitude*rad),
|
||
|
|
(a[index].Latitude-b[index].Latitude)*111.19)
|
||
|
|
worst = math.Max(worst, km)
|
||
|
|
}
|
||
|
|
return worst
|
||
|
|
}
|
||
|
|
compare := func(name string, limb LunarLimb, wantApplied bool, maxShiftKM float64) {
|
||
|
|
options := circularOptions
|
||
|
|
options.LunarLimb = limb
|
||
|
|
limbed := solarEclipsePartialFootprints(seed, SolarEclipseModelIAUSingleK, options, nil)
|
||
|
|
if limbed.PartialBoundaryLimbApplied != wantApplied {
|
||
|
|
t.Errorf("%s: PartialBoundaryLimbApplied = %v, want %v", name, limbed.PartialBoundaryLimbApplied, wantApplied)
|
||
|
|
}
|
||
|
|
if limbed.RiseSetTopologyDegraded {
|
||
|
|
t.Errorf("%s: rise/set topology degraded", name)
|
||
|
|
}
|
||
|
|
if len(limbed.PartialBandContours) != len(circular.PartialBandContours) || len(limbed.RiseSetCurves) != len(circular.RiseSetCurves) {
|
||
|
|
t.Fatalf("%s: boundary structure changed", name)
|
||
|
|
}
|
||
|
|
worst := 0.0
|
||
|
|
for index := range circular.PartialBandContours {
|
||
|
|
worst = math.Max(worst, samePoints(circular.PartialBandContours[index], limbed.PartialBandContours[index], 0))
|
||
|
|
}
|
||
|
|
for index, curve := range circular.RiseSetCurves {
|
||
|
|
for segment := range curve.Segments {
|
||
|
|
shift := samePoints(curve.Segments[segment], limbed.RiseSetCurves[index].Segments[segment], 0)
|
||
|
|
if curve.Phase == RiseSetPhaseGreatest && shift != 0 {
|
||
|
|
t.Errorf("%s: greatest rise/set curve moved by %.3f km", name, shift)
|
||
|
|
}
|
||
|
|
worst = math.Max(worst, shift)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if worst > maxShiftKM {
|
||
|
|
t.Errorf("%s: boundary moved by %.3f km, want <= %.3f km", name, worst, maxShiftKM)
|
||
|
|
}
|
||
|
|
if wantApplied && worst < 0.5 {
|
||
|
|
t.Errorf("%s: boundary moved only %.3f km", name, worst)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
compare("failing", failingLunarLimb{}, false, 0)
|
||
|
|
compare("constant", &recordingLunarLimb{
|
||
|
|
radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseIAUSingleRadiusK * localSolarMoonRadiusScale,
|
||
|
|
}, false, 0.05)
|
||
|
|
compare("profile", sawtoothLunarLimb{}, true, limbLimitMaxShiftKM)
|
||
|
|
}
|
||
|
|
|
||
|
|
// sawtoothLunarLimb 以位置角 10° 为周期在参考半径上叠加 ±3 km 起伏，模拟月缘山谷。
|
||
|
|
type sawtoothLunarLimb struct{}
|
||
|
|
|
||
|
|
func (sawtoothLunarLimb) LimbRadiusKM(_, _, angle float64) (float64, bool) {
|
||
|
|
phase := math.Mod(angle, 10) / 10
|
||
|
|
return geodata.EarthEquatorialRadiusKM*solarEclipseIAUSingleRadiusK*localSolarMoonRadiusScale + 6*math.Abs(phase-0.5) - 1.5, true
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestGlobalSolarEclipseLimbContactMatchesTime 检查月缘修正后的偏食始末接触点与修正时刻同源：
|
||
|
|
// 接触点必须落在该时刻重解的半影外切点上，而不是沿地球边缘扫描网格上的样点。
|
||
|
|
func TestGlobalSolarEclipseLimbContactMatchesTime(t *testing.T) {
|
||
|
|
for _, seed := range []float64{2460409.25, 2460232.25, 2461275.25} {
|
||
|
|
options := SolarEclipseOptions{RadiusModel: SolarEclipseModelNASABulletinSplitK, LunarLimb: limb.Default()}
|
||
|
|
result := SolarEclipseWithOptionsWithInstance(seed, options, nil)
|
||
|
|
if !result.LunarLimbApplied {
|
||
|
|
t.Fatalf("seed %.2f: the default limb profile changed nothing", seed)
|
||
|
|
}
|
||
|
|
solver := newSolarEclipseSolverWithOptions(CalcMoonSHByJDE(seed, 0), options, nil)
|
||
|
|
for _, pair := range []struct {
|
||
|
|
name string
|
||
|
|
jde float64
|
||
|
|
contact SolarEclipseLimbContact
|
||
|
|
}{
|
||
|
|
{"P1", result.PartialBeginOnEarth, result.PartialBeginContact},
|
||
|
|
{"P4", result.PartialEndOnEarth, result.PartialEndContact},
|
||
|
|
} {
|
||
|
|
if !pair.contact.Defined {
|
||
|
|
t.Errorf("seed %.2f %s: the corrected contact location is missing", seed, pair.name)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
point, ok := solver.shadowContactPointAt(pair.jde, solarEclipsePenumbralShadow, false)
|
||
|
|
if !ok {
|
||
|
|
t.Errorf("seed %.2f %s: no penumbral tangent point at the corrected time", seed, pair.name)
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
longitude := signedAngleDifference(pair.contact.Longitude, point.Longitude) * math.Cos(point.Latitude*rad)
|
||
|
|
if d := math.Hypot(longitude, pair.contact.Latitude-point.Latitude) * geodata.EarthKMPerDegree; d > 0.05 {
|
||
|
|
t.Errorf("seed %.2f %s: contact location is %.3f km from the tangent point at its own time", seed, pair.name, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestLimbFlagsIgnoreNoiseWithConstantLimb 检查常数月缘等价于圆月面时，各层月缘标志都不因离散残差误报。
|
||
|
|
func TestLimbFlagsIgnoreNoiseWithConstantLimb(t *testing.T) {
|
||
|
|
iau := &recordingLunarLimb{radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseIAUSingleRadiusK * localSolarMoonRadiusScale}
|
||
|
|
umbral := &recordingLunarLimb{radiusKM: geodata.EarthEquatorialRadiusKM * solarEclipseUmbralK * localSolarMoonRadiusScale}
|
||
|
|
for _, seed := range []float64{2460409.25, 2460232.25, 2461275.25} {
|
||
|
|
global := SolarEclipseWithOptionsWithInstance(seed, SolarEclipseOptions{RadiusModel: SolarEclipseModelIAUSingleK, LunarLimb: iau}, nil)
|
||
|
|
if global.LunarLimbApplied || global.PartialBeginContact.Defined || global.PartialEndContact.Defined {
|
||
|
|
t.Errorf("seed %.2f: constant limb reported a global correction", seed)
|
||
|
|
}
|
||
|
|
central := SolarEclipseCentralPathNASABulletinSplitKWithInstance(seed, SolarEclipsePathOptions{LunarLimb: umbral}, nil)
|
||
|
|
if central.CentralLimitsLimbApplied {
|
||
|
|
t.Errorf("seed %.2f: constant limb reported moved central limits", seed)
|
||
|
|
}
|
||
|
|
local := LocalSolarEclipseWithOptionsWithInstance(seed, -96.8, 32.8, 0, SolarEclipseOptions{RadiusModel: SolarEclipseModelIAUSingleK, LunarLimb: iau}, nil)
|
||
|
|
if local.LunarLimbApplied {
|
||
|
|
t.Errorf("seed %.2f: constant limb reported a local correction", seed)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
real := SolarEclipseCentralPathNASABulletinSplitKWithInstance(2460409.25, SolarEclipsePathOptions{LunarLimb: limb.Default()}, nil)
|
||
|
|
if !real.CentralLimitsLimbApplied {
|
||
|
|
t.Error("default limb profile must move the central limits")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestLocalSolarEclipseLimbFlagCoversMagnitude 检查只改变食分、遮蔽率而不改变接触时刻时站心标志仍为真。
|
||
|
|
func TestLocalSolarEclipseLimbFlagCoversMagnitude(t *testing.T) {
|
||
|
|
circular := LocalSolarEclipseResult{Type: SolarEclipsePartial, PartialStart: 1, PartialEnd: 2, Magnitude: 0.5, Obscuration: 0.4}
|
||
|
|
limbed := circular
|
||
|
|
if localSolarEclipseLimbChanged(limbed, circular) {
|
||
|
|
t.Fatal("identical results reported a change")
|
||
|
|
}
|
||
|
|
limbed.Magnitude += 1e-12
|
||
|
|
if localSolarEclipseLimbChanged(limbed, circular) {
|
||
|
|
t.Error("floating-point noise in magnitude reported a change")
|
||
|
|
}
|
||
|
|
limbed.Magnitude = circular.Magnitude + 1e-6
|
||
|
|
if !localSolarEclipseLimbChanged(limbed, circular) {
|
||
|
|
t.Error("a visible magnitude change was not reported")
|
||
|
|
}
|
||
|
|
limbed = circular
|
||
|
|
limbed.Obscuration += 1e-6
|
||
|
|
if !localSolarEclipseLimbChanged(limbed, circular) {
|
||
|
|
t.Error("a visible obscuration change was not reported")
|
||
|
|
}
|
||
|
|
limbed = circular
|
||
|
|
limbed.Type = SolarEclipseAnnular
|
||
|
|
if !localSolarEclipseLimbChanged(limbed, circular) {
|
||
|
|
t.Error("a type change was not reported")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// steppedLunarLimb 报告指定网格步长的常半径剖面。
|
||
|
|
type steppedLunarLimb struct{ step float64 }
|
||
|
|
|
||
|
|
func (limb steppedLunarLimb) LimbRadiusKM(lon, lat, angle float64) (float64, bool) {
|
||
|
|
return 1737.4, true
|
||
|
|
}
|
||
|
|
func (limb steppedLunarLimb) RadiusRangeKM() (float64, float64) { return 1737.4, 1737.4 }
|
||
|
|
func (limb steppedLunarLimb) AngleStepDeg() float64 { return limb.step }
|
||
|
|
|
||
|
|
func TestLunarLimbFrameRejectsTinyStep(t *testing.T) {
|
||
|
|
_, moon := solarEclipseSunMoonEquatorial(2460409.25)
|
||
|
|
moonXYZ := solarEclipseLLRToXYZ(moon[0], moon[1], moon[2])
|
||
|
|
for _, c := range []struct{ step, want float64 }{
|
||
|
|
{1e-300, lunarLimbDefaultStepDeg}, {1e-4, lunarLimbDefaultStepDeg}, {0.001, 0.001}, {0.5, 0.5}, {2, lunarLimbDefaultStepDeg},
|
||
|
|
} {
|
||
|
|
frame := newLunarLimbFrame(steppedLunarLimb{c.step}, 2460409.25, moonXYZ)
|
||
|
|
if !frame.valid || frame.stepDeg != c.want {
|
||
|
|
t.Errorf("step %g: got %g valid=%v, want %g", c.step, frame.stepDeg, frame.valid, c.want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|