新增函数&修复bug

master
兔子 4 years ago
parent 08fcbf9f89
commit 1c4397c9dc

@ -1,196 +1,2 @@
// Package astro
package astro package astro
import (
"errors"
"time"
"b612.me/astro/basic"
)
/*
*/
func NowJDE() float64 {
return basic.GetNowJDE()
}
/*
*/
func Date2JDE(date time.Time) float64 {
day := float64(date.Day()) + float64(date.Hour())/24.0 + float64(date.Minute())/24.0/60.0 + float64(date.Second())/24.0/3600.0 + float64(date.Nanosecond())/1000000000.0/3600.0/24.0
return basic.JDECalc(date.Year(), int(date.Month()), day)
}
/*
*/
func JDE2Date(jde float64) time.Time {
return basic.JDE2Date(jde)
}
/*
*/
func Lunar(year, month, day int) (int, int, bool, string) {
return basic.GetLunar(year, month, day)
}
/*
*/
func Solar(year, month, day int, leap bool) time.Time {
jde := basic.GetSolar(year, month, day, leap)
return JDE2Date(jde)
}
/*
jde0 JDE
lon西
lat
timezone西
aerotrue
*/
func SunRiseTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
var err error = nil
tz := 0.00
if aero {
tz = 1
}
tm := basic.GetSunRiseTime(jde, lon, lat, timezone, tz)
if tm == -2 {
err = errors.New("极夜")
}
if tm == -1 {
err = errors.New("极昼")
}
return JDE2Date(tm), err
}
/*
jde0 JDE
lon西
lat
timezone西
aerotrue
*/
func SunDownTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
var err error = nil
tz := 0.00
if aero {
tz = 1
}
tm := basic.GetSunDownTime(jde, lon, lat, timezone, tz)
if tm == -2 {
err = errors.New("极夜")
}
if tm == -1 {
err = errors.New("极昼")
}
return JDE2Date(tm), err
}
/*
jde0 JDE
lon西
lat
timezone西
angle-6 -12 -18
*/
func MorningTwilightTime(jde, lon, lat, timezone, angle float64) (time.Time, error) {
var err error = nil
tm := basic.GetAsaTime(jde, lon, lat, timezone, angle)
if tm == -2 {
err = errors.New("不存在")
}
if tm == -1 {
err = errors.New("不存在")
}
return JDE2Date(tm), err
}
/*
jde0 JDE
lon西
lat
timezone西
angle-6 -12 -18
*/
func EveningTwilightTime(jde, lon, lat, timezone, angle float64) (time.Time, error) {
var err error = nil
tm := basic.GetBanTime(jde, lon, lat, timezone, angle)
if tm == -2 {
err = errors.New("不存在")
}
if tm == -1 {
err = errors.New("不存在")
}
return JDE2Date(tm), err
}
/*
jde0 JDE
lon西
lat
timezone西
aerotrue
*/
func MoonRiseTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
var err error = nil
tz := 0.00
if aero {
tz = 1
}
tm := basic.GetMoonRiseTime(jde, lon, lat, timezone, tz)
if tm == -3 {
err = errors.New("非今日")
}
if tm == -2 {
err = errors.New("极夜")
}
if tm == -1 {
err = errors.New("极昼")
}
return JDE2Date(tm), err
}
/*
jde0 JDE
lon西
lat
timezone西
aerotrue
*/
func MoonDownTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
var err error = nil
tz := 0.00
if aero {
tz = 1
}
tm := basic.GetMoonDownTime(jde, lon, lat, timezone, tz)
if tm == -3 {
err = errors.New("非今日")
}
if tm == -2 {
err = errors.New("极夜")
}
if tm == -1 {
err = errors.New("极昼")
}
return JDE2Date(tm), err
}
/*
jdeUTC JDE
*/
func Phase(jde float64) float64 {
return basic.MoonLight(basic.TD2UT(jde, true))
}

