b612
2bf8478639
- 新增日月食中心带、偏食带、阴影足迹、等时线、食分线及升落边界计算，支持极区与混合食拓扑 - 新增日食单时刻阴影求解器、站心状态查询、批量采样和 ΔT 覆盖接口 - 重构恒星与行星月掩路径，补充有限盘面接触、站心修正、掩带宽度、极区投影及升落边界 - 扩展 SVG 与 GeoJSON 输出，支持详细面板、全球/极区/地球投影、边界闭合、时间标记和拓扑签名 - 扩展日月食候选搜索、局地搜索、沙罗序列预计算与范围外推，补充系列锚点和成员一致性校验 - 补齐古历纪年、儒略历独有闰日、多公历候选、历法改革跨日及精确日期运算接口 - 优化 ΔT、章动、恒星时、月球地平线、事件根搜索和本地星历缓存，降低重复计算开销并提升边界稳定
435 lines
14 KiB
Go
435 lines
14 KiB
Go
package basic
|
|
|
|
import "math"
|
|
|
|
// LocalSolarEclipseResult 表示某个站点的一次站心日食几何结果。
|
|
//
|
|
// 所有时刻字段都使用力学时儒略日（JDE, TT）。
|
|
// 输入 seedJDE 只需要落在目标朔月附近，允许相差数天。
|
|
type LocalSolarEclipseResult struct {
|
|
Model SolarEclipseRadiusModel
|
|
Type SolarEclipseType
|
|
|
|
// GreatestEclipse 是站心盘面中心角距最小的时刻。
|
|
GreatestEclipse float64
|
|
|
|
// PartialStart / PartialEnd 是站心偏食始 / 偏食终。
|
|
PartialStart float64
|
|
PartialEnd float64
|
|
// CentralStart / CentralEnd 是站心中心食始 / 中心食终。
|
|
//
|
|
// 对全食对应食既 / 生光；
|
|
// 对环食对应环食始 / 环食终。
|
|
CentralStart float64
|
|
CentralEnd float64
|
|
|
|
// Magnitude 是站心食分。
|
|
Magnitude float64
|
|
// Obscuration 是食甚时太阳视圆面被月面遮蔽的面积比例，范围 [0, 1]。
|
|
Obscuration float64
|
|
// Separation 是食甚时日月中心的站心角距，单位为度。
|
|
Separation float64
|
|
|
|
// SunAltitude / SunAzimuth 是食甚时太阳的站心高度角 / 方位角，单位为度。
|
|
SunAltitude float64
|
|
SunAzimuth float64
|
|
|
|
// VisibleAtGreatest 表示食甚时太阳中心在地平线上方。
|
|
VisibleAtGreatest bool
|
|
|
|
HasPartial bool
|
|
HasCentral bool
|
|
HasAnnular bool
|
|
HasTotal bool
|
|
}
|
|
|
|
type localSolarEclipseState struct {
|
|
separationRad float64
|
|
separationSquared float64
|
|
sunRadiusRad float64
|
|
moonOuterRadiusRad float64
|
|
moonInnerRadiusRad float64
|
|
sunAltitudeRad float64
|
|
sunAzimuthRad float64
|
|
}
|
|
|
|
func (state localSolarEclipseState) movingDiskContactState() movingDiskContactState {
|
|
return movingDiskContactState{
|
|
separation: state.separationRad,
|
|
occultingOuterRadius: state.moonOuterRadiusRad,
|
|
occultingInnerRadius: state.moonInnerRadiusRad,
|
|
targetRadius: state.sunRadiusRad,
|
|
valid: movingDiskContactStateValid(
|
|
state.separationRad,
|
|
state.moonOuterRadiusRad,
|
|
state.moonInnerRadiusRad,
|
|
state.sunRadiusRad,
|
|
),
|
|
}
|
|
}
|
|
|
|
type localSolarEclipseStateContext struct {
|
|
sunXYZ [3]float64
|
|
moonXYZ [3]float64
|
|
gst float64
|
|
params solarEclipseModelParameters
|
|
// generation 记录写入缓存时的 ΔT 世代（gst 依赖 ΔT，覆盖 ΔT 后条目必须失效）。
|
|
// generation is the ΔT generation the cached context was built under; gst depends on
|
|
// ΔT, so an override must invalidate the entry.
|
|
generation uint64
|
|
}
|
|
|
|
const (
|
|
localSolarEclipseGreatestWindowDays = 0.5
|
|
localSolarEclipseGreatestTolerance = 1e-8
|
|
localSolarEclipseContactStepDays = 10.0 / 1440.0
|
|
localSolarEclipseContactSearchSteps = 72
|
|
localSolarEclipseContactTolerance = 1e-8
|
|
localSolarMoonRadiusScale = 1.0000036
|
|
)
|
|
|
|
// LocalSolarEclipse 计算给定近朔时刻附近的一次站心日食，默认使用 NASA bulletin Split-K 模型。
|
|
//
|
|
// seedJDE 为力学时儒略日（TT），只需落在目标朔月附近，允许相差数天。
|
|
// lon 为经度，东正西负；lat 为纬度，北正南负；height 为海拔高度，单位米。
|
|
func LocalSolarEclipse(seedJDE, lon, lat, height float64) LocalSolarEclipseResult {
|
|
return LocalSolarEclipseNASABulletinSplitK(seedJDE, lon, lat, height)
|
|
}
|
|
|
|
// LocalSolarEclipseIAUSingleK 计算给定近朔时刻附近的一次站心日食，使用 IAU Single-K 模型。
|
|
func LocalSolarEclipseIAUSingleK(seedJDE, lon, lat, height float64) LocalSolarEclipseResult {
|
|
return localSolarEclipse(seedJDE, lon, lat, height, SolarEclipseModelIAUSingleK)
|
|
}
|
|
|
|
// LocalSolarEclipseNASABulletinSplitK 计算给定近朔时刻附近的一次站心日食，使用 NASA bulletin Split-K 模型。
|
|
func LocalSolarEclipseNASABulletinSplitK(seedJDE, lon, lat, height float64) LocalSolarEclipseResult {
|
|
return localSolarEclipse(seedJDE, lon, lat, height, SolarEclipseModelNASABulletinSplitK)
|
|
}
|
|
|
|
func localSolarEclipse(seedJDE, lonDeg, latDeg, heightMeters float64, model SolarEclipseRadiusModel) LocalSolarEclipseResult {
|
|
newMoonJDE := CalcMoonSHByJDE(seedJDE, 0)
|
|
lonRad := lonDeg * rad
|
|
latRad := latDeg * rad
|
|
heightKM := heightMeters / 1000.0
|
|
params := solarEclipseModelParams(model)
|
|
|
|
greatestEclipseJDE := localSolarEclipseGreatest(newMoonJDE, lonRad, latRad, heightKM, params)
|
|
state := localSolarEclipseStateAt(greatestEclipseJDE, lonRad, latRad, heightKM, params)
|
|
contactEvaluator := newLocalSolarEclipseContactEvaluator(lonRad, latRad, heightKM, params)
|
|
visibleThresholdRad := 0.0
|
|
if heightMeters > 0 {
|
|
visibleThresholdRad = -HeightDegreeByLat(heightMeters, latDeg) * rad
|
|
}
|
|
|
|
result := LocalSolarEclipseResult{
|
|
Model: model,
|
|
Type: SolarEclipseNone,
|
|
GreatestEclipse: greatestEclipseJDE,
|
|
Separation: state.separationRad / rad,
|
|
SunAltitude: state.sunAltitudeRad / rad,
|
|
SunAzimuth: state.sunAzimuthRad / rad,
|
|
VisibleAtGreatest: state.sunAltitudeRad > visibleThresholdRad,
|
|
}
|
|
|
|
contactState := state.movingDiskContactState()
|
|
contactEvaluator.prime(greatestEclipseJDE, contactState, contactState.valid)
|
|
partialGap := contactState.externalContactGap()
|
|
if partialGap > 0 {
|
|
return result
|
|
}
|
|
|
|
result.Type = SolarEclipsePartial
|
|
result.HasPartial = true
|
|
result.Magnitude = (state.moonOuterRadiusRad + state.sunRadiusRad - state.separationRad) / (2 * state.sunRadiusRad)
|
|
if result.Magnitude < 0 {
|
|
result.Magnitude = 0
|
|
}
|
|
result.Obscuration = localSolarEclipseObscuration(
|
|
state.sunRadiusRad,
|
|
state.moonOuterRadiusRad,
|
|
state.separationRad,
|
|
)
|
|
|
|
if partialStart, ok := localSolarEclipseContactWithEvaluator(greatestEclipseJDE, contactEvaluator, false, true); ok {
|
|
result.PartialStart = partialStart
|
|
}
|
|
if partialEnd, ok := localSolarEclipseContactWithEvaluator(greatestEclipseJDE, contactEvaluator, false, false); ok {
|
|
result.PartialEnd = partialEnd
|
|
}
|
|
|
|
if contactState.internalContactGap() > 0 {
|
|
return result
|
|
}
|
|
|
|
result.HasCentral = true
|
|
if state.moonInnerRadiusRad >= state.sunRadiusRad {
|
|
result.Type = SolarEclipseTotal
|
|
result.HasTotal = true
|
|
} else {
|
|
result.Type = SolarEclipseAnnular
|
|
result.HasAnnular = true
|
|
}
|
|
result.Magnitude = state.moonInnerRadiusRad / state.sunRadiusRad
|
|
|
|
if centralStart, ok := localSolarEclipseContactWithEvaluator(greatestEclipseJDE, contactEvaluator, true, true); ok {
|
|
result.CentralStart = centralStart
|
|
}
|
|
if centralEnd, ok := localSolarEclipseContactWithEvaluator(greatestEclipseJDE, contactEvaluator, true, false); ok {
|
|
result.CentralEnd = centralEnd
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func solarEclipseModelParams(model SolarEclipseRadiusModel) solarEclipseModelParameters {
|
|
params := solarEclipseModelParameters{
|
|
penumbralK: solarEclipsePenumbralK,
|
|
umbralK: solarEclipsePenumbralK,
|
|
}
|
|
if model == SolarEclipseModelNASABulletinSplitK {
|
|
params.umbralK = solarEclipseUmbralK
|
|
}
|
|
return params
|
|
}
|
|
|
|
func localSolarEclipseGreatest(
|
|
newMoonJDE, lonRad, latRad, heightKM float64,
|
|
params solarEclipseModelParameters,
|
|
) float64 {
|
|
return localSolarEclipseGreatestWith(newMoonJDE, func(jd float64) localSolarEclipseState {
|
|
return localSolarEclipseStateAt(jd, lonRad, latRad, heightKM, params)
|
|
})
|
|
}
|
|
|
|
func localSolarEclipseGreatestWith(
|
|
newMoonJDE float64,
|
|
stateAt func(float64) localSolarEclipseState,
|
|
) float64 {
|
|
left := newMoonJDE - localSolarEclipseGreatestWindowDays
|
|
right := newMoonJDE + localSolarEclipseGreatestWindowDays
|
|
return solarEclipseMovingDiskEngine().greatest(
|
|
newMoonJDE, left, right,
|
|
func(jd float64) (float64, bool) {
|
|
return stateAt(jd).separationSquared, true
|
|
},
|
|
80,
|
|
)
|
|
}
|
|
|
|
// centralPhaseDurationDaysAt 用事件局部插值星历求解某点的中心相时长（日）：先求局部食甚，
|
|
// 再解本影/反本影的内切接触。没有中心相或接触退化时返回 0。
|
|
func (solver solarEclipseSolver) centralPhaseDurationDaysAt(jd, lonDeg, latDeg float64) float64 {
|
|
solver = solver.withLocalEphemeris()
|
|
lonRad, latRad := lonDeg*rad, latDeg*rad
|
|
stateAt := func(jd float64) localSolarEclipseState {
|
|
return solver.localStateContextCandidateAt(jd).stateAt(lonRad, latRad, 0)
|
|
}
|
|
greatestJDE := localSolarEclipseGreatestWith(solver.newMoonJDE, stateAt)
|
|
contactState := stateAt(greatestJDE).movingDiskContactState()
|
|
if !contactState.valid || contactState.internalContactGap() > 0 {
|
|
return 0
|
|
}
|
|
evaluator := newMovingDiskContactEvaluator(func(jd float64) (movingDiskContactState, bool) {
|
|
contact := stateAt(jd).movingDiskContactState()
|
|
return contact, contact.valid
|
|
})
|
|
evaluator.prime(greatestJDE, contactState, true)
|
|
start, ok := localSolarEclipseContactWithEvaluator(greatestJDE, evaluator, true, true)
|
|
if !ok {
|
|
return 0
|
|
}
|
|
end, ok := localSolarEclipseContactWithEvaluator(greatestJDE, evaluator, true, false)
|
|
if !ok || end <= start {
|
|
return 0
|
|
}
|
|
return end - start
|
|
}
|
|
|
|
func newLocalSolarEclipseContactEvaluator(
|
|
lonRad, latRad, heightKM float64,
|
|
params solarEclipseModelParameters,
|
|
) *movingDiskContactEvaluator {
|
|
return newMovingDiskContactEvaluator(func(jdTT float64) (movingDiskContactState, bool) {
|
|
state := localSolarEclipseStateAt(jdTT, lonRad, latRad, heightKM, params)
|
|
contactState := state.movingDiskContactState()
|
|
return contactState, contactState.valid
|
|
})
|
|
}
|
|
|
|
func localSolarEclipseContactWithEvaluator(
|
|
greatestEclipseJDE float64,
|
|
evaluator *movingDiskContactEvaluator,
|
|
central bool,
|
|
beforeGreatest bool,
|
|
) (float64, bool) {
|
|
centerGap, centerOK := evaluator.gap(greatestEclipseJDE, central)
|
|
if !centerOK {
|
|
return 0, false
|
|
}
|
|
if centerGap > 0 {
|
|
return 0, false
|
|
}
|
|
if math.Abs(centerGap) <= 1e-14 {
|
|
return greatestEclipseJDE, true
|
|
}
|
|
|
|
direction := 1.0
|
|
if beforeGreatest {
|
|
direction = -1.0
|
|
}
|
|
return solarEclipseMovingDiskEngine().contactRoot(
|
|
greatestEclipseJDE,
|
|
direction,
|
|
localSolarEclipseContactStepDays,
|
|
localSolarEclipseContactStepDays*localSolarEclipseContactSearchSteps,
|
|
localSolarEclipseContactTolerance,
|
|
func(jd float64) (float64, bool) {
|
|
return evaluator.gap(jd, central)
|
|
},
|
|
80,
|
|
)
|
|
}
|
|
|
|
func localSolarEclipseStateAt(
|
|
jdTT, lonRad, latRad, heightKM float64,
|
|
params solarEclipseModelParameters,
|
|
) localSolarEclipseState {
|
|
return newLocalSolarEclipseStateContext(jdTT, params).stateAt(lonRad, latRad, heightKM)
|
|
}
|
|
|
|
func newLocalSolarEclipseStateContext(
|
|
jdTT float64,
|
|
params solarEclipseModelParameters,
|
|
) localSolarEclipseStateContext {
|
|
return newLocalSolarEclipseStateContextWithOverride(jdTT, math.NaN(), params)
|
|
}
|
|
|
|
// newLocalSolarEclipseStateContextWithOverride 用显式 ΔT 构造站心状态上下文：TT 时刻不变，
|
|
// ΔT 只决定恒星时相位；deltaTSeconds 为 NaN 时走进程级模型。
|
|
func newLocalSolarEclipseStateContextWithOverride(
|
|
jdTT, deltaTSeconds float64,
|
|
params solarEclipseModelParameters,
|
|
) localSolarEclipseStateContext {
|
|
sunEquatorial, moonEquatorial := solarEclipseSunMoonEquatorial(jdTT)
|
|
utJDE := TD2UT(jdTT, false)
|
|
if !math.IsNaN(deltaTSeconds) {
|
|
utJDE = jdTT - deltaTSeconds/86400
|
|
}
|
|
return localSolarEclipseStateContext{
|
|
sunXYZ: solarEclipseLLRToXYZ(sunEquatorial[0], sunEquatorial[1], sunEquatorial[2]),
|
|
moonXYZ: solarEclipseLLRToXYZ(moonEquatorial[0], moonEquatorial[1], moonEquatorial[2]),
|
|
gst: ApparentSiderealTime(utJDE) * 15 * rad,
|
|
params: params,
|
|
}
|
|
}
|
|
|
|
func (context localSolarEclipseStateContext) stateAt(lonRad, latRad, heightKM float64) localSolarEclipseState {
|
|
observerXYZ := localSolarEclipseObserverXYZ(context.gst, lonRad, latRad, heightKM)
|
|
|
|
sunTopocentric := solarEclipseXYZToLLR(
|
|
context.sunXYZ[0]-observerXYZ[0],
|
|
context.sunXYZ[1]-observerXYZ[1],
|
|
context.sunXYZ[2]-observerXYZ[2],
|
|
)
|
|
moonTopocentric := solarEclipseXYZToLLR(
|
|
context.moonXYZ[0]-observerXYZ[0],
|
|
context.moonXYZ[1]-observerXYZ[1],
|
|
context.moonXYZ[2]-observerXYZ[2],
|
|
)
|
|
|
|
sunUnit := solarEclipseLLRToXYZ(sunTopocentric[0], sunTopocentric[1], 1)
|
|
moonUnit := solarEclipseLLRToXYZ(moonTopocentric[0], moonTopocentric[1], 1)
|
|
dot := sunUnit[0]*moonUnit[0] + sunUnit[1]*moonUnit[1] + sunUnit[2]*moonUnit[2]
|
|
if dot > 1 {
|
|
dot = 1
|
|
}
|
|
if dot < -1 {
|
|
dot = -1
|
|
}
|
|
|
|
sunRadiusRad := math.Asin(localSolarEclipseClampUnit(
|
|
solarEclipseEarthEquatorialRadiusKM * solarEclipseSolarRadiusRatio / sunTopocentric[2],
|
|
))
|
|
moonOuterRadiusRad := math.Asin(localSolarEclipseClampUnit(
|
|
solarEclipseEarthEquatorialRadiusKM * solarEclipsePenumbralK * localSolarMoonRadiusScale / moonTopocentric[2],
|
|
))
|
|
moonInnerRadiusRad := math.Asin(localSolarEclipseClampUnit(
|
|
solarEclipseEarthEquatorialRadiusKM * context.params.umbralK * localSolarMoonRadiusScale / moonTopocentric[2],
|
|
))
|
|
|
|
sunHorizontal := solarEclipseEquatorialToHorizontal(
|
|
sunTopocentric[0],
|
|
sunTopocentric[1],
|
|
sunTopocentric[2],
|
|
lonRad,
|
|
latRad,
|
|
context.gst,
|
|
)
|
|
|
|
return localSolarEclipseState{
|
|
separationRad: math.Acos(dot),
|
|
separationSquared: 2 - 2*dot,
|
|
sunRadiusRad: sunRadiusRad,
|
|
moonOuterRadiusRad: moonOuterRadiusRad,
|
|
moonInnerRadiusRad: moonInnerRadiusRad,
|
|
sunAltitudeRad: sunHorizontal[1],
|
|
sunAzimuthRad: solarEclipseNormalizeRadians(sunHorizontal[0] + math.Pi),
|
|
}
|
|
}
|
|
|
|
func localSolarEclipseObserverXYZ(gst, lonRad, latRad, heightKM float64) [3]float64 {
|
|
equatorialRadius := solarEclipseEarthEquatorialRadiusKM
|
|
polarRadius := solarEclipseEarthEquatorialRadiusKM * solarEclipseEarthPolarRatio
|
|
|
|
u := math.Atan((polarRadius / equatorialRadius) * math.Tan(latRad))
|
|
radiusXY := equatorialRadius*math.Cos(u) + heightKM*math.Cos(latRad)
|
|
radiusZ := polarRadius*math.Sin(u) + heightKM*math.Sin(latRad)
|
|
angle := gst + lonRad
|
|
|
|
return [3]float64{
|
|
radiusXY * math.Cos(angle),
|
|
radiusXY * math.Sin(angle),
|
|
radiusZ,
|
|
}
|
|
}
|
|
|
|
func localSolarEclipseObscuration(sunRadius, moonRadius, separation float64) float64 {
|
|
if separation >= sunRadius+moonRadius {
|
|
return 0
|
|
}
|
|
|
|
sunArea := math.Pi * sunRadius * sunRadius
|
|
if separation <= math.Abs(sunRadius-moonRadius) {
|
|
if moonRadius >= sunRadius {
|
|
return 1
|
|
}
|
|
return moonRadius * moonRadius / (sunRadius * sunRadius)
|
|
}
|
|
|
|
partSun := localSolarEclipseClampUnit((separation*separation + sunRadius*sunRadius - moonRadius*moonRadius) / (2 * separation * sunRadius))
|
|
partMoon := localSolarEclipseClampUnit((separation*separation + moonRadius*moonRadius - sunRadius*sunRadius) / (2 * separation * moonRadius))
|
|
term := (-separation + sunRadius + moonRadius) *
|
|
(separation + sunRadius - moonRadius) *
|
|
(separation - sunRadius + moonRadius) *
|
|
(separation + sunRadius + moonRadius)
|
|
if term < 0 {
|
|
term = 0
|
|
}
|
|
|
|
overlapArea := sunRadius*sunRadius*math.Acos(partSun) +
|
|
moonRadius*moonRadius*math.Acos(partMoon) -
|
|
0.5*math.Sqrt(term)
|
|
|
|
return overlapArea / sunArea
|
|
}
|
|
|
|
func localSolarEclipseClampUnit(value float64) float64 {
|
|
if value > 1 {
|
|
return 1
|
|
}
|
|
if value < -1 {
|
|
return -1
|
|
}
|
|
return value
|
|
}
|