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 _stars(self) -> DataFrame: logging.info("Loading Hipparcos data") with self.load.open(hipparcos.URL) as f: df = hipparcos.load_dataframe(f) # Filter out the ones with no reliable position df = df[df["ra_degrees"].notnull()] return df
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 test_dataframe(): with api.load.open('hip_main.dat.gz') as f: df = load_dataframe(f) star = api.Star.from_dataframe(df) assert repr( star ) == 'Star(ra shape=214, dec shape=214, ra_mas_per_year shape=214, dec_mas_per_year shape=214, parallax_mas shape=214, epoch shape=214)'
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 test_hipparcos(): try: df = load_dataframe(BytesIO(gzip.compress(sample_hipparcos_line))) except ImportError: raise SkipTest('pandas not available') assert len(df) == 1 row = df.iloc[0] assert abs(row.ra_degrees - 000.00091185) < 1e-30 assert abs(row.ra_hours == 000.00091185 / 15.0) < 1e-30
def __init__(self, time_only=False): path = pathlib.Path( __file__).parent.parent.absolute() / 'skyfield-data' load = Loader(path.as_posix()) self.timescale = load.timescale() self.timescale.julian_calendar_cutoff = GREGORIAN_START if not time_only: self.ephemeris = load('de431t.bsp') self.babylon_topos = Topos(*BABYLON_COORDS) with load.open(hipparcos.URL) as f: self.stars = hipparcos.load_dataframe(f)
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 test_hipparcos(): b = BytesIO() g = gzip.GzipFile(mode='wb', fileobj=b) g.write(sample_hipparcos_line) g.close() b.seek(0) try: df = load_dataframe(b) except ImportError: # raise SkipTest('pandas not available') # Assay doesn't understand skipping tests yet; just pass # for now if Pandas cannot be imported. return assert len(df) == 1 row = df.iloc[0] assert abs(row.ra_degrees - 000.00091185) < 1e-30 assert abs(row.dec_degrees - +01.08901332) < 1e-30
def test_hipparcos(): b = BytesIO() g = gzip.GzipFile(mode='wb', fileobj=b) g.write(sample_hipparcos_line) g.close() b.seek(0) try: df = load_dataframe(b) except ImportError: # raise SkipTest('pandas not available') # Assay doesn't understand skipping tests yet; just pass # for now if Pandas cannot be imported. return assert len(df) == 1 row = df.iloc[0] assert abs(row.ra_degrees - 000.00091185) < 1e-30 assert abs(row.dec_degrees - +01.08901332) < 1e-30
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 init_sf(spad): global ts, eph, earth, moon, sun, venus, mars, jupiter, saturn, df load = Loader(spad) # spad = folder to store the downloaded files EOPdf = "finals2000A.all" # Earth Orientation Parameters data file dfIERS = spad + 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, 3, 4]): eph = load(config.ephemeris[config.ephndx][0]) # load chosen ephemeris earth = eph['earth'] moon = eph['moon'] sun = eph['sun'] venus = eph['venus'] jupiter = eph['jupiter barycenter'] saturn = eph['saturn barycenter'] if config.ephndx >= 3: mars = eph['mars barycenter'] else: mars = eph['mars'] # 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
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. 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]
def create_starmap(command, observation_id): # The comet is plotted on several dates `t_comet`. 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. ts = load.timescale() t_comet = ts.utc(2020, 8, range(1, 10)) 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.sort_values('reference') .groupby('designation', as_index=False).last() .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: 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(comet) projection = build_stereographic_projection(center) field_of_view_degrees = 30.0 limiting_magnitude = 8.0 # 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) comet_x, comet_y = projection(earth.at(t_comet).observe(comet)) # 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=[9, 9]) # 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. comet_color = '#f00' offset = 0.002 ax.plot(comet_x, comet_y, '+', c=comet_color, zorder=3) for xi, yi, tstr in zip(comet_x, comet_y, t_comet.utc_strftime('%m/%d')): tstr = tstr.lstrip('0') text = ax.text(xi + offset, yi - offset, tstr, color=comet_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('Comet NEOWISE {} through {}'.format( t_comet[0].utc_strftime('%Y %B %d'), t_comet[-1].utc_strftime('%Y %B %d'), )) # 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
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 })
# 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()) print(az_b.dstr())
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
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
def compute_all(): yield compute('Sun', precision_radec=1) yield compute('Moon') yield compute('Jupiter barycenter', planet=599) yield compute('Io', kernel=jup365) # XXX: Those tests might fail when we update the planet.ini data since # the orbits are not stable. t = [2021, 3, 22, 15, 0, 0] yield compute('Metis', kernel=jup365, t=t, precision_radec=15, precision_azalt=20) yield compute('Thebe', kernel=jup365, t=t, precision_radec=15, precision_azalt=20) yield compute('Phobos', kernel=mar097, t=t, precision_radec=5, precision_azalt=10) yield compute('Deimos', kernel=mar097, precision_radec=5, t=t, precision_azalt=10) yield compute('Pluto barycenter', planet=999, t=t, precision_radec=10, precision_azalt=15) yield compute('Pluto barycenter', planet=999, t=t, precision_radec=10, precision_azalt=15) # ISS, using TLE as of 2019-08-04. tle = [ '1 25544U 98067A 19216.19673594 -.00000629 00000-0 -27822-5 0 9998', '2 25544 51.6446 123.0769 0006303 213.9941 302.5470 15.51020378182708', ] iss = sf.EarthSatellite(*tle, 'ISS (ZARYA)') iss = de421['earth'] + iss json = { 'model_data': { 'norad_number': 25544, 'tle': tle, } } yield compute(iss, name='ISS', t=[2019, 8, 4, 17, 0], json=json, planet=0, klass='tle_satellite', precision_radec=15, precision_azalt=15) yield compute( iss, name='ISS', t=[2019, 8, 3, 20, 51, 46], json=json, topo=['43.4822 N', '1.432 E'], # Goyrans planet=0, klass='tle_satellite', precision_radec=100, precision_azalt=100) # Pallas, using MPC data as of 2019-08-06. data = { "Epoch": 2458600.5, "M": 59.69912, "Peri": 310.04884, "Node": 173.08006, "i": 34.83623, "e": 0.2303369, "n": 0.21350337, "a": 2.772466 } yield compute_asteroid('Pallas', data=data, t='2019/08/10 17:00', precision_radec=200, precision_azalt=400) with sf.load.open(hipparcos.URL) as f: df = hipparcos.load_dataframe(f) polaris = sf.Star.from_dataframe(df.loc[11767]) yield compute_star(polaris, name='Polaris') proxima = sf.Star.from_dataframe(df.loc[70890]) yield compute_star(proxima, name='Proxima Centauri') barnard = sf.Star.from_dataframe(df.loc[87937]) yield compute_star(barnard, name='Barnards Star')