@ -70,12 +70,12 @@ func dt_cal(y float64) float64 { //传入年, 返回世界时UT与原子时
if y >= y0 { if y >= y0 {
jsd := float64(31) // sjd是y1年之后的加速度估计 jsd := float64(31) // sjd是y1年之后的加速度估计
// 瑞士星历表jsd=31, NASA网站jsd=32, skmap的jsd=29 // 瑞士星历表jsd=31, NASA网站jsd=32, skmap的jsd=29
if y > y0+100 { if y > y0+100.00 {
return dt_ext(y, jsd) return dt_ext(y, jsd)
} }
v := dt_ext(y, jsd) //二次曲线外推 v := dt_ext(y, jsd) //二次曲线外推
dv := dt_ext(y0, jsd) - t0 // ye年的二次外推与te的差 dv := dt_ext(y0, jsd) - t0 // ye年的二次外推与te的差
return (v - dv*(y0+100-y)/100) return (v - dv*(y0+100.00-y)/100.00)
} }
d := dt_at d := dt_at
var i int var i int
@ -85,7 +85,7 @@ func dt_cal(y float64) float64 { //传入年, 返回世界时UT与原子时
// 判断年所在的区间 // 判断年所在的区间
} }
} }
t1 := (y - d[i]) / (d[i+5] - d[i]) * 10 //////// 三次插值, 保证精确性 t1 := (y - d[i]) / (d[i+5] - d[i]) * 10.00 //////// 三次插值, 保证精确性
t2 := t1 * t1 t2 := t1 * t1
t3 := t2 * t1 t3 := t2 * t1
res := d[i+1] + d[i+2]*t1 + d[i+3]*t2 + d[i+4]*t3 res := d[i+1] + d[i+2]*t1 + d[i+3]*t2 + d[i+4]*t3
@ -94,7 +94,8 @@ func dt_cal(y float64) float64 { //传入年, 返回世界时UT与原子时
func DeltaT(Date float64, IsJDE bool) (Result float64) { //传入年或儒略日,传出为秒 func DeltaT(Date float64, IsJDE bool) (Result float64) { //传入年或儒略日,传出为秒
var Year float64 var Year float64
if IsJDE { if IsJDE {
Year = (Date-2451545.0)/365.25 + 0.1 + 2000 dates := JDE2Date(Date)
Year = float64(dates.Year()) + float64(dates.YearDay())/365.0
} else { } else {
Year = Date Year = Date
} }
@ -103,6 +104,7 @@ func DeltaT(Date float64, IsJDE bool) (Result float64) { //传入年或儒略日
return return
} }
if Year < 2100 && Year >= 2010 { if Year < 2100 && Year >= 2010 {
//fmt.Println(Year)
Result = dt_cal(Year) //-3.2-(Year-2017)*0.029915; Result = dt_cal(Year) //-3.2-(Year-2017)*0.029915;
return return
} }
@ -167,6 +169,41 @@ func JDE2Date(JD float64) time.Time {
return dates return dates
} }
func JDE2DateByZone(JD float64, tz *time.Location) time.Time {
JD = JD + 0.5
Z := float64(int(JD))
F := JD - Z
var A, B, Years, Months, Days float64
if Z < 2299161.0 {
A = Z
} else {
alpha := math.Floor((Z - 1867216.25) / 36524.25)
A = Z + 1 + alpha - math.Floor(alpha/4)
}
B = A + 1524
C := math.Floor((B - 122.1) / 365.25)
D := math.Floor(365.25 * C)
E := math.Floor((B - D) / 30.6001)
Days = B - D - math.Floor(30.6001*E) + F
if E < 14 {
Months = E - 1
}
if E == 14 || E == 15 {
Months = E - 13
}
if Months > 2 {
Years = C - 4716
}
if Months == 1 || Months == 2 {
Years = C - 4715
}
tms := (Days - math.Floor(Days)) * 24 * 3600
Days = math.Floor(Days)
dates := time.Date(int(Years), time.Month(int(Months)), int(Days), 0, 0, 0, 0, tz)
dates = time.Unix(dates.Unix()+int64(tms), int64((tms-math.Floor(tms))*1000000000))
return dates
}
func GetLunar(year, month, day int) (lmonth, lday int, leap bool, result string) { func GetLunar(year, month, day int) (lmonth, lday int, leap bool, result string) {
jde := JDECalc(year, month, float64(day)) //计算当前JDE时间 jde := JDECalc(year, month, float64(day)) //计算当前JDE时间
if month == 11 || month == 12 { //判断当前日期属于前一年周期还是后一年周期 if month == 11 || month == 12 { //判断当前日期属于前一年周期还是后一年周期
@ -321,3 +358,9 @@ func GetSolar(year, month, day int, leap bool) float64 {
jde := moon[min-1+month] + float64(day) - 1 jde := moon[min-1+month] + float64(day) - 1
return jde return jde
} }
// Date2JDE 日期转儒略日
func Date2JDE(date time.Time) float64 {
day := float64(date.Day()) + float64(date.Hour())/24.0 + float64(date.Minute())/24.0/60.0 + float64(date.Second())/24.0/3600.0 + float64(date.Nanosecond())/1000000000.0/3600.0/24.0
return JDECalc(date.Year(), int(date.Month()), day)
}

@ -6,5 +6,5 @@ import (
) )
func Test_LoBo(t *testing.T) { func Test_LoBo(t *testing.T) {
fmt.Sprintf("%.14f", LoToRa(22, 33, 2451545.0)) fmt.Printf("%.9f", dt_cal(2020.5))
} }

@ -1420,9 +1420,9 @@ func GetMoonRiseTime(JD, Lon, Lat, TZ, ZS float64) float64 {
} }
if moonheight < 0 && moonang > 180 { if moonheight < 0 && moonang > 180 {
tms = (180 - moonang) / 15 tms = (180 - moonang) / 15
JD1 += (tms/24 + (tms/24*12.0)/15.0/24.0) JD1 = JD1 - (tms/24 + (tms/24*12.0)/15.0/24.0)
} else if moonheight < 0 && moonang < 180 { } else if moonheight < 0 && moonang < 180 {
tms = (-180 + moonang) / 15 tms = (180 - moonang) / 15
JD1 += (tms/24 + (tms/24*12.0)/15.0/24.0) JD1 += (tms/24 + (tms/24*12.0)/15.0/24.0)
} }
now := MoonTimeAngle(JD1, Lon, Lat, TZ) now := MoonTimeAngle(JD1, Lon, Lat, TZ)

