def V_LSR(RA, dec, dss, timedate):
"""
Computes the velocity of the local standard of rest w.r.t. the observer
@param ra : J2000 right ascension as a float or as "12h34m56.78s"
@type ra : float or str
@param dec : J2000 declination as a float or as "-12d34m56.78s"
@type dec : float or str
@param observer : DSN station
@type observer : int
@param timedate : date/time of the observation
@type timedate : datetime object
"""
logger.debug("V_LSR: entered with coord types %s and %s", type(RA),
type(dec))
if type(RA) == str and type(dec) == str:
skypos = coord.SkyCoord(RA, dec, unit=(u.hourangle, u.deg))
elif type(RA) == float and type(dec) == float:
skypos = coord.SkyCoord(RA * u.hour, dec * u.degree)
else:
raise RuntimeError(RA, dec, "cannot be parsed")
logger.debug("V_LSR: sky pos: %s", skypos)
ra2000, dec2000 = skypos.ra.hour, skypos.dec.deg
logger.debug("V_LSR: J2000 coordinates are %f, %f", ra2000, dec2000)
sourcename = "%5.2f%+5.2f" % (ra2000, dec2000)
cat_entry = novas.make_cat_entry(sourcename, "", 0, ra2000, dec2000, 0, 0,
0, 0)
source = novas.make_object(2, 0, sourcename, cat_entry)
station = Astronomy.DSN_coordinates.DSS(dss)
logger.debug("V_LSR: station lat=%f", station.lat * 180 / math.pi)
logger.debug("V_LSR: station long=%f", station.lon * 180 / math.pi)
if station.long > math.pi:
longitude = station.long - 2 * math.pi
elif station.long < math.pi:
longitude = station.long + 2 * math.pi
else:
longitude = station.long
observer = novas.make_observer_on_surface(station.lat * 180 / math.pi,
longitude * 180 / math.pi,
station.elev, 0, 0)
jd = novas.julian_date(timedate.year, timedate.month, timedate.day,
timedate.hour + timedate.minute / 60.)
mjd = DatesTimes.MJD(timedate.year, timedate.month, timedate.day)
earth = novas.make_object(0, 3, 'Earth', None)
urthpos, urthvel = novas.ephemeris((jd, 0), earth, origin=0)
(obspos, obsvel) = novas.geo_posvel(jd, 0, observer, 0)
totvel = tuple(numpy.array(urthvel) + numpy.array(obsvel))
(srcpos, srcvel) = novas.starvectors(cat_entry)
V = novas.rad_vel(source, srcpos, srcvel, totvel, 0, 0, 0)
logger.debug("V_LSR: velocity of observer w.r.t. Sun= %.2f", V)
return V + Astronomy.v_sun(mjd, ra2000 / 15., dec2000)
def output_topocentric_tests(dates):
usno = novas.make_on_surface(38.9215, -77.0669, 92.0, 10.0, 1010.0)
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
obj = novas.make_object(0, code, 'planet{}'.format(code), None)
ra1, dec1, distance1 = call(novas.local_planet, jd, 0.0, obj, usno)
ra2, dec2, distance2 = call(novas.topo_planet, jd, 0.0, obj, usno)
alt, az = call(altaz_maneuver, jd, obj, usno)
output(locals(), """\
def test_{planet}_topocentric_date{i}():
jd = JulianDate(tt={jd!r})
usno = de405.earth.topos('38.9215 N', '77.0669 W', elevation_m=92.0)
apparent = usno(jd).observe(de405.{planet}).apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
alt, az, distance = apparent.altaz()
compare(alt.degrees, {alt!r}, 0.001 * arcsecond)
compare(az.degrees, {az!r}, 0.001 * arcsecond)
""")
def test_altaz(jd, planet_name_and_code):
""" Tests of generating a full position in altaz coordinates. Uses
fixtures to iterate through date pairs and planets to generate
individual tests.
"""
planet_name, planet_code = planet_name_and_code
position = c.make_on_surface(45.0, -75.0, 0.0, 10.0, 1010.0)
ggr = positionlib.Topos('45 N', '75 W', 0.0,
temperature=10.0, pressure=1010.0)
ggr.ephemeris = de405
xp = yp = 0.0
obj = c.make_object(0, planet_code, 'planet', None)
ra, dec, dis = c.topo_planet(jd.tt, jd.delta_t, obj, position)
(zd0, az0), (ra, dec) = c.equ2hor(jd.ut1, jd.delta_t, xp, yp,
position, ra, dec)
alt0 = 90.0 - zd0
planet = getattr(de405, planet_name)
g = ggr(jd)
distance = length_of((g - planet(jd)).position.AU)
alt, az, d = g.observe(planet).apparent().altaz()
eq(az0, az.degrees(), 0.001 * arcsecond_in_degrees)
eq(alt0, alt.degrees(), 0.001 * arcsecond_in_degrees)
eq(dis, distance, 0.5 * meter)
def test_new_horizontal(timepairs, planets_list):
""" Tests of generating a full position in horizontal coordinates. Uses
fixtures to iterate through date pairs and planets to generate
individual tests.
"""
jd_tt = timepairs[0]
delta_t = timepairs[1]
planet_name = planets_list[0]
planet_code = planets_list[1]
position = c.make_on_surface(45.0, -75.0, 0.0, 10.0, 1010.0)
ggr = coordinates.Topos('75 W', '45 N', 0.0,
temperature=10.0, pressure=1010.0)
ggr.earth = emp.earth
ggr.ephemeris = emp
xp = yp = 0.0
# replaces the for loop
obj = c.make_object(0, planet_code, 'planet', None)
ra, dec, dis = c.topo_planet(jd_tt, delta_t, obj, position)
jd_ut1 = jd_tt - delta_t / 86400.0
(zd, az), (ra, dec) = c.equ2hor(
jd_ut1, delta_t, xp, yp, position, ra, dec, ref_option=0)
planet = getattr(emp, planet_name)
jd = JulianDate(tt=jd_tt, delta_t=delta_t)
h = ggr(jd).observe(planet).apparent().horizontal()
eq(zd * TAU / 360.0, h.zd, 0.001 * arcsecond)
eq(az * TAU / 360.0, h.az, 0.001 * arcsecond)
eq(0.25 * TAU - zd * TAU / 360.0, h.alt, 0.001 * arcsecond)
eq(dis, h.distance, 0.001 * meter)
def output_geocentric_tests(dates):
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
obj = novas.make_object(0, code, 'planet{}'.format(code), None)
ra1, dec1, distance1 = call(novas.astro_planet, jd, obj)
ra2, dec2, distance2 = call(novas.virtual_planet, jd, obj)
ra3, dec3, distance3 = call(novas.app_planet, jd, obj)
assert distance1 == distance2 == distance3
output(locals(), """\
def test_{planet}_geocentric_date{i}():
jd = JulianDate(tt={jd!r})
e = de405.earth(jd)
distance = length_of((e - de405.{planet}(jd)).position.AU)
compare(distance, {distance1!r}, 0.5 * meter)
astrometric = e.observe(de405.{planet})
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.001 * arcsecond)
""")
def getOwlt(utc_time): '''Uses novas module to compute One Way Light Time at given UTC time.''' jd_start, jd_end, number = eph_manager.ephem_open() jd_tt = novas.julian_date(utc_time.tm_year, utc_time.tm_mon, utc_time.tm_mday, utc_time.tm_hour) mars = novas.make_object(0, 4, 'Mars', None) ra, dec, dis = novas.astro_planet(jd_tt, mars) au_sec = 499.0047838061 # Light-time for one astronomical unit (AU) in seconds, from DE-405 owlt = dis * au_sec return owlt
def test_setup_Sun():
test_cat_entry = make_cat_entry('DUMMY', 'xxx', 0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0)
test_sun = make_object(0, 10, 'Sun', test_cat_entry)
sun = lsst_visibility_calculator.setup_Sun()
assert type(sun) == type(test_sun)
def setup_Sun():
"""
Function to establish a NOVAS-object for the Sun
"""
star = make_cat_entry('DUMMY', 'xxx', 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
sun = make_object(0, 10, 'Sun', star)
return sun
def print_planet(planet_name, planet_num):
# make_object(type, number, name, star)
# type = 0;major planet, Pluto, Sun, or Moon
# type = 1; minor planet
# type = 2; object located outside the soloar system
# number; Mercury = 1, ..., Pluto = 9, Sun = 10, Moon = 11
print planet_name
planet = novas.make_object(0, planet_num, planet_name, None)
ra, dec, dis = novas.astro_planet(jd_tt, planet)
print 'R.A. %d:%02f' % (ra, abs(ra) % 1. * 60.)
print 'dec. %d:%02f' % (dec, abs(dec) % 1. * 60.)
print 'distance %f AU' % (dis,)
def test_app_planet(self):
for jd_tt, name in product([T0, TA, TB], planets_to_test):
obj = c.make_object(0, planet_codes[name], 'planet', None)
ra, dec, dis = c.app_planet(jd_tt, obj)
earth = self.e.earth
planet = getattr(self.e, name)
jd = JulianDate(tt=jd_tt)
g = planet.observe_from(earth(jd)).apparent()
self.eq(ra * tau / 24.0, g.ra, 0.001 * arcsecond)
self.eq(dec * tau / 360.0, g.dec, 0.001 * arcsecond)
self.eq(dis, g.distance, 0.001 * meter)
def test_app_planet(jd, planet_name_and_code):
planet_name, planet_code = planet_name_and_code
obj = c.make_object(0, planet_code, 'planet', None)
ra0, dec0, distance0 = c.app_planet(jd.tt, obj)
earth = de405.earth
planet = getattr(de405, planet_name)
e = earth(jd)
distance = length_of((e - planet(jd)).position.AU)
ra, dec, d = e.observe(planet).apparent().radec(epoch=jd)
eq(ra0, ra.hours(), 0.001 * arcsecond_in_hours)
eq(dec0, dec.degrees(), 0.001 * arcsecond_in_degrees)
eq(distance0, distance, 0.5 * meter)
def test_app_planet(timepairs, planets_list):
jd_tt = timepairs[0]
planet_name = planets_list[0]
planet_code = planets_list[1]
obj = c.make_object(0, planet_code, 'planet', None)
ra, dec, dis = c.app_planet(jd_tt, obj)
earth = emp.earth
planet = getattr(emp, planet_name)
jd = JulianDate(tt=jd_tt)
g = planet.observe_from(earth(jd)).apparent()
eq(ra * TAU / 24.0, g.ra, 0.001 * arcsecond)
eq(dec * TAU / 360.0, g.dec, 0.001 * arcsecond)
eq(dis, g.distance, 0.001 * meter)
def __init__(self,
latitude,
longitude,
height = HEIGHT_DEFAULT,
ephem_filepath = None,
deltat_preds_filepath = None
):
ephem_open(ephem_filepath) #locate the ephemeris data, needed for subsequent NOVAS calls
dummy_star = make_cat_entry('DUMMY', 'xxx', 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
self._sun = make_object(0, 10, 'Sun', dummy_star) #type 0, number 10 denotes the Sun
self._latitude = latitude
self._longitude = longitude
self._height = height
self._temperature = TEMPERATURE_DEFAULT
self._pressure = PRESSURE_DEFAULT
self._update_geo_loc()
self._julian_clock = JulianClock(deltat_preds_filepath)
def test_topo_planet(self):
position = c.make_on_surface(45.0, -75.0, 0.0, 10.0, 1010.0)
ggr = coordinates.Topos('75 W', '45 N', 0.0,
temperature=10.0, pressure=1010.0)
ggr.earth = self.e.earth
ggr.ephemeris = self.e
for (jd_tt, delta_t), name in product([P0, PA, PB], planets_to_test):
obj = c.make_object(0, planet_codes[name], 'planet', None)
ra, dec, dis = c.topo_planet(jd_tt, delta_t, obj, position)
planet = getattr(self.e, name)
jd = JulianDate(tt=jd_tt, delta_t=delta_t)
g = ggr(jd).observe(planet).apparent()
self.eq(ra * tau / 24.0, g.ra, 0.001 * arcsecond)
self.eq(dec * tau / 360.0, g.dec, 0.001 * arcsecond)
self.eq(dis, g.distance, 0.001 * meter)
def test_topo_planet(jd, planet_name_and_code):
position = c.make_on_surface(45.0, -75.0, 0.0, 10.0, 1010.0)
ggr = positionlib.Topos('45 N', '75 W', 0.0,
temperature=10.0, pressure=1010.0)
ggr.ephemeris = de405
planet_name, planet_code = planet_name_and_code
obj = c.make_object(0, planet_code, 'planet', None)
ra0, dec0, distance0 = c.topo_planet(jd.tt, jd.delta_t, obj, position)
planet = getattr(de405, planet_name)
g = ggr(jd)
distance = length_of((g - planet(jd)).position.AU)
ra, dec, d = g.observe(planet).apparent().radec(epoch=jd)
eq(ra0, ra.hours(), 0.001 * arcsecond_in_hours)
eq(dec0, dec.degrees(), 0.001 * arcsecond_in_degrees)
eq(distance0, distance, 0.5 * meter)
def output_topocentric_tests(dates):
usno = novas.make_on_surface(38.9215, -77.0669, 92.0, 10.0, 1010.0)
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
slug = slugify(planet)
obj = novas.make_object(0, code, 'planet{0}'.format(code), None)
ra1, dec1, distance1 = call(novas.local_planet, jd, 0.0, obj, usno)
ra2, dec2, distance2 = call(novas.topo_planet, jd, 0.0, obj, usno)
alt, az = call(altaz_maneuver, jd, usno, ra2, dec2)
alt2, az2 = call(altaz_maneuver, jd, usno, ra2, dec2, 1)
alt3, az3 = call(altaz_maneuver, jd, usno, ra2, dec2, 2)
output(
locals(), """\
def test_{slug}_topocentric_date{i}(de405):
t = load.timescale(delta_t=0.0).tt_jd({jd!r})
earth = de405['earth']
usno = earth + Topos('38.9215 N', '77.0669 W', elevation_m=92.0)
apparent = usno.at(t).observe(de405[{planet!r}]).apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra1!r}, 0.0005 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.0005 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra2!r}, 0.0005 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.0005 * arcsecond)
alt, az, distance = apparent.altaz()
compare(alt.degrees, {alt!r}, 0.0005 * arcsecond)
compare(az.degrees, {az!r}, 0.0005 * arcsecond)
alt, az, distance = apparent.altaz('standard')
compare(alt.degrees, {alt2!r}, 0.0005 * arcsecond)
compare(az.degrees, {az2!r}, 0.0005 * arcsecond)
alt, az, distance = apparent.altaz(10.0, 1010.0)
compare(alt.degrees, {alt3!r}, 0.0005 * arcsecond)
compare(az.degrees, {az3!r}, 0.0005 * arcsecond)
""")
def output_topocentric_tests(dates):
usno = novas.make_on_surface(38.9215, -77.0669, 92.0, 10.0, 1010.0)
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
slug = slugify(planet)
obj = novas.make_object(0, code, 'planet{0}'.format(code), None)
ra1, dec1, distance1 = call(novas.local_planet, jd, 0.0, obj, usno)
ra2, dec2, distance2 = call(novas.topo_planet, jd, 0.0, obj, usno)
alt, az = call(altaz_maneuver, jd, usno, ra2, dec2)
alt2, az2 = call(altaz_maneuver, jd, usno, ra2, dec2, 1)
alt3, az3 = call(altaz_maneuver, jd, usno, ra2, dec2, 2)
output(locals(), """\
def test_{slug}_topocentric_date{i}(de405):
t = load.timescale(delta_t=0.0).tt(jd={jd!r})
earth = de405['earth']
usno = earth.topos('38.9215 N', '77.0669 W', elevation_m=92.0)
apparent = usno.at(t).observe(de405[{planet!r}]).apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra1!r}, 0.0005 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.0005 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra2!r}, 0.0005 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.0005 * arcsecond)
alt, az, distance = apparent.altaz()
compare(alt.degrees, {alt!r}, 0.0005 * arcsecond)
compare(az.degrees, {az!r}, 0.0005 * arcsecond)
alt, az, distance = apparent.altaz('standard')
compare(alt.degrees, {alt2!r}, 0.0005 * arcsecond)
compare(az.degrees, {az2!r}, 0.0005 * arcsecond)
alt, az, distance = apparent.altaz(10.0, 1010.0)
compare(alt.degrees, {alt3!r}, 0.0005 * arcsecond)
compare(az.degrees, {az3!r}, 0.0005 * arcsecond)
""")
def output_topocentric_tests(dates):
usno = novas.make_on_surface(38.9215, -77.0669, 92.0, 10.0, 1010.0)
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
obj = novas.make_object(0, code, 'planet{}'.format(code), None)
ra1, dec1, distance1 = call(novas.local_planet, jd, 0.0, obj, usno)
ra2, dec2, distance2 = call(novas.topo_planet, jd, 0.0, obj, usno)
alt, az = call(altaz_maneuver, jd, usno, ra2, dec2)
alt2, az2 = call(altaz_maneuver, jd, usno, ra2, dec2, 1)
alt3, az3 = call(altaz_maneuver, jd, usno, ra2, dec2, 2)
output(
locals(), """\
def test_{planet}_topocentric_date{i}():
jd = JulianDate(tt={jd!r})
usno = de405.earth.topos('38.9215 N', '77.0669 W', elevation_m=92.0)
apparent = usno(jd).observe(de405.{planet}).apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
alt, az, distance = apparent.altaz()
compare(alt.degrees, {alt!r}, 0.001 * arcsecond)
compare(az.degrees, {az!r}, 0.001 * arcsecond)
alt, az, distance = apparent.altaz('standard')
compare(alt.degrees, {alt2!r}, 0.001 * arcsecond)
compare(az.degrees, {az2!r}, 0.001 * arcsecond)
alt, az, distance = apparent.altaz(10.0, 1010.0)
compare(alt.degrees, {alt3!r}, 0.001 * arcsecond)
compare(az.degrees, {az3!r}, 0.001 * arcsecond)
""")
def test_topo_planet(timepairs, planets_list):
position = c.make_on_surface(45.0, -75.0, 0.0, 10.0, 1010.0)
ggr = coordinates.Topos('75 W', '45 N', 0.0,
temperature=10.0, pressure=1010.0)
ggr.earth = emp.earth
ggr.ephemeris = emp
jd_tt = timepairs[0]
delta_t = timepairs[1]
planet_name = planets_list[0]
planet_code = planets_list[1]
obj = c.make_object(0, planet_code, 'planet', None)
ra, dec, dis = c.topo_planet(jd_tt, delta_t, obj, position)
planet = getattr(emp, planet_name)
jd = JulianDate(tt=jd_tt, delta_t=delta_t)
g = ggr(jd).observe(planet).apparent()
eq(ra * TAU / 24.0, g.ra, 0.001 * arcsecond)
eq(dec * TAU / 360.0, g.dec, 0.001 * arcsecond)
eq(dis, g.distance, 0.001 * meter)
def test_horizontal(self):
position = c.make_on_surface(45.0, -75.0, 0.0, 10.0, 1010.0)
ggr = coordinates.Topos('75 W', '45 N', 0.0,
temperature=10.0, pressure=1010.0)
ggr.earth = self.e.earth
ggr.ephemeris = self.e
xp = yp = 0.0
for (jd_tt, delta_t), name in product([P0, PA, PB], planets_to_test):
obj = c.make_object(0, planet_codes[name], 'planet', None)
ra, dec, dis = c.topo_planet(jd_tt, delta_t, obj, position)
jd_ut1 = jd_tt - delta_t / 86400.0
(zd, az), (ra, dec) = c.equ2hor(
jd_ut1, delta_t, xp, yp, position, ra, dec, ref_option=0)
planet = getattr(self.e, name)
jd = JulianDate(tt=jd_tt, delta_t=delta_t)
h = ggr(jd).observe(planet).apparent().horizontal()
self.eq(zd * tau / 360.0, h.zd, 0.001 * arcsecond)
self.eq(az * tau / 360.0, h.az, 0.001 * arcsecond)
self.eq(0.25 * tau - zd * tau / 360.0, h.alt, 0.001 * arcsecond)
self.eq(dis, h.distance, 0.001 * meter)
def output_ephemeris_tests():
code = 3
cel_obj = novas.make_object(0, code, 'planet{0}'.format(code), None)
ssb = 0
full_accuracy = 0
jd = T0
pos, vel = novas.ephemeris([jd, 0], cel_obj, ssb, full_accuracy)
# TODO: why are two uses of exactly the same ephemeris not agreeing
# any more closely than 10 meters?
# TODO: are my units meaningful when comparing the velocity?
output(locals(), """\
def test_position_and_velocity(de405, ts):
t = ts.tt_jd({jd!r})
e = de405['earth'].at(t)
compare(e.position.au, {pos!r}, 10 * meter)
compare(e.velocity.au_per_d, {vel!r}, 1e-5 * meter / one_second)
""")
def output_ephemeris_tests():
code = 3
cel_obj = novas.make_object(0, code, 'planet{0}'.format(code), None)
ssb = 0
full_accuracy = 0
jd = T0
pos, vel = novas.ephemeris([jd, 0], cel_obj, ssb, full_accuracy)
# TODO: why are two uses of exactly the same ephemeris not agreeing
# any more closely than 10 meters?
# TODO: are my units meaningful when comparing the velocity?
output(locals(), """\
def test_position_and_velocity(de405, ts):
t = ts.tt(jd={jd!r})
e = de405['earth'].at(t)
compare(e.position.au, {pos!r}, 10 * meter)
compare(e.velocity.au_per_d, {vel!r}, 1e-5 * meter / one_second)
""")
#EOP参数
ut1_utc = 0.06723
x_pole = -0.002
y_pole = +0.529
#tt-ut1
delta_t = tt_tai + leap_second - ut1_utc
#构造不同的儒略日时间变量
jd_utc = novas.julian_date(year, month, day, hour) #utc
jd_ut1 = jd_utc + ut1_utc / 86400.0 #ut1
jd_tt = jd_utc + (leap_second + tt_tai) / 86400.0 #tt
jd = (jd_tt, 0.0)
jd0 = (jd_tt - ta / 86400, 0.0)
#打开de历表
jd_s, jd_e, num = eph_manager.ephem_open()
#太阳和地球构造
sun = novas.make_object(0, 10, 'sun', None)
moon = novas.make_object(0, 11, 'moon', None)
earth = novas.make_object(0, 3, 'earth', None)
#位置构造
location1 = novas.make_on_surface(latitude, longitude, height, 25.0, 1013)
location = novas.make_observer_on_surface(latitude, longitude, height, 25.0,
1013)
#矢量和夹角初始化
O1_S1 = [0.0, 0.0, 0.0] #月球半影锥点到太阳质心矢量坐标
O2_S1 = [0.0, 0.0, 0.0] #月球全影锥点到太阳质心矢量坐标
O1_E = [0.0, 0.0, 0.0] #月球半影锥点到地心距离矢量坐标
O1_T = [0.0, 0.0, 0.0] #月球半影锥点到地球某一点距离矢量坐标
O2_E = [0.0, 0.0, 0.0] #月球全影锥点到地心距离矢量坐标
O2_T = [0.0, 0.0, 0.0] #月球全影锥点到地球某一点距离矢量坐标
O1_M = [0.0, 0.0, 0.0] #月球半影锥点到月心距离矢量坐标
O2_M = [0.0, 0.0, 0.0] #月球全影锥点到月心距离矢量坐标
def output_geocentric_tests(dates):
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
obj = novas.make_object(0, code, 'planet{}'.format(code), None)
ra1, dec1, distance1 = call(novas.astro_planet, jd, obj)
ra2, dec2, distance2 = call(novas.virtual_planet, jd, obj)
ra3, dec3, distance3 = call(novas.app_planet, jd, obj)
assert distance1 == distance2 == distance3
output(locals(), """\
def test_{planet}_geocentric_date{i}():
jd = JulianDate(tt={jd!r})
e = de405.earth(jd)
distance = length_of((e - de405.{planet}(jd)).position.au)
compare(distance * OLD_AU, {distance1!r}, 0.5 * meter)
astrometric = e.observe(de405.{planet})
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.001 * arcsecond)
""")
# And, one star.
polaris = novas.make_cat_entry(
'POLARIS', 'HIP', 0, 2.530301028, 89.264109444,
44.22, -11.75, 7.56, -17.4)
starlist = [('polaris', polaris)]
for (name, star), (i, jd) in product(starlist, enumerate(dates)):
ra1, dec1 = call(novas.astro_star, jd, star)
ra2, dec2 = call(novas.virtual_star, jd, star)
ra3, dec3 = call(novas.app_star, jd, star)
output(locals(), """\
def test_{name}_geocentric_date{i}():
jd = JulianDate(tt={jd!r})
e = de405.earth(jd)
star = starlib.Star(ra_hours=2.530301028, dec_degrees=89.264109444,
ra_mas_per_year=44.22, dec_mas_per_year=-11.75,
parallax_mas=7.56, radial_km_per_s=-17.4)
astrometric = e.observe(star)
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.001 * arcsecond)
""")
def output_geocentric_tests(dates):
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
slug = slugify(planet)
obj = novas.make_object(0, code, 'planet{0}'.format(code), None)
ra1, dec1, distance1 = call(novas.astro_planet, jd, obj)
ra2, dec2, distance2 = call(novas.virtual_planet, jd, obj)
ra3, dec3, distance3 = call(novas.app_planet, jd, obj)
assert distance1 == distance2 == distance3
output(
locals(), """\
def test_{slug}_geocentric_date{i}(de405, ts):
t = ts.tt_jd({jd!r})
reduce_precision(t)
e = de405['earth'].at(t)
p = de405[{planet!r}]
distance = length_of((e - p.at(t)).position.au)
compare(distance * OLD_AU, {distance1!r}, 0.014 * meter)
astrometric = e.observe(p)
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.0002 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.0001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.0002 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.0001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.0002 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.0001 * arcsecond)
""")
# And, one star.
polaris = novas.make_cat_entry('POLARIS', 'HIP', 0, 2.530301028,
89.264109444, 44.22, -11.75, 7.56, -17.4)
starlist = [('polaris', polaris)]
for (name, star), (i, jd) in product(starlist, enumerate(dates)):
ra1, dec1 = call(novas.astro_star, jd, star)
ra2, dec2 = call(novas.virtual_star, jd, star)
ra3, dec3 = call(novas.app_star, jd, star)
output(
locals(), """\
def test_{name}_geocentric_date{i}(earth):
e = earth.at(load.timescale().tt_jd({jd!r}))
star = starlib.Star(ra_hours=2.530301028, dec_degrees=89.264109444,
ra_mas_per_year=44.22, dec_mas_per_year=-11.75,
parallax_mas=7.56, radial_km_per_s=-17.4)
astrometric = e.observe(star)
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.00001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.00001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.00001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.00001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.00001 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.00001 * arcsecond)
""")
def output_geocentric_tests(dates):
for (planet, code), (i, jd) in product(planets, enumerate(dates)):
obj = novas.make_object(0, code, 'planet{}'.format(code), None)
ra1, dec1, distance1 = call(novas.astro_planet, jd, obj)
ra2, dec2, distance2 = call(novas.virtual_planet, jd, obj)
ra3, dec3, distance3 = call(novas.app_planet, jd, obj)
assert distance1 == distance2 == distance3
output(
locals(), """\
def test_{planet}_geocentric_date{i}():
jd = JulianDate(tt={jd!r})
e = de405.earth(jd)
distance = length_of((e - de405.{planet}(jd)).position.au)
compare(distance * OLD_AU, {distance1!r}, 0.5 * meter)
astrometric = e.observe(de405.{planet})
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.001 * arcsecond)
""")
# And, one star.
polaris = novas.make_cat_entry('POLARIS', 'HIP', 0, 2.530301028,
89.264109444, 44.22, -11.75, 7.56, -17.4)
starlist = [('polaris', polaris)]
for (name, star), (i, jd) in product(starlist, enumerate(dates)):
ra1, dec1 = call(novas.astro_star, jd, star)
ra2, dec2 = call(novas.virtual_star, jd, star)
ra3, dec3 = call(novas.app_star, jd, star)
output(
locals(), """\
def test_{name}_geocentric_date{i}():
jd = JulianDate(tt={jd!r})
e = de405.earth(jd)
star = starlib.Star(ra_hours=2.530301028, dec_degrees=89.264109444,
ra_mas_per_year=44.22, dec_mas_per_year=-11.75,
parallax_mas=7.56, radial_km_per_s=-17.4)
astrometric = e.observe(star)
ra, dec, distance = astrometric.radec()
compare(ra.hours, {ra1!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec1!r}, 0.001 * arcsecond)
apparent = astrometric.apparent()
ra, dec, distance = apparent.radec()
compare(ra.hours, {ra2!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec2!r}, 0.001 * arcsecond)
ra, dec, distance = apparent.radec(epoch='date')
compare(ra.hours, {ra3!r}, 0.001 * ra_arcsecond)
compare(dec.degrees, {dec3!r}, 0.001 * arcsecond)
""")
