def compare_splines_to_finals2000_error_bars():
#url = 'http://astro.ukho.gov.uk/nao/lvm/Table-S15-v18.txt'
url = 'http://astro.ukho.gov.uk/nao/lvm/Table-S15.2020.txt'
with load.open(url) as f:
names, columns = parse_S15_table(f)
i, start_year, end_year, a0, a1, a2, a3 = columns
with load.open('ci/finals2000A.all') as f:
utc_mjd, dut1 = iers.parse_dut1_from_finals_all(f)
delta_t_recent, leap_dates, leap_offsets = (iers._build_timescale_arrays(
utc_mjd, dut1))
print('Size of IERS table:', delta_t_recent.shape)
print('Number of splines:', i.shape)
#year = [-720, 400, 700]
#year = np.arange(-720, 2010)
#year = np.arange(1800, 2010)
#year = np.arange(1980, 2010)
year = np.arange(1980, 2010, 0.1)
interpolate = Splines(start_year, end_year, a3, a2, a1, a0)
s15_curve = interpolate(year)
finals_tt, finals_delta_t = delta_t_recent
ts = load.timescale()
t = ts.utc(year)
tt = t.tt
interpolate = Splines(
finals_tt[:-1],
finals_tt[1:],
finals_delta_t[1:] - finals_delta_t[:-1],
finals_delta_t[:-1],
)
T0 = time()
finals_curve = interpolate(tt)
print(time() - T0, 's for interpolate()')
T0 = time()
finals_curve2 = np.interp(tt, finals_tt, finals_delta_t)
print(time() - T0, 's for interp()')
assert (finals_curve == finals_curve2).all()
diff = max(abs(s15_curve - finals_curve))
print('Max difference (seconds, arcseconds):', diff, diff * 15)
def main(argv):
# parser = argparse.ArgumentParser(description=put description here)
# parser.add_argument('integers', metavar='N', type=int, nargs='+',
# help='an integer for the accumulator')
# parser.add_argument('--sum', dest='accumulate', action='store_const',
# const=sum, default=max,
# help='sum the integers (default: find the max)')
# args = parser.parse_args(argv)
# print(args.accumulate(args.integers))
#draw_plot_comparing_USNO_and_IERS_data()
f = load.open('finals.all')
mjd_utc, dut1 = iers.parse_dut1_from_finals_all(f)
delta_t_recent, leap_dates, leap_offsets = (iers.build_timescale_arrays(
mjd_utc, dut1))
ts = load.timescale()
jd = mjd_utc + 2400000.5
t = ts.tt_jd(jd)
fig, ax = plt.subplots()
ax.plot(t.tt, t.delta_t)
ax.plot(delta_t_recent[0], delta_t_recent[1])
ax.grid()
fig.savefig('tmp.png')
def morrison_and_stephenson_2004_table():
"""Table of smoothed Delta T values from Morrison and Stephenson, 2004."""
import pandas as pd
f = load.open('http://eclipse.gsfc.nasa.gov/SEcat5/deltat.html')
tables = pd.read_html(f.read())
df = tables[0]
return pd.DataFrame({'year': df[0], 'delta_t': df[1]})
def galactic_Sun_north_directions( recv_time, user_longlatdist=geographic_position):
user_longlatdist = np.array(user_longlatdist)#46.07983746062874, 26.232615661106784, 659.5100082775696
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
planets = load('de421.bsp')
earth = planets['earth']
user_position = earth + Topos('{} N'.format(user_longlatdist[0]), '{} E'.format(user_longlatdist[1])) #user_longlatdist user_longlatdist[0],user_longlatdist[1]
terrestrial_time = format_time(recv_time)
ts = load.timescale()
t = ts.tt(terrestrial_time[0], terrestrial_time[1], terrestrial_time[2], terrestrial_time[3], terrestrial_time[4], terrestrial_time[5])
sun = planets['sun']
astrometric_sun = user_position.at(t).observe(sun)
alt_sun, az_sun, distance_sun = astrometric_sun.apparent().altaz()#astrometric.apparent().altaz() = astrometric_denebola.apparent().altaz()
print('Location: ', '{} N'.format(user_longlatdist[0]), '{} E'.format(user_longlatdist[1]))
print('Sun (alt/az): ',alt_sun, az_sun)
sun_position = pm.aer2ecef( az_sun.degrees, alt_sun.degrees, distance_sun.m, user_longlatdist[0], user_longlatdist[1], user_longlatdist[2])
# Északi Galaktikus Pólus (RA: 12h 51.42m; D: 27° 07.8′, epocha J2000.0)
coma_berenices = Star(ra_hours=(12, 51, 25.2), dec_degrees=(27, 7, 48.0))
astrometric_berenice = user_position.at(t).observe(coma_berenices)
alt_b, az_b, distance_b = astrometric_berenice.apparent().altaz()
print('Coma Berenice (alt/az): ',alt_b, az_b)
berenice_position = pm.aer2ecef( az_b.degrees, alt_b.degrees, distance_b.m, user_longlatdist[0], user_longlatdist[1], user_longlatdist[2])
stars_pos=[sun_position, berenice_position]
return stars_pos
def get_star_position( recv_time, star_name, star_name2, user_longlatdist=geographic_position):
# if not star_name:
# star_name = 57632 #Denebola
# if not star_name2:
# star_name2 = 109074 #Sadalmelik
user_longlatdist = np.array(user_longlatdist)#46.07983746062874, 26.232615661106784, 659.5100082775696
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
planets = load('de421.bsp')
earth = planets['earth']
user_position = earth + Topos('{} N'.format(user_longlatdist[0]), '{} E'.format(user_longlatdist[1])) #user_longlatdist user_longlatdist[0],user_longlatdist[1]
terrestrial_time = format_time(recv_time)
ts = load.timescale()
t = ts.tt(terrestrial_time[0], terrestrial_time[1], terrestrial_time[2], terrestrial_time[3], terrestrial_time[4], terrestrial_time[5])
denebola = Star.from_dataframe(df.loc[star_name])
astrometric_denebola = user_position.at(t).observe(denebola)
alt_d, az_d, distance_d = astrometric_denebola.apparent().altaz()#astrometric.apparent().altaz() = astrometric_denebola.apparent().altaz()
print('Location: ', '{} N'.format(user_longlatdist[0]), '{} E'.format(user_longlatdist[1]))
print('S1 (alt/az): ',alt_d, az_d)
star_pos_d = pm.aer2ecef( az_d.degrees,alt_d.degrees, distance_d.m,user_longlatdist[0],user_longlatdist[1],user_longlatdist[2])
sadalmelik = Star.from_dataframe(df.loc[star_name2])
astrometric_sadalmelik = user_position.at(t).observe(sadalmelik)
alt_s, az_s, distance_s = astrometric_sadalmelik.apparent().altaz()
print('S2 (alt/az): ',alt_s, az_s)
star_pos_s = pm.aer2ecef( az_s.degrees,alt_s.degrees, distance_s.m,user_longlatdist[0],user_longlatdist[1],user_longlatdist[2])
stars_pos=[star_pos_d,star_pos_s]
return stars_pos
def morrison_and_stephenson_2004_table():
"""Table of smoothed Delta T values from Morrison and Stephenson, 2004."""
import pandas as pd
f = load.open('http://eclipse.gsfc.nasa.gov/SEcat5/deltat.html')
tables = pd.read_html(f.read())
df = tables[0]
return pd.DataFrame({'year': df[0], 'delta_t': df[1]})
def get_all_comets():
global all_comets
global all_comets_expiration
global creation_running
now = datetime.now()
if all_comets is None or now > all_comets_expiration:
all_comets_expiration = now + timedelta(days=1)
with load.open(mpc.COMET_URL, reload=True) as f:
# fix problem in coma in CometEls.txt
lines = f.readlines()
s = ''
for line in lines:
s += line.decode('ascii').replace(',', ' ')
sio = BytesIO(s.encode('ascii'))
# end of fix
all_comets = mpc.load_comets_dataframe_slow(sio)
all_comets = (all_comets.sort_values('reference')
.groupby('designation', as_index=False).last()
.set_index('designation', drop=False))
all_comets['comet_id'] = np.where(all_comets['designation_packed'].isnull(), all_comets['designation'], all_comets['designation_packed'])
all_comets['comet_id'] = all_comets['comet_id'].str.replace('/', '')
all_comets['comet_id'] = all_comets['comet_id'].str.replace(' ', '')
# brightness file expires after 5 days
fname = os.path.join(current_app.config.get('USER_DATA_DIR'), 'comets_brightness.txt')
if (not os.path.isfile(fname) or datetime.fromtimestamp(os.path.getctime(fname)) + timedelta(days=5) < all_comets_expiration) and not creation_running:
all_comets.loc[:, 'mag'] = 22.0
creation_running = True
thread = threading.Thread(target=_create_comet_brighness_file, args=(all_comets, fname,))
thread.start()
else:
_load_comet_brightness(all_comets, fname)
return all_comets
def get_asteroid(name, timestamp):
# https://rhodesmill.org/skyfield/example-plots.html#drawing-a-finder-chart-for-comet-neowise
# https://astroquery.readthedocs.io/en/latest/mpc/mpc.html
designation = name
try:
asteroids = Asteroid.objects.filter(designation__icontains=name)
designation = asteroids[0].designation
except:
pass
with load.open(settings.MY_ASTEROIDS_URL) as f:
minor_planets = mpc.load_mpcorb_dataframe(f)
bad_orbits = minor_planets.semimajor_axis_au.isnull()
minor_planets = minor_planets[~bad_orbits]
# Index by designation for fast lookup.
minor_planets = minor_planets.set_index('designation', drop=False)
row = minor_planets.loc[designation]
ts = load.timescale()
eph = load('de421.bsp')
sun, earth = eph['sun'], eph['earth']
asteroid = sun + mpc.mpcorb_orbit(row, ts, GM_SUN)
t = ts.utc(timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute)
ra, dec, distance_from_sun = sun.at(t).observe(asteroid).radec()
ra, dec, distance_from_earth = earth.at(t).observe(asteroid).radec()
# https://towardsdatascience.com/space-science-with-python-a-very-bright-opposition-62e248abfe62
# how do I calculate the current phase_angle between sun and earth as seen from the asteroid
ra_sun, dec_sun, d = asteroid.at(t).observe(sun).radec()
ra_earth,dec_earth, d = asteroid.at(t).observe(earth).radec()
phase_angle_in_degrees = abs(ra_sun.hours - ra_earth.hours)
phase_angle = phase_angle_in_degrees * math.pi / 180
visual_magnitude = app_mag(abs_mag=row['magnitude_H'], \
phase_angle=phase_angle, \
slope_g=row['magnitude_G'], \
d_ast_sun=distance_from_sun.au, \
d_ast_earth=distance_from_earth.au)
result = {}
result['name'] = name
result['designation'] = designation
result['timestamp'] = str(timestamp)
result['ra'] = str(ra)
result['dec'] = str(dec)
result['ra_decimal'] = str(ra.hours * 15)
result['dec_decimal'] = str(dec.degrees)
result['distance_from_earth'] = str(distance_from_earth.au)
result['distance_from_sun'] = str(distance_from_sun.au)
result['magnitude_h'] = row['magnitude_H']
result['magnitude_g'] = row['magnitude_G']
result['visual_magnitude'] = visual_magnitude
result['last_observation_date'] = row['last_observation_date']
# result['row'] = row
return result,asteroid
def __init__(self):
with load.open(hipparcos.URL) as f:
self.df = hipparcos.load_dataframe(f)
self.planets = load('de421.bsp')
self.earth = self.planets['earth']
self.ts = load.timescale()
self.position = self.earth
def compare_old_and_new_delta_t():
with load.open('ci/finals2000A.all') as f:
utc_mjd, dut1 = iers.parse_dut1_from_finals_all(f)
delta_t_recent, leap_dates, leap_offsets = (iers._build_timescale_arrays(
utc_mjd, dut1))
plot_delta_t_functions(
build_legacy_delta_t(delta_t_recent),
build_new_delta_t(delta_t_recent),
)
def import_mpcorb_minor_planets(mpcorb_file):
with load.open(mpcorb_file) as f:
all_minor_planets = mpc.load_mpcorb_dataframe(f)
bad_orbits = all_minor_planets.semimajor_axis_au.isnull()
all_minor_planets = all_minor_planets[~bad_orbits]
all_minor_planets['minor_planet_id'] = all_minor_planets[
'designation_packed']
minor_planets = []
for index, mpc_mp in all_minor_planets.iterrows():
int_designation = int(mpc_mp['designation_packed'])
minor_planet = MinorPlanet.query.filter_by(
int_designation=int_designation).first()
if minor_planet is None:
minor_planet = MinorPlanet()
minor_planet.int_designation = int_designation
minor_planet.magnitude_H = mpc_mp['magnitude_H']
minor_planet.magnitude_G = mpc_mp['magnitude_G']
minor_planet.epoch = mpc_mp['epoch_packed']
minor_planet.mean_anomaly_degrees = mpc_mp['mean_anomaly_degrees']
minor_planet.argument_of_perihelion_degrees = mpc_mp[
'argument_of_perihelion_degrees']
minor_planet.longitude_of_ascending_node_degrees = mpc_mp[
'longitude_of_ascending_node_degrees']
minor_planet.inclination_degrees = mpc_mp['inclination_degrees']
minor_planet.eccentricity = mpc_mp['eccentricity']
minor_planet.mean_daily_motion_degrees = mpc_mp[
'mean_daily_motion_degrees']
minor_planet.semimajor_axis_au = mpc_mp['semimajor_axis_au']
minor_planet.uncertainty = mpc_mp['uncertainty']
minor_planet.reference = mpc_mp['reference']
minor_planet.observations = mpc_mp['observations']
minor_planet.oppositions = mpc_mp['oppositions']
minor_planet.observation_period = mpc_mp['observation_period']
minor_planet.rms_residual_arcseconds = mpc_mp[
'rms_residual_arcseconds']
minor_planet.coarse_perturbers = mpc_mp['coarse_perturbers']
minor_planet.precise_perturbers = mpc_mp['precise_perturbers']
minor_planet.computer_name = mpc_mp['computer_name']
minor_planet.hex_flags = mpc_mp['hex_flags']
minor_planet.designation = mpc_mp['designation']
minor_planet.last_observation_date = mpc_mp[
'last_observation_date']
minor_planets.append(minor_planet)
try:
line_cnt = 1
for minor_planet in minor_planets:
progress(line_cnt, len(minor_planets), 'Importing minor planets')
line_cnt += 1
db.session.add(minor_planet)
print('')
db.session.commit()
except IntegrityError as err:
print('\nIntegrity error {}'.format(err))
db.session.rollback()
def _get_mpc_minor_planets():
global all_minor_planets
if all_minor_planets is None:
with load.open('data/MPCORB.9999.DAT') as f:
all_minor_planets = mpc.load_mpcorb_dataframe(f)
bad_orbits = all_minor_planets.semimajor_axis_au.isnull()
all_minor_planets = all_minor_planets[~bad_orbits]
all_minor_planets['minor_planet_id'] = all_minor_planets[
'designation_packed']
return all_minor_planets
def get_probe_coords(hip_id, distance):
# set timezone + load planet info
utcTZ = timezone("UTC")
local_tz = get_localzone()
ts = load.timescale()
planets = load('de421.bsp')
# get time of observation and locations of observation
t = ts.from_datetime(datetime(2020, 11, 9, 00, 00, tzinfo=utcTZ))
sun = planets['sun']
earth = planets['earth']
# load in the hipparcos data
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
# # match on star coords
# ra_inds = []
# for ind, cat_ra in enumerate(df['ra_degrees'].values):
# if isclose(cat_ra, ra_star, rel_tol=1e-2):
# ra_inds.append(ind)
# dec_inds = []
# for ind, cat_dec in enumerate(df['dec_degrees'].values):
# if isclose(cat_dec, dec_star, rel_tol=1e-2):
# dec_inds.append(ind)
# # find where ra & dec match within tolerance
# sets = set(ra_inds).intersection(set(dec_inds))
# inds = [x for x in iter(sets)]
# print(inds)
# just take the first one for now
the_star = Star.from_dataframe(df.loc[hip_id])
# "observe" the star from Earth
starPosObj = earth.at(t).observe(the_star)
ra, dec, dist = starPosObj.radec()
# get coords of opposite point on the sky
ra = ((ra._degrees + 180.0) % 360) * (24.0 / 360.0)
dec = -1.0 * dec._degrees
# get coords of the probe and return ra dec in degree
probe = position_of_radec(ra, dec, distance, t=t)
sunPosObj = earth.at(t).observe(sun)
inverseSunCoord = -1.0 * sunPosObj.position.au
probeCoord = probe.position.au
probeDir = ICRF(probeCoord + inverseSunCoord).radec()
return probeDir[0]._degrees, probeDir[1]._degrees
def main():
f = load.open(mpc.COMET_URL)
t0 = time()
c = mpc.load_comets_dataframe(f)
print(time() - t0, 'seconds for load_comets_dataframe()')
assert len(c) == 864
f.seek(0)
t0 = time()
c = mpc.load_comets_dataframe_slow(f)
print(time() - t0, 'seconds for load_comets_dataframe_slow()')
assert len(c) == 864
def load_all_mpc_comets():
with load.open(mpc.COMET_URL, reload=True) as f:
all_mpc_comets = mpc.load_comets_dataframe_slow(f)
all_mpc_comets = (all_mpc_comets.sort_values('reference').groupby(
'designation', as_index=False).last().set_index('designation',
drop=False))
all_mpc_comets['comet_id'] = np.where(
all_mpc_comets['designation_packed'].isnull(),
all_mpc_comets['designation'],
all_mpc_comets['designation_packed'])
all_mpc_comets['comet_id'] = all_mpc_comets['comet_id'].str.replace(
'/', '')
all_mpc_comets['comet_id'] = all_mpc_comets['comet_id'].str.replace(
' ', '')
return all_mpc_comets
def work_on_delta_t_discontinuities():
with load.open('ci/finals2000A.all') as f:
utc_mjd, dut1 = iers.parse_dut1_from_finals_all(f)
delta_t_recent, leap_dates, leap_offsets = (iers._build_timescale_arrays(
utc_mjd, dut1))
ts = load.timescale()
t = ts.J(np.arange(-3000 * 12, 4000 * 12) / 12)
#t = ts.J(np.arange(1700 * 12, 2000 * 12) / 12)
fig, ax = plt.subplots(1, 1)
fig.set(size_inches=(5, 5))
ax.plot(t.J[:-1], np.diff(ts.delta_t_function(t.tt)))
ax.grid()
ax.set(xlabel='Year', ylabel='∆T month-to-month change')
fig.tight_layout()
fig.savefig('tmp.png')
def main(argv):
parser = argparse.ArgumentParser(description='Grep MPCORB.DAT.gz')
parser.add_argument('designations',
nargs='+',
help='packed designations'
' of the minor planets whose orbits you need')
args = parser.parse_args(argv)
designations = [re.escape(d.encode('ascii')) for d in args.designations]
pattern = rb'^((?:%s) .*\n)' % rb'|'.join(designations)
r = re.compile(pattern, re.M)
data = load.open(mpc.MPCORB_URL).read()
data = zlib.decompress(data, wbits=zlib.MAX_WBITS | 16)
lines = r.findall(data)
sys.stdout.buffer.write(b''.join(lines))
def load_stars(max_magnitude, verbose=False):
"""Load the Hipparcos catalog data and find all applicable stars. Returns a
list of StarObs, one per star.
"""
if verbose:
print("[ CATALOG] Loading star catalog data.")
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
df = df[df['magnitude'] <= max_magnitude]
df = df[df['ra_degrees'].notnull()]
if verbose:
print(
f'[ CATALOG] Found {len(df)} stars brighter than magnitude {max_magnitude:.4f}.'
)
return [
StarObs(str(idx), Star.from_dataframe(df.loc[idx]),
df.loc[idx].magnitude) for idx in df.index
]
def get_comet(name, timestamp):
# https://rhodesmill.org/skyfield/example-plots.html#drawing-a-finder-chart-for-comet-neowise
# https://astroquery.readthedocs.io/en/latest/mpc/mpc.html
# name = "C/2020 F3 (NEOWISE)"
# https://www.minorplanetcenter.net/iau/info/CometOrbitFormat.html
with load.open(mpc.COMET_URL) as f:
comets = mpc.load_comets_dataframe(f)
comets = (comets.sort_values('reference')
.groupby('designation', as_index=False).last()
.set_index('designation', drop=False))
row = comets.loc[name]
print(row)
ts = load.timescale()
eph = load('de421.bsp')
sun, earth = eph['sun'], eph['earth']
comet = sun + mpc.comet_orbit(row, ts, GM_SUN)
t = ts.utc(timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute)
ra, dec, distance = earth.at(t).observe(comet).radec()
result = {}
result['name'] = name
result['designation'] = row['designation']
result['timestamp'] = str(timestamp)
result['ra'] = str(ra)
result['dec'] = str(dec)
result['ra_decimal'] = str(ra.hours * 15)
result['dec_decimal'] = str(dec.degrees)
result['distance'] = str(distance)
result['magnitude_g'] = row['magnitude_g']
result['magnitude_k'] = row['magnitude_k']
result['visual_magnitude'] = row['magnitude_k']
result['row'] = row
return result,comet
def init_sf():
global ts, eph, earth, moon, sun, venus, mars, jupiter, saturn, df
EOPdf = "finals2000A.all" # Earth Orientation Parameters data file
dfIERS = EOPdf
if config.useIERS:
if compareVersion(VERSION, "1.31") >= 0:
if path.isfile(dfIERS):
if load.days_old(EOPdf) > float(config.ageIERS):
load.download(EOPdf)
ts = load.timescale(builtin=False) # timescale object
else:
load.download(EOPdf)
ts = load.timescale(builtin=False) # timescale object
else:
ts = load.timescale() # timescale object with built-in UT1-tables
else:
ts = load.timescale() # timescale object with built-in UT1-tables
if config.ephndx in set([0, 1, 2]):
eph = load(config.ephemeris[config.ephndx][0]) # load chosen ephemeris
earth = eph['earth']
moon = eph['moon']
sun = eph['sun']
venus = eph['venus']
mars = eph['mars']
jupiter = eph['jupiter barycenter']
saturn = eph['saturn barycenter']
# load the Hipparcos catalog as a 118,218 row Pandas dataframe.
with load.open(hipparcos.URL) as f:
#hipparcos_epoch = ts.tt(1991.25)
df = hipparcos.load_dataframe(f)
return ts
ts = load.timescale()
ephem = load('de421.bsp')
cet = timezone('CET')
sun, moon, earth = ephem['sun'], ephem['moon'], ephem['earth']
amsterdam = Topos('52.3679 N', '4.8984 E')
amstercentric = earth + amsterdam
t0 = ts.now()
t1 = ts.tt_jd(t0.tt + 1)
nu = t0.utc_datetime().astimezone(cet).time().strftime('%H:%M')
mindist=1.5
from skyfield.constants import GM_SUN_Pitjeva_2005_km3_s2 as GM_SUN
with load.open(mpc.COMET_URL,reload=True) as f:
comets = mpc.load_comets_dataframe(f)
print('Found ',len(comets), ' comets')
comets = (comets.sort_values('reference')
.groupby('designation', as_index=False).last()
.set_index('designation', drop=False))
f = open('cometlist.txt', 'w')
for (c, cometdata) in comets.iterrows():
comet = sun + mpc.comet_orbit(cometdata, ts, GM_SUN)
ra, dec, distance = sun.at(t0).observe(comet).radec()
print(c,' is at ',distance.au,'au')
if (distance.au < mindist):
f.write(c+"\n")
f.close()
from skyfield.data import hipparcos
from skyfield.api import load
from inspect import getmembers
import pdb
planets = load("de421.bsp")
with load.open("hip_main.dat") as f:
stars = hipparcos.load_dataframe(f)
for planet in planets:
print(planet)
pdb.set_trace()
data = {planets: planets, stars: stars}
print(data)
# need to be drawn once, so we take the middle comet date as the single
# time `t` we use for everything else.
ts = load.timescale()
t_comet = ts.utc(2020, 7, range(17, 27))
t = t_comet[len(t_comet) // 2] # middle date
# An ephemeris from the JPL provides Sun and Earth positions.
eph = load('de421.bsp')
sun = eph['sun']
earth = eph['earth']
# The Minor Planet Center data file provides the comet orbit.
with load.open(mpc.COMET_URL) as f:
comets = mpc.load_comets_dataframe(f)
comets = comets.set_index('designation', drop=False)
row = comets.loc['C/2020 F3 (NEOWISE)']
comet = sun + mpc.comet_orbit(row, ts, GM_SUN)
# The Hipparcos mission provides our star catalog.
with load.open(hipparcos.URL) as f:
stars = hipparcos.load_dataframe(f)
# And the constellation outlines come from Stellarium. We make a list
# of the stars at which each edge stars, and the star at which each edge
# ends.
# Altitude and azimuth in the sky of a
# specific geographic location
boston = earth + Topos('42.3583 N', '71.0603 W')
astro = boston.at(ts.utc(1980, 3, 1)).observe(mars)
app = astro.apparent()
alt, az, distance = app.altaz()
print(alt.dstr())
print(az.dstr())
print(distance)
# Measure a star
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
barnards_star = Star.from_dataframe(df.loc[87937])
planets = load('de421.bsp')
earth = planets['earth']
ts = load.timescale()
t = ts.now()
astrometric = boston.at(t).observe(barnards_star)
app_b = astrometric.apparent()
alt_b, az_b, distance_b = app_b.altaz()
print("Bernard star")
print(alt_b.dstr())
def usno_historic_delta_t():
import pandas as pd
f = load.open(_CDDIS + 'historic_deltat.data')
df = pd.read_table(f, sep=b' +', engine='python', skiprows=[1])
return pd.DataFrame({'year': df[b'Year'], 'delta_t': df[b'TDT-UT1']})
def usno_historic_delta_t():
import pandas as pd
f = load.open('http://maia.usno.navy.mil/ser7/historic_deltat.data')
df = pd.read_table(f, sep=rb' +', engine='python', skiprows=[1])
return pd.DataFrame({'year': df[b'Year'], 'delta_t': df[b'TDT-UT1']})
def galactic_Sun_north_center_SD_directions(
measurement_date,
recv_time,
user_longlatdist=geographic_position,
prints=False):
user_longlatdist = np.array(user_longlatdist)
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
planets = load('de421.bsp')
earth = planets['earth']
user_position = earth + Topos(
'{} N'.format(user_longlatdist[0]), '{} E'.format(user_longlatdist[1])
) #user_longlatdist user_longlatdist[0],user_longlatdist[1]
terrestrial_time = format_time_auto(measurement_date, recv_time)
ts = load.timescale()
t = ts.tt(terrestrial_time[0], terrestrial_time[1], terrestrial_time[2],
terrestrial_time[3], terrestrial_time[4], terrestrial_time[5])
sun = planets['sun']
astrometric_sun = user_position.at(t).observe(sun)
alt_sun, az_sun, distance_sun = astrometric_sun.apparent().altaz(
) #astrometric.apparent().altaz() = astrometric_denebola.apparent().altaz()
sun_position = pm.aer2ecef(az_sun.degrees, alt_sun.degrees, distance_sun.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
# Északi Galaktikus Pólus (RA: 12h 51.42m; D: 27° 07.8′, epocha J2000.0)
coma_berenices = Star(ra_hours=(12, 51, 25.2), dec_degrees=(27, 7, 48.0))
astrometric_berenice = user_position.at(t).observe(coma_berenices)
alt_b, az_b, distance_b = astrometric_berenice.apparent().altaz()
berenice_position = pm.aer2ecef(az_b.degrees, alt_b.degrees, distance_b.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
# Galaktikus Center (RA: 12h 51.42m; D: 27° 07.8′, epocha J2000.0) 17h 45.6m −28.94°
galactic_center = Star(ra_hours=(17, 45, 36.0),
dec_degrees=(-28, 56, 24.0))
astrometric_center = user_position.at(t).observe(galactic_center)
alt_c, az_c, distance_c = astrometric_center.apparent().altaz()
center_position = pm.aer2ecef(az_c.degrees, alt_c.degrees, distance_c.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
nunki = Star.from_dataframe(df.loc[92855])
astrometric_nunki = user_position.at(t).observe(nunki)
alt_n, az_n, distance_n = astrometric_nunki.apparent().altaz(
) #astrometric.apparent().altaz() = astrometric_denebola.apparent().altaz()
star_pos_n = pm.aer2ecef(az_n.degrees, alt_n.degrees, distance_n.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
capella = Star.from_dataframe(df.loc[24608])
astrometric_capella = user_position.at(t).observe(capella)
alt_ca, az_ca, distance_ca = astrometric_capella.apparent().altaz(
) #astrometric.apparent().altaz() = astrometric_denebola.apparent().altaz()
star_pos_ca = pm.aer2ecef(az_ca.degrees, alt_ca.degrees, distance_ca.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
denebola = Star.from_dataframe(df.loc[57632])
astrometric_denebola = user_position.at(t).observe(denebola)
alt_d, az_d, distance_d = astrometric_denebola.apparent().altaz(
) #astrometric.apparent().altaz() = astrometric_denebola.apparent().altaz()
star_pos_d = pm.aer2ecef(az_d.degrees, alt_d.degrees, distance_d.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
sadalmelik = Star.from_dataframe(df.loc[109074])
astrometric_sadalmelik = user_position.at(t).observe(sadalmelik)
alt_s, az_s, distance_s = astrometric_sadalmelik.apparent().altaz()
star_pos_s = pm.aer2ecef(az_s.degrees, alt_s.degrees, distance_s.m,
user_longlatdist[0], user_longlatdist[1],
user_longlatdist[2])
if prints:
print('Time: ', terrestrial_time)
print('Location: ', '{} N'.format(user_longlatdist[0]),
'{} E'.format(user_longlatdist[1]))
print('Sun (alt/az): ', alt_sun, az_sun)
print('Coma Berenice (alt/az): ', alt_b, az_b)
print('Galactic Center (alt/az): ', alt_c, az_c)
print('Nunki (alt/az): ', alt_n, az_n)
print('Capella (alt/az): ', alt_ca, az_ca)
print('Denebola (alt/az): ', alt_d, az_d)
print('Sadalmelik (alt/az): ', alt_s, az_s)
stars_pos = [
sun_position, berenice_position, center_position, star_pos_n,
star_pos_ca, star_pos_d, star_pos_s
]
return stars_pos
"""Check Skyfield lunar eclipses against the huge NASA table of eclipses."""
from collections import Counter
from skyfield import eclipselib
from skyfield.api import load, GREGORIAN_START
import datetime as dt
with load.open('https://eclipse.gsfc.nasa.gov/5MCLE/5MKLEcatalog.txt') as f:
data = f.read()
ts = load.timescale()
ts.julian_calendar_cutoff = GREGORIAN_START
table = []
lines = data.decode('ascii').splitlines()
for line in lines[14:]:
year = int(line[7:12])
if year < 1 or year >= 3000:
#if year < 1900 or year > 1920:
continue
datestr = line[8:29]
d = dt.datetime.strptime(datestr, '%Y %b %d %H:%M:%S')
t = ts.tt(d.year, d.month, d.day, d.hour, d.minute, d.second)
table.append((t, line[51]))
time0 = table[0][0]
timeN = table[-1][0]
start_time = ts.tt_jd(time0.whole - 1, time0.tt_fraction)
end_time = ts.tt_jd(timeN.whole + 1, timeN.tt_fraction)
def index(request):
stars = []
if request.body:
req = json.loads(request.body)
if req['type'] == 'GET_VISIBLE_STARS':
planets = load('de421.bsp')
earth = planets['earth']
ts = load.timescale()
dt = datetime.strptime(req['date'], '%Y-%m-%dT%H:%M:%S.%fZ')
dt = dt.replace(tzinfo=timezone.utc)
t = ts.utc(dt)
observerLocation = earth + \
Topos(latitude_degrees=req['lat'],
longitude_degrees=req['long'])
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
for key in navigationStarsHip:
starname = key
hipNo = navigationStarsHip[key]
star = Star.from_dataframe(df.loc[hipNo])
apparent = observerLocation.at(t).observe(star).apparent()
alt, az, dist = apparent.altaz()
eachStar = {
'name': key,
'hip': navigationStarsHip[key],
'alt': alt.degrees,
'az': az.degrees,
'dist': dist.km
}
if eachStar['alt'] > 0 :
stars.append(eachStar)
if req['type'] == 'GET_TBRG_STAR':
planets = load('de421.bsp')
earth = planets['earth']
ts = load.timescale()
dt = datetime.strptime(req['date'], '%Y-%m-%dT%H:%M:%S.%fZ')
dt = dt.replace(tzinfo=timezone.utc)
t = ts.utc(dt)
observerLocation = earth + \
Topos(latitude_degrees=req['lat'],
longitude_degrees=req['long'])
with load.open(hipparcos.URL) as f:
df = hipparcos.load_dataframe(f)
starname = req['selectedStar']
hipNo = navigationStarsHip[starname]
star = Star.from_dataframe(df.loc[hipNo])
apparent = observerLocation.at(t).observe(star).apparent()
alt, az, dist = apparent.altaz()
return JsonResponse({
'name': starname,
'hipNo': navigationStarsHip[starname],
'alt': alt.degrees,
'az': az.degrees,
'dist': dist.km
})
if (req['type'] == 'GET_TBRG_PLANET'):
planets = load('de421.bsp')
earth = planets['earth']
ts = load.timescale()
dt = datetime.strptime(req['date'], '%Y-%m-%dT%H:%M:%S.%fZ')
dt = dt.replace(tzinfo=timezone.utc)
t = ts.utc(dt)
observerLocation = earth + \
Topos(latitude_degrees=req['lat'],
longitude_degrees=req['long'])
planet = planets[req['body']]
apparent = observerLocation.at(t).observe(planet).apparent()
alt, az, dist = apparent.altaz()
return JsonResponse({
"alt": alt.degrees,
"az": az.degrees,
"dist": dist.km
})
def usno_historic_delta_t():
import pandas as pd
f = load.open('http://maia.usno.navy.mil/ser7/historic_deltat.data')
df = pd.read_table(f, sep=rb' +', engine='python', skiprows=[1])
return pd.DataFrame({'year': df[b'Year'], 'delta_t': df[b'TDT-UT1']})
def draw_plot_comparing_USNO_and_IERS_data():
f = load.open('finals.all')
year, month, day, dut1 = iers.parse_dut1_from_finals_all(f)
# auto-detect leap seconds
leap_seconds = np.diff(dut1) > 0.9
#x = np.append(leap_seconds > 0.9, False)
#x = np.prepend(leap_seconds > 0.9, False)
#x = np.concatenate([leap_seconds > 0.9, [False]]).astype(bool)
x = np.concatenate([
[False],
leap_seconds,
])
print(x)
print(x, sum(x))
print(year[x])
print(month[x])
print(day[x])
delta_t = dut1 - np.cumsum(x)
ts = load.timescale()
t = ts.utc(year, month, day)
y_new = dut1
y_old = t.dut1
# and: figure out error cost of interpolating weeks or months
all_points = np.arange(len(delta_t))
samples = all_points[::600] + 0.001
print(f'{len(samples)} samples')
for skip in range(1, 40):
index = np.arange(0, len(delta_t), skip)
excerpt = delta_t[index]
interpolated = np.interp(all_points, index, excerpt)
difference_seconds = abs(interpolated - delta_t).max()
difference_arcseconds = difference_seconds / 24.0 * 360.0
storage = 4 * len(excerpt)
t0 = time()
np.interp(samples, index, excerpt)
duration = time() - t0
fmt = '{:2} days {:10.6f} s {:10.6f} arcseconds {} bytes {:.6f} s'
print(
fmt.format(
skip,
difference_seconds,
difference_arcseconds,
storage,
duration,
))
#print(dut1)
fig, ax = plt.subplots()
ax.set(xlabel='Year', title='UT1 minus UTC')
# ax.plot(t.J, y_old, '-', label='deltat.dat')
# ax.plot(t.J, y_new, ',', label='finals.all')
ax.plot(delta_t)
ax.plot(np.diff(delta_t))
ax.grid()
plt.legend()
fig.savefig('tmp.png')
print(len(y_new))
np.savez_compressed(
'test.npz',
time=t.J,
ut1_minus_utc=y_new,
)
def create_starmap(name, timestamp, days_past, days_future, fov, magnitude):
# The comet is plotted on several dates `t_transient`. But the stars only
# need to be drawn once, so we take the middle comet date as the single
# time `t` we use for everything else.
try:
# first try comets
d, transient = algorithms.get_comet(name, timestamp)
except:
# then try asteroids
d, transient = algorithms.get_asteroid(name, timestamp)
ts = load.timescale()
t_timestamp = ts.utc(timestamp.year, timestamp.month, timestamp.day,
timestamp.hour, timestamp.minute)
t_transient = ts.utc(
timestamp.year, timestamp.month,
range(timestamp.day - days_past, timestamp.day + days_future))
t = t_transient[len(t_transient) // 2] # middle date
# An ephemeris from the JPL provides Sun and Earth positions.
eph = load('de421.bsp')
earth = eph['earth']
# The Hipparcos mission provides our star catalog.
# with load.open(hipparcos.URL) as f:
with load.open(settings.MY_HIPPARCOS_URL) as f:
stars = hipparcos.load_dataframe(f)
# And the constellation outlines come from Stellarium. We make a list
# of the stars at which each edge stars, and the star at which each edge
# ends.
url = ('https://raw.githubusercontent.com/Stellarium/stellarium/master'
'/skycultures/western_SnT/constellationship.fab')
with load.open(url) as f:
constellations = stellarium.parse_constellations(f)
edges = [edge for name, edges in constellations for edge in edges]
edges_star1 = [star1 for star1, star2 in edges]
edges_star2 = [star2 for star1, star2 in edges]
# We will center the chart on the comet's middle position.
center = earth.at(t).observe(transient)
#star = Star(ra_hours=(17, 57, 48.49803), dec_degrees=(4, 41, 36.2072))
#center = earth.at(t).observe(star)
projection = build_stereographic_projection(center)
field_of_view_degrees = float(fov)
limiting_magnitude = magnitude
# Now that we have constructed our projection, compute the x and y
# coordinates that each star and the comet will have on the plot.
star_positions = earth.at(t).observe(Star.from_dataframe(stars))
stars['x'], stars['y'] = projection(star_positions)
transient_x, transient_y = projection(
earth.at(t_transient).observe(transient))
# Create a True/False mask marking the stars bright enough to be
# included in our plot. And go ahead and compute how large their
# markers will be on the plot.
bright_stars = (stars.magnitude <= limiting_magnitude)
magnitude = stars['magnitude'][bright_stars]
marker_size = (0.5 + limiting_magnitude - magnitude)**2.0
# The constellation lines will each begin at the x,y of one star and end
# at the x,y of another. We have to "rollaxis" the resulting coordinate
# array into the shape that matplotlib expects.
xy1 = stars[['x', 'y']].loc[edges_star1].values
xy2 = stars[['x', 'y']].loc[edges_star2].values
lines_xy = np.rollaxis(np.array([xy1, xy2]), 1)
# Time to build the figure!
fig, ax = plt.subplots(figsize=[12, 12])
# Draw the constellation lines.
ax.add_collection(LineCollection(lines_xy, colors='#00f2'))
# Draw the stars.
ax.scatter(stars['x'][bright_stars],
stars['y'][bright_stars],
s=marker_size,
color='k')
# Draw the comet positions, and label them with dates.
transient_color = '#f00'
offset = 0.0005
ax.plot(transient_x, transient_y, '+', c=transient_color, zorder=3)
for xi, yi, tstr in zip(transient_x, transient_y,
t_transient.utc_strftime('%m/%d')):
tstr = tstr.lstrip('0')
text = ax.text(xi + offset,
yi - offset,
tstr,
color=transient_color,
ha='left',
va='top',
fontsize=9,
weight='bold',
zorder=-1)
text.set_alpha(0.5)
# Finally, title the plot and set some final parameters.
angle = np.pi - field_of_view_degrees / 360.0 * np.pi
limit = np.sin(angle) / (1.0 - np.cos(angle))
ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.set_aspect(1.0)
ax.set_title('{} {} through {}'.format(
d['designation'],
t_transient[0].utc_strftime('%d %B %Y'),
t_transient[-1].utc_strftime('%d %B %Y'),
))
# Save.
filename = 'starmap.png'
path = os.path.join(settings.MEDIA_ROOT, filename)
fig.savefig(path, bbox_inches='tight')
image_url = os.path.join(settings.MEDIA_URL, filename)
return image_url