@ -903,21 +903,34 @@ func HSunTrueLo(JD float64) float64 {
return L return L
} }
func HSunTrueBo(JD float64) float64 {
L := planet.WherePlanet(0, 1, JD)
return L
}
func HSunSeeLo(JD float64) float64 { func HSunSeeLo(JD float64) float64 {
t := (JD - 2451545) / 365250.0
L := HSunTrueLo(JD) L := HSunTrueLo(JD)
/*
t := (JD - 2451545) / 365250.0
R := planet.WherePlanet(-1, 2, JD) R := planet.WherePlanet(-1, 2, JD)
t2 := t * t t2 := t * t
t3 := t2 * t //千年数的各次方 t3 := t2 * t //千年数的各次方
R += (-0.0020 + 0.0044*t + 0.0213*t2 - 0.0250*t3) R += (-0.0020 + 0.0044*t + 0.0213*t2 - 0.0250*t3)
L = L + HJZD(JD) - 20.4898/R/3600 L = L + HJZD(JD) - 20.4898/R/3600.00
*/
L = L + HJZD(JD) + SunLoGXC(JD)
return L return L
} }
func SunLoGXC(JD float64) float64 {
R := planet.WherePlanet(0, 2, JD)
return -20.49552 / R / 3600
}
func EarthAway(JD float64) float64 { func EarthAway(JD float64) float64 {
//t=(JD - 2451545) / 365250; //t=(JD - 2451545) / 365250;
//R=Earth_R5(t)+Earth_R4(t)+Earth_R3(t)+Earth_R2(t)+Earth_R1(t)+Earth_R0(t); //R=Earth_R5(t)+Earth_R4(t)+Earth_R3(t)+Earth_R2(t)+Earth_R1(t)+Earth_R0(t);
return planet.WherePlanet(0, 2, 2555555) return planet.WherePlanet(0, 2, JD)
} }
func HSunSeeRaDec(JD float64) (float64, float64) { func HSunSeeRaDec(JD float64) (float64, float64) {

@ -7,10 +7,14 @@ import (
) )
func Test_Jq(t *testing.T) { func Test_Jq(t *testing.T) {
//fmt.Println(GetOneYearJQ(2019)) data := GetOneYearJQ(2019)
fmt.Println(JDE2Date(GetWHTime(2019, 10))) for i := 1; i < 25; i++ {
fmt.Println(JDE2Date(GetJQTime(2019, 15))) fmt.Println(JDE2Date(data[i]))
fmt.Println(JDE2Date(GetJQTime(2019, 0))) }
//fmt.Println(JDE2Date(GetWHTime(2019, 10)))
//fmt.Println(JDE2Date(GetJQTime(2020, 0)))
//date := TD2UT(GetJQTime(2020, 0), true)
//fmt.Println(HSunSeeLo(date))
} }
func Test_SunLo(t *testing.T) { func Test_SunLo(t *testing.T) {

@ -0,0 +1,25 @@
package calendar
import (
"time"
"b612.me/astro/basic"
)
// NowJDE 获取当前时刻(本地时间)对应的儒略日时间
func NowJDE() float64 {
return basic.GetNowJDE()
}
// Date2JDE 日期转儒略日
func Date2JDE(date time.Time) float64 {
day := float64(date.Day()) + float64(date.Hour())/24.0 + float64(date.Minute())/24.0/60.0 + float64(date.Second())/24.0/3600.0 + float64(date.Nanosecond())/1000000000.0/3600.0/24.0
return basic.JDECalc(date.Year(), int(date.Month()), day)
}
// JDE2Date 儒略日转日期
func JDE2Date(jde float64) time.Time {
return basic.JDE2Date(jde)
}

@ -0,0 +1,79 @@
package calendar
import (
"time"
"b612.me/astro/basic"
)
const (
JQ_ = 15 * iota
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
JQ_
)
// Lunar 公历转农历
// 传入 公历年月日
// 返回 农历月,日,是否闰月以及文字描述
func Lunar(year, month, day int) (int, int, bool, string) {
return basic.GetLunar(year, month, day)
}
// ChineseLunar 公历转农历
// 传入 公历年月日
// 返回 农历月,日,是否闰月以及文字描述
// 忽略时区,日期一律按北京时间计算
func ChineseLunar(date time.Time) (int, int, bool, string) {
return basic.GetLunar(date.Year(), int(date.Month()), date.Day())
}
// Solar 农历转公历
// 传入 农历年份,月,日,是否闰月
// 传出 公历时间
// 农历年份用公历年份代替,但是岁首需要使用农历岁首
// 例计算己亥猪年腊月三十日对应的公历即2020年1月24日
// 由于农历还未到鼠年故应当传入Solar(2019,12,30,false)
func Solar(year, month, day int, leap bool) time.Time {
jde := basic.GetSolar(year, month, day, leap)
return JDE2Date(jde)
}
// GanZhi 返回传入年份对应的干支
func GanZhi(year int) string {
return basic.GetGZ(year)
}
// JieQi 返回传入年份、节气对应的北京时间节气时间
func JieQi(year, term int) time.Time {
calcJde := basic.GetJQTime(year, term) + 8.00/24.00
zone := time.FixedZone("CST", 8*3600)
return basic.JDE2DateByZone(calcJde, zone)
}
// WuHou 返回传入年份、物候对应的北京时间物候时间
func WuHou(year, term int) time.Time {
calcJde := basic.GetWHTime(year, term) + 8.00/24.00
zone := time.FixedZone("CST", 8*3600)
return basic.JDE2DateByZone(calcJde, zone)
}

@ -1,14 +1,14 @@
package earth package earth
import ( import (
"time"
"b612.me/astro/basic" "b612.me/astro/basic"
) )
/* // EarthEccentricity 地球偏心率
// 返回date对应UTC时间的地球偏心率
jde, utc func EarthEccentricity(date time.Time) float64 {
*/ jde := basic.Date2JDE(date.UTC())
func EarthEccentricity(jde float64) float64 {
return basic.Earthe(basic.TD2UT(jde, true)) return basic.Earthe(basic.TD2UT(jde, true))
} }

@ -2,208 +2,190 @@ package moon
import ( import (
"errors" "errors"
"time"
"b612.me/astro/basic" "b612.me/astro/basic"
) )
/* var (
ERR_MOON_NEVER_RISE = errors.New("ERROR:极夜,月亮在今日永远在地平线下!")
jdeUTC ERR_MOON_NEVER_DOWN = errors.New("ERROR:极昼,月亮在今日永远在地平线上!")
*/ ERR_NOT_TODAY = errors.New("ERROR:月亮已在(昨日/明日)(升起/降下)")
func TrueLo(jde float64) float64 { )
// TrueLo 月亮真黄经
func TrueLo(date time.Time) float64 {
jde := basic.Date2JDE(date.UTC())
return basic.HMoonTrueLo(basic.TD2UT(jde, true)) return basic.HMoonTrueLo(basic.TD2UT(jde, true))
} }
/* // TrueBo 月亮真黄纬
func TrueBo(date time.Time) float64 {
jdeUTC jde := basic.Date2JDE(date.UTC())
*/ return basic.HMoonTrueBo(basic.TD2UT(jde, true))
func SeeLo(jde float64) float64 { }
// SeeLo 月亮视黄经(地心)
// 传入UTC对应的儒略日时间
func SeeLo(date time.Time) float64 {
jde := basic.Date2JDE(date.UTC())
return basic.HMoonSeeLo(basic.TD2UT(jde, true)) return basic.HMoonSeeLo(basic.TD2UT(jde, true))
} }
/* // SeeRa 月亮视赤经(站心)
// jde世界时UTC
jdeUTC // lon, 经度
lon, // lat, 纬度
lat, // timezone, 时区
timezone, // 返回站心坐标
func SeeRa(date time.Time, lon, lat, timezone float64) float64 {
*/ jde := basic.Date2JDE(date)
func SeeRa(jde, lon, lat, timezone float64) float64 {
return basic.HMoonSeeRa(basic.TD2UT(jde, true), lon, lat, timezone) return basic.HMoonSeeRa(basic.TD2UT(jde, true), lon, lat, timezone)
} }
/* // SeeDec 月亮视赤纬(站心)
// jde世界时UTC
jdeUTC // lon, 经度
lon, // lat, 纬度
lat, // timezone, 时区
timezone, // 返回站心坐标
func SeeDec(date time.Time, lon, lat, timezone float64) float64 {
*/ jde := basic.Date2JDE(date)
func SeeDec(jde, lon, lat, timezone float64) float64 {
return basic.HMoonSeeDec(basic.TD2UT(jde, true), lon, lat, timezone) return basic.HMoonSeeDec(basic.TD2UT(jde, true), lon, lat, timezone)
} }
/* // SeeRaDec 月亮视赤纬(站心)
// jde世界时UTC
jdeUTC // lon, 经度
lon, // lat, 纬度
lat, // timezone, 时区
timezone, // 返回站心坐标
func SeeRaDec(date time.Time, lon, lat, timezone float64) (float64, float64) {
*/ jde := basic.Date2JDE(date)
func SeeRaDec(jde, lon, lat, timezone float64) (float64, float64) {
return basic.HMoonSeeRaDec(basic.TD2UT(jde, true), lon, lat, timezone) return basic.HMoonSeeRaDec(basic.TD2UT(jde, true), lon, lat, timezone)
} }
/* // HourAngle 月亮时角
// date, 世界时(忽略此处时区)
jdeUTC // lon经度东正西负
*/ // lat纬度北正南负
func TrueRa(jde float64) float64 { // timezone时区东正西负
return basic.HMoonTrueRa(basic.TD2UT(jde, true)) func HourAngle(date time.Time, lon, lat, timezone float64) float64 {
} jde := basic.Date2JDE(date)
/*
jdeUTC
*/
func TrueDec(jde float64) float64 {
return basic.HMoonTrueDec(basic.TD2UT(jde, true))
}
/*
jde
lon西
lat
timezone西
*/
func HourAngle(jde, lon, lat, timezone float64) float64 {
return basic.MoonTimeAngle(jde, lon, lat, timezone) return basic.MoonTimeAngle(jde, lon, lat, timezone)
} }
/* // Azimuth 月亮方位角
// date, 世界时(忽略此处时区)
jde // lon经度东正西负
lon西 // lat纬度北正南负
lat // timezone时区东正西负
timezone西 func Azimuth(date time.Time, lon, lat, timezone float64) float64 {
*/ jde := basic.Date2JDE(date)
func Azimuth(jde, lon, lat, timezone float64) float64 {
return basic.HMoonAngle(jde, lon, lat, timezone) return basic.HMoonAngle(jde, lon, lat, timezone)
} }
/* // Zenith 月亮高度角
// date, 世界时(忽略此处时区)
jde // lon经度东正西负
lon西 // lat纬度北正南负
lat // timezone时区东正西负
timezone西 func Zenith(date time.Time, lon, lat, timezone float64) float64 {
*/ jde := basic.Date2JDE(date)
func Zenith(jde, lon, lat, timezone float64) float64 {
return basic.HMoonHeight(jde, lon, lat, timezone) return basic.HMoonHeight(jde, lon, lat, timezone)
} }
/* // CulminationTime 月亮中天时间
// date, 世界时(忽略此处时区)
jde0 // lon经度东正西负
lon西 // lat纬度北正南负
lat // timezone时区东正西负
timezone西 func CulminationTime(date time.Time, lon, lat, timezone float64) float64 {
*/ jde := basic.Date2JDE(date)
func CulminationTime(jde, lon, lat, timezone float64) float64 {
return basic.GetMoonTZTime(jde, lon, lat, timezone) return basic.GetMoonTZTime(jde, lon, lat, timezone)
} }
/* // RiseTime 月亮升起时间
// date, 世界时(忽略此处时区)
jde0 JDE // lon经度东正西负
lon西 // lat纬度北正南负
lat // timezone时区东正西负
timezone西 func RiseTime(date time.Time, lon, lat, timezone float64, aero bool) (time.Time, error) {
aerotrue var err error
*/ jde := basic.Date2JDE(date)
func RiseTime(jde, lon, lat, timezone float64, aero bool) (float64, error) { aeroFloat := 0.00
var err error = nil
tz := 0.00
if aero { if aero {
tz = 1 aeroFloat = 1
} }
tm := basic.GetMoonRiseTime(jde, lon, lat, timezone, tz) riseJde := basic.GetMoonRiseTime(jde, lon, lat, timezone, aeroFloat)
if tm == -3 { if riseJde == -3 {
err = errors.New("非今日") err = ERR_NOT_TODAY
} }
if tm == -2 { if riseJde == -2 {
err = errors.New("极夜") err = ERR_MOON_NEVER_RISE
} }
if tm == -1 { if riseJde == -1 {
err = errors.New("极昼") err = ERR_MOON_NEVER_DOWN
} }
return tm, err return basic.JDE2Date(riseJde), err
} }
/* // DownTime 月亮降下时间
// date, 世界时(忽略此处时区)
jde0 JDE // lon经度东正西负
lon西 // lat纬度北正南负
lat // timezone时区东正西负
timezone西 func DownTime(date time.Time, lon, lat, timezone float64, aero bool) (time.Time, error) {
aerotrue var err error
*/ jde := basic.Date2JDE(date)
func DownTime(jde, lon, lat, timezone float64, aero bool) (float64, error) { aeroFloat := 0.00
var err error = nil
tz := 0.00
if aero { if aero {
tz = 1 aeroFloat = 1
} }
tm := basic.GetMoonDownTime(jde, lon, lat, timezone, tz) downJde := basic.GetMoonDownTime(jde, lon, lat, timezone, aeroFloat)
if tm == -3 { if downJde == -3 {
err = errors.New("非今日") err = ERR_NOT_TODAY
} }
if tm == -2 { if downJde == -2 {
err = errors.New("极夜") err = ERR_MOON_NEVER_RISE
} }
if tm == -1 { if downJde == -1 {
err = errors.New("极昼") err = ERR_MOON_NEVER_DOWN
} }
return tm, err return basic.JDE2Date(downJde), err
} }
/* // Phase 月相
// 返回Date对应UTC世界时的月相大小
jdeUTC JDE func Phase(date time.Time) float64 {
*/ jde := basic.Date2JDE(date.UTC())
func Phase(jde float64) float64 {
return basic.MoonLight(basic.TD2UT(jde, true)) return basic.MoonLight(basic.TD2UT(jde, true))
} }
/* // ShuoYue 朔月
*/
func ShuoYue(year float64) float64 { func ShuoYue(year float64) float64 {
return basic.CalcMoonSH(year, 0) return basic.CalcMoonSH(year, 0)
} }
/* // WangYue 望月
*/
func WangYue(year float64) float64 { func WangYue(year float64) float64 {
return basic.CalcMoonSH(year, 1) return basic.CalcMoonSH(year, 1)
} }
/* // ShangXianYue 上弦月
*/
func ShangXianYue(year float64) float64 { func ShangXianYue(year float64) float64 {
return basic.CalcMoonXH(year, 0) return basic.CalcMoonXH(year, 0)
} }
/* // XiaXianYue 下弦月
*/
func XiaXianYue(year float64) float64 { func XiaXianYue(year float64) float64 {
return basic.CalcMoonXH(year, 1) return basic.CalcMoonXH(year, 1)
} }
// EarthDistance 日地距离
// 返回date对应UTC世界时日地距离
func EarthDistance(date time.Time) float64 {
jde := basic.Date2JDE(date)
jde = basic.TD2UT(jde, true)
return basic.MoonAway(jde)
}

@ -0,0 +1,15 @@
package star
import (
"time"
"b612.me/astro/basic"
)
// Constellation
// 计算date对应UTC世界时给定Date坐标赤经、赤纬所在的星座
func Constellation(ra, dec float64, date time.Time) string {
jde := basic.Date2JDE(date.UTC())
return basic.WhichCst(ra, dec, jde)
}

@ -2,243 +2,251 @@ package sun
import ( import (
"errors" "errors"
"math"
"time"
"b612.me/astro/basic" "b612.me/astro/basic"
) )
var (
ERR_SUN_NEVER_RISE = errors.New("ERROR:极夜,太阳在今日永远在地平线下!")
ERR_SUN_NEVER_DOWN = errors.New("ERROR:极昼,太阳在今日永远在地平线上!")
ERR_TWILIGHT_NOT_EXISTS = errors.New("ERROR:今日晨昏朦影不存在!")
)
/* /*
jdeUTC 26.74
nutationtrue 4.839
G2V
Z = 0.0122
31.6 32.7
*/ */
func EclipticObliquity(jde float64, nutation bool) float64 {
// RiseTime 太阳升起时间
// date取日期时区忽略
// lon经度东正西负
// lat纬度北正南负
// timezone时区东正西负
// aerotrue时进行大气修正
func RiseTime(date time.Time, lon, lat, timezone float64, aero bool) (time.Time, error) {
var err error
var aeroFloat float64
if aero {
aeroFloat = 1
}
jde := basic.Date2JDE(date)
riseJde := basic.GetSunRiseTime(jde, lon, lat, timezone, aeroFloat)
if riseJde == -2 {
err = ERR_SUN_NEVER_RISE
}
if riseJde == -1 {
err = ERR_SUN_NEVER_DOWN
}
return basic.JDE2Date(riseJde), err
}
// SunDownTime 太阳落下时间
// date取日期时区忽略
// lon经度东正西负
// lat纬度北正南负
// timezone时区东正西负
// aerotrue时进行大气修正
func DownTime(date time.Time, lon, lat, timezone float64, aero bool) (time.Time, error) {
var err error
var aeroFloat float64
if aero {
aeroFloat = 1
}
jde := basic.Date2JDE(date)
downJde := basic.GetSunDownTime(jde, lon, lat, timezone, aeroFloat)
if downJde == -2 {
err = ERR_SUN_NEVER_RISE
}
if downJde == -1 {
err = ERR_SUN_NEVER_DOWN
}
return basic.JDE2Date(downJde), err
}
// MorningTwilight 晨朦影
// date取日期时区忽略
// lon经度东正西负
// lat纬度北正南负
// timezone时区东正西负
// angle朦影角度可选-6 -12 -18(民用、航海、天文)
func MorningTwilight(date time.Time, lon, lat, timezone, angle float64) (time.Time, error) {
var err error
jde := basic.Date2JDE(date)
calcJde := basic.GetAsaTime(jde, lon, lat, timezone, angle)
if calcJde == -2 {
err = ERR_TWILIGHT_NOT_EXISTS
}
if calcJde == -1 {
err = ERR_TWILIGHT_NOT_EXISTS
}
return basic.JDE2Date(calcJde), err
}
// EveningTwilight 昏朦影
// date取日期时区忽略
// lon经度东正西负
// lat纬度北正南负
// timezone时区东正西负
// angle朦影角度可选-6 -12 -18(民用、航海、天文)
func EveningTwilight(date time.Time, lon, lat, timezone, angle float64) (time.Time, error) {
var err error
jde := basic.Date2JDE(date)
//不需要进行力学时转换会在GetBanTime中转换
calcJde := basic.GetBanTime(jde, lon, lat, timezone, angle)
if calcJde == -2 {
err = ERR_TWILIGHT_NOT_EXISTS
}
if calcJde == -1 {
err = ERR_TWILIGHT_NOT_EXISTS
}
return basic.JDE2Date(calcJde), err
}
// EclipticObliquity 黄赤交角
// 返回date对应UTC世界时的黄赤交角nutation为true时计算交角章动
func EclipticObliquity(date time.Time, nutation bool) float64 {
//转换为UTC时间
jde := basic.Date2JDE(date.UTC())
//进行力学时转换
jde = basic.TD2UT(jde, true) jde = basic.TD2UT(jde, true)
//黄赤交角计算
return basic.EclipticObliquity(jde, nutation) return basic.EclipticObliquity(jde, nutation)
} }
/* // EclipticNutation 黄经章动
// 返回date对应UTC世界时的黄经章动
jdeUTC func EclipticNutation(date time.Time) float64 {
*/ //转换为UTC时间
func EclipticNutation(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
//进行力学时转换与章动计算
return basic.HJZD(basic.TD2UT(jde, true)) return basic.HJZD(basic.TD2UT(jde, true))
} }
/* // AxialtiltNutation 交角章动
// 返回date对应UTC世界时的交角章动
jdeUTC func AxialtiltNutation(date time.Time) float64 {
*/ //转换为UTC时间
func AxialtiltNutation(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
//进行力学时转换与章动计算
return basic.JJZD(basic.TD2UT(jde, true)) return basic.JJZD(basic.TD2UT(jde, true))
} }
/* // GeometricLo 太阳几何黄经
// 返回date对应UTC世界时的太阳几何黄经
jdeUTC func GeometricLo(date time.Time) float64 {
*/ //转换为UTC时间
func GeometricLo(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
return basic.SunLo(basic.TD2UT(jde, true)) return basic.SunLo(basic.TD2UT(jde, true))
} }
/* // TrueLo 太阳真黄经
// 返回date对应UTC世界时的太阳真黄经
jdeUTC func TrueLo(date time.Time) float64 {
*/ //转换为UTC时间
func TrueLo(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
return basic.HSunTrueLo(basic.TD2UT(jde, true)) return basic.HSunTrueLo(basic.TD2UT(jde, true))
} }
/* // TrueBo 太阳真黄纬
// 返回date对应UTC世界时的太阳真黄纬
jdeUTC func TrueBo(date time.Time) float64 {
*/ //转换为UTC时间
func SeeLo(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
return basic.HSunTrueLo(basic.TD2UT(jde, true))
}
// SeeLo 太阳视黄经
// 返回date对应UTC世界时的太阳视黄经
func SeeLo(date time.Time) float64 {
//转换为UTC时间
jde := basic.Date2JDE(date.UTC())
return basic.HSunSeeLo(basic.TD2UT(jde, true)) return basic.HSunSeeLo(basic.TD2UT(jde, true))
} }
/* // SeeRa 太阳地心视赤经
// 返回date对应UTC世界时的太阳视赤经使用黄道坐标转换且默认忽略黄纬
jdeUTC func SeeRa(date time.Time) float64 {
*/ //转换为UTC时间
func SeeRa(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
return basic.HSunSeeRa(basic.TD2UT(jde, true)) return basic.HSunSeeRa(basic.TD2UT(jde, true))
} }
/* // SeeDec 太阳地心视赤纬
// 返回date对应UTC世界时的太阳视赤纬使用黄道坐标转换且默认忽略黄纬
jdeUTC func SeeDec(date time.Time) float64 {
*/ //转换为UTC时间
func SeeDec(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
return basic.HSunSeeDec(basic.TD2UT(jde, true)) return basic.HSunSeeDec(basic.TD2UT(jde, true))
} }
/* // SeeRaDec 太阳地心视赤经和赤纬
// 返回date对应UTC世界时的太阳视赤纬使用黄道坐标转换且默认忽略黄纬
jdeUTC func SeeRaDec(date time.Time) (float64, float64) {
*/ //转换为UTC时间
func SeeRaDec(jde float64) (float64, float64) { jde := basic.Date2JDE(date.UTC())
return basic.HSunSeeRaDec(basic.TD2UT(jde, true)) return basic.HSunSeeRaDec(basic.TD2UT(jde, true))
} }
/* // MidFunc 太阳中间方程
func MidFunc(date time.Time) float64 {
jdeUTC //转换为UTC时间
*/ jde := basic.Date2JDE(date.UTC())
func TrueRa(jde float64) float64 {
return basic.HSunTrueRa(basic.TD2UT(jde, true))
}
/*
jdeUTC
*/
func TrueDec(jde float64) float64 {
return basic.HSunTrueDec(basic.TD2UT(jde, true))
}
/*
jdeUTC
*/
func MidFunc(jde float64) float64 {
return basic.SunMidFun(basic.TD2UT(jde, true)) return basic.SunMidFun(basic.TD2UT(jde, true))
} }
/* // EquationTime 均时差
// 返回date对应UTC世界时的均时差
jdeUTC func EquationTime(date time.Time) float64 {
*/ //转换为UTC时间
func EquationTime(jde float64) float64 { jde := basic.Date2JDE(date.UTC())
return basic.SunTime(basic.TD2UT(jde, true)) return basic.SunTime(basic.TD2UT(jde, true))
} }
/* // HourAngle 太阳时角
// 返回给定经纬度、对应timezone时区date时刻的太阳时角注意date本身的时区将默认舍去
jde func HourAngle(date time.Time, lon, lat, timezone float64) float64 {
lon西 jde := basic.Date2JDE(date)
lat
timezone西
*/
func HourAngle(jde, lon, lat, timezone float64) float64 {
return basic.SunTimeAngle(jde, lon, lat, timezone) return basic.SunTimeAngle(jde, lon, lat, timezone)
} }
/* // Azimuth 太阳方位角
// 返回给定经纬度、对应timezone时区date时刻的太阳方位角正北为0向东增加
jde //注意date本身的时区将默认舍去
lon西 func Azimuth(date time.Time, lon, lat, timezone float64) float64 {
lat jde := basic.Date2JDE(date)
timezone西
*/
func Azimuth(jde, lon, lat, timezone float64) float64 {
return basic.SunAngle(jde, lon, lat, timezone) return basic.SunAngle(jde, lon, lat, timezone)
} }
/* // Zenith 太阳高度角
// 返回给定经纬度、对应timezone时区date时刻的太阳高度角
jde //注意date本身的时区将默认舍去
lon西 func Zenith(date time.Time, lon, lat, timezone float64) float64 {
lat jde := basic.Date2JDE(date)
timezone西
*/
func Zenith(jde, lon, lat, timezone float64) float64 {
return basic.SunHeight(jde, lon, lat, timezone) return basic.SunHeight(jde, lon, lat, timezone)
} }
/* // CulminationTime 太阳中天时间
// 返回给定经纬度、对应timezone时区date时刻的太阳中天日期
jde0 //注意date本身的时区将默认舍去返回的时间时区应当为传入的timezone
lon西 func CulminationTime(date time.Time, lon, timezone float64) time.Time {
timezone西 jde := basic.Date2JDE(date)
*/ if jde-math.Floor(jde) > 0.5 {
func CulminationTime(jde, lon, timezone float64) float64 { jde++
return basic.GetSunTZTime(jde, lon, timezone)
}
/*
jde0 JDE
lon西
lat
timezone西
aerotrue
*/
func RiseTime(jde, lon, lat, timezone float64, aero bool) (float64, error) {
var err error = nil
tz := 0.00
if aero {
tz = 1
}
tm := basic.GetSunRiseTime(jde, lon, lat, timezone, tz)
if tm == -2 {
err = errors.New("极夜")
} }
if tm == -1 { calcJde := basic.GetSunTZTime(jde, lon, timezone)
err = errors.New("极昼") return basic.JDE2Date(calcJde)
}
return tm, err
}
/*
jde0 JDE
lon西
lat
timezone西
aerotrue
*/
func DownTime(jde, lon, lat, timezone float64, aero bool) (float64, error) {
var err error = nil
tz := 0.00
if aero {
tz = 1
}
tm := basic.GetSunDownTime(jde, lon, lat, timezone, tz)
if tm == -2 {
err = errors.New("极夜")
}
if tm == -1 {
err = errors.New("极昼")
}
return tm, err
}
/*
jde0 JDE
lon西
lat
timezone西
angle-6 -12 -18
*/
func MorningTwilightTime(jde, lon, lat, timezone, angle float64) (float64, error) {
var err error = nil
tm := basic.GetAsaTime(jde, lon, lat, timezone, angle)
if tm == -2 {
err = errors.New("不存在")
}
if tm == -1 {
err = errors.New("不存在")
}
return tm, err
} }
/* // EarthDistance 日地距离
// 返回date对应UTC世界时日地距离
jde0 JDE func EarthDistance(date time.Time) float64 {
lon西 jde := basic.Date2JDE(date)
lat jde = basic.TD2UT(jde, true)
timezone西 return basic.EarthAway(jde)
angle-6 -12 -18
*/
func EveningTwilightTime(jde, lon, lat, timezone, angle float64) (float64, error) {
var err error = nil
tm := basic.GetBanTime(jde, lon, lat, timezone, angle)
if tm == -2 {
err = errors.New("不存在")
}
if tm == -1 {
err = errors.New("不存在")
}
return tm, err
} }

Loading…
Cancel
Save