def print_constellation(constellation): for el in constellation: #print(el[0] , " and " , el[1]) star = Star.from_dataframe(df.loc[el[0]]) star_prev = Star.from_dataframe(df.loc[el[1]]) astrometric_star = earth.at(t).observe(star) ra_s, dec_s, distance_s = astrometric_star.radec() astrometric_star_p = earth.at(t).observe(star_prev) ra_s_p, dec_s_p, distance_s_p = astrometric_star_p.radec() hours_s = list() hours_s.append(ra_s.hours) hours_s.append(ra_s_p.hours) deg_s = list() deg_s.append(dec_s.degrees) deg_s.append(dec_s_p.degrees) #print(hours_s[0], " and " , deg_s[0]) #print(hours_s[1], " and " , deg_s[1]) plt.plot(hours_s, deg_s, 'bo-', linewidth=2) #plt.scatter(ra.hours, dec.degrees, 8 - df['magnitude'], 'k') plt.show()
def icrs_to_cirs(ra, dec, epoch, apparent=True): """Convert a set of positions from ICRS to CIRS at a given data. Parameters ---------- ra, dec : float or np.ndarray Positions of source in ICRS coordinates including an optional redshift position. epoch : time_like Time to convert the positions to. Can be any type convertible to a time using `caput.time.ensure_unix`. apparent : bool Calculate the apparent position (includes abberation and deflection). Returns ------- ra_cirs, dec_cirs : float or np.ndarray Arrays of the positions in *CIRS* coordiantes. """ positions = Star(ra=Angle(degrees=ra), dec=Angle(degrees=dec)) epoch = ctime.unix_to_skyfield_time(ctime.ensure_unix(epoch)) earth = ctime.skyfield_wrapper.ephemeris["earth"] positions = earth.at(epoch).observe(positions) if apparent: positions = positions.apparent() ra_cirs, dec_cirs, _ = positions.cirs_radec(epoch) return ra_cirs._degrees, dec_cirs._degrees
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 get_stars_azimut_altitude(self, constellation): azimut_alt = list() for el in constellation: t = self.ts.now() #print(el[0] , " and " , el[1]) star = Star.from_dataframe(self.df.loc[el[0]]) star_next = Star.from_dataframe(self.df.loc[el[1]]) astro = self.position.at(t).observe(star) astro_next = self.position.at(t).observe(star_next) app = astro.apparent() app_next = astro_next.apparent() alt, az, distance = app.altaz() alt_next, az_next, distance_next = app_next.altaz() azimut_alt.append( ((az.dstr().split("deg", 1)[0], alt.dstr().split("deg", 1)[0]), (az_next.dstr().split("deg", 1)[0], alt_next.dstr().split("deg", 1)[0]))) return azimut_alt
def draw(self, ax, when): """ Draw on a matplotlib axis. Draw a representation of the constellation at a certain time projected onto the observation disk. This will look a bit strange with our given projection... they'll look kind of upside down. """ plotted = [] # don't repeat star points for (ra1, dec1), (ra2, dec2) in self._radec_pairs: star1 = Star(ra_hours=ra1, dec_degrees=dec1) star2 = Star(ra_hours=ra2, dec_degrees=dec2) azi1, alt1 = self._sky.compute_position(star1, when) azi2, alt2 = self._sky.compute_position(star2, when) # alt1 = 90 - alt1 # alt2 = 90 - alt2 if alt1 > 90 and alt1 > 90: # skip constellations that are not visible continue if (azi1, alt1) not in plotted: ax.scatter( azi1, alt1, s=10, alpha=0.1, color="black", edgecolor="black", ) plotted.append((azi1, alt1)) if (azi2, alt2) not in plotted: ax.scatter( azi2, alt2, s=10, alpha=0.1, color="black", edgecolor="black", ) plotted.append((azi2, alt2)) # avoid wrap-arounds azimuthally if azi2 - azi1 > math.pi: azi1 += math.pi * 2 elif azi1 - azi2 > math.pi: azi2 += math.pi * 2 ax.plot( np.linspace(azi1, azi2, 10), np.linspace(alt1, alt2, 10), "-", color="k", linewidth=1, alpha=0.1, )
def cirs_radec(body, date=None, deg=False, obs=chime): """Converts a Skyfield body in CIRS coordinates at a given epoch to ICRS coordinates observed from CHIME Parameters ---------- body : skyfield.api.Star Skyfield Star object with positions in CIRS coordinates. Returns ------- new_body : skyfield.api.Star Skyfield Star object with positions in ICRS coordinates """ from skyfield.positionlib import Angle from skyfield.api import Star ts = skyfield_wrapper.timescale epoch = ts.tt_jd(np.median(body.epoch)) pos = obs.skyfield_obs().at(epoch).observe(body) # Matrix CT transforms from CIRS to ICRF (https://rhodesmill.org/skyfield/time.html) r_au, dec, ra = skyfield.functions.to_polar( np.einsum("ij...,j...->i...", epoch.CT, pos.position.au)) return Star(ra=Angle(radians=ra, preference="hours"), dec=Angle(radians=dec), epoch=epoch)
def transform_to_altaz(self, tf=None, sky=None, mount_set_icrs=None): # use ev. other refraction methods if sky is None: tem = pre = hum = 0. else: tem = sky.temperature pre = sky.pressure hum = sky.humidity ra = Angle(radians=tf.ra.radian * u.radian) dec = Angle(radians=tf.dec.radian * u.radian) star = Star(ra=ra, dec=dec) t = self.ts.utc(tf.obstime.datetime.replace(tzinfo=utc)) if mount_set_icrs: # Apparent GCRS ("J2000.0") coordinates alt, az, distance = self.obs.at(t).observe(star).apparent().altaz() else: # is already apparent # alt, az, distance = self.obs.at(t).observe(star).apparent().altaz() aa = SkyCoord(az=az.to(u.radian), alt=alt.to(u.radian), unit=(u.radian, u.radian), frame='altaz', location=tf.location, obstime=tf.obstime, pressure=pre, temperature=tem, relative_humidity=hum) return aa
def _convert_radec_to_altaz(ra, dec, lon, lat, height, time): """Convert a single position. This is done for easy code sharing with other tools. Skyfield does support arrays of positions. """ load = Loader('.') # Skyfield uses FTP URLs, but FTP doesn't work on Github Actions so # we use alternative HTTP URLs. load.urls['finals2000A.all'] = 'https://datacenter.iers.org/data/9/' load.urls['.bsp'] = [ ('*.bsp', 'https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/') ] radec = Star(ra=Angle(degrees=ra), dec=Angle(degrees=dec)) earth = load(EPHEMERIS)['earth'] location = earth + wgs84.latlon(longitude_degrees=lon, latitude_degrees=lat, elevation_m=height * 1000.0) ts = load.timescale(builtin=False) with load.open('finals2000A.all') as f: finals_data = iers.parse_x_y_dut1_from_finals_all(f) iers.install_polar_motion_table(ts, finals_data) obstime = ts.from_astropy(Time(time, scale='utc')) alt, az, _ = location.at(obstime).observe(radec).apparent().altaz( pressure_mbar=0) return dict(az=az.degrees, alt=alt.degrees)
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 __init__(self, object_name, session): super().__init__(object_name, session) if type(object_name) == ongc.Dso: self.dso = object_name # If class initialized directly with a Dso, use it, else create a new one. else: try: self.dso = ongc.Dso(object_name) except Exception as e: logging.warning(e) #print("DSO:", self.dso, type(self.dso)) #self.kind = 'Deep Space object' # TODO: distinguish between stars, galaxies... #self.constellation = '' ra_arr, dec_arr = self.dso.getCoords() self.ra, self.dec = tuple(ra_arr), tuple(dec_arr) self.alt_ids = self.dso.getIdentifiers() self.constellation = self.dso.getConstellation() self.kind = self.dso.getType() self.star = Star(ra_hours=self.ra, dec_degrees=self.dec) self.star_astro_now = self.astrometric = self.session.here.at( self.session.start).observe(self.star) self.apparent = self.astrometric.apparent() self.alt, self.az, self.distance = self.apparent.altaz('standard') ra_arr, dec_arr = self.dso.getCoords() self.ra, self.dec = tuple(ra_arr), tuple(dec_arr) self.alt_ids = self.dso.getIdentifiers() self.messier = self.alt_ids[0] self.constellation = self.dso.getConstellation() self.kind = self.dso.getType()
def make_chart_sdss(self, ra, de, pmra, pmde, name, outdir='findercharts_1d/'): ra_ang = Angle(degrees=ra) de_ang = Angle(degrees=de) star_obj = Star(ra=ra_ang, dec=de_ang, ra_mas_per_year=pmra, dec_mas_per_year=pmde) astrometric = self.earth.at(self.t).observe(star_obj) astrometric_old = self.earth.at(self.t_2000).observe(star_obj) ra_out, dec_out, dist_out = astrometric.radec() ra_out1, dec_out1, dist_out1 = astrometric_old.radec() ra_new = ra_out.to(u.degree).value de_new = dec_out.to(u.degree).value ra_old = ra_out1.to(u.degree).value de_old = dec_out1.to(u.degree).value raline = [ra_old, ra_new] deline = [de_old, de_new] cc = astropy.coordinates.SkyCoord(ra, de, unit=(u.degree, u.degree)) cc_new = astropy.coordinates.SkyCoord(ra_new, de_new, unit=(u.degree, u.degree)) cc_old = astropy.coordinates.SkyCoord(ra_old, de_old, unit=(u.degree, u.degree)) fig = figure(figsize=(10, 12)) fovrad = astropy.coordinates.Angle('0d4m0s') oo, oh = astroplan.plots.plot_finder_image(cc_old, reticle=True, survey='2MASS-K') oo.set_autoscale_on(False) oo.plot(raline, deline, transform=oo.get_transform('icrs')) oo.set_title(name, fontsize=20) ra_s = cc_new.ra.to_string(unit=u.hour, sep=':') de_s = cc_new.dec.to_string(unit=u.degree, sep=':') #ra_s = [alltargs_uniq.loc[i,'cc'].ra.to_string(unit=u.hour,sep=':') for i in ai] #oo.text(0,-.1,'TEST',transform=oo.transAxes) oo.text(0, -.1, 'RA (ICRS): ' + ra_s, transform=oo.transAxes, fontsize=20) oo.text(0, -.15, 'DEC (ICRS): ' + de_s, transform=oo.transAxes, fontsize=20) fig.savefig(outdir + name + '.pdf') close(fig)
def __init__(self): # load the planetary positions and our position self.planets = load('de421.bsp') self.earth = self.planets['earth'] self.Cas_A = Star(ra_hours=(23, 23, 5.00), dec_degrees=(58, 46, 0.00), epoch=1992.5) self.sources = {"CAS_A":self.Cas_A, "SUN":self.planets['sun'], "MOON":self.planets['moon']}
def radec_with_proper_motion(self, ra, de, pmra, pmde, verbose=False): """ Calculate the INPUT: - ra in degrees - dec in degrees - pmra - in mas/yr - pmdec - in mas/yr OUTPUT: - Angle NOTES: - Built on Ryan's code """ ra_ang = Angle(degrees=ra) de_ang = Angle(degrees=de) star_obj = Star(ra=ra_ang, dec=de_ang, ra_mas_per_year=pmra, dec_mas_per_year=pmde) astrometric = self.earth.at(self.t).observe(star_obj) astrometric_old = self.earth.at(self.t_2000).observe(star_obj) ra_out, dec_out, dist_out = astrometric.radec() ra_out1, dec_out1, dist_out1 = astrometric_old.radec() ra_new = ra_out.to(u.degree).value de_new = dec_out.to(u.degree).value ra_old = ra_out1.to(u.degree).value de_old = dec_out1.to(u.degree).value raline = [ra_old, ra_new] deline = [de_old, de_new] cc = astropy.coordinates.SkyCoord(ra, de, unit=(u.degree, u.degree)) cc_new = astropy.coordinates.SkyCoord(ra_new, de_new, unit=(u.degree, u.degree)) cc_old = astropy.coordinates.SkyCoord(ra_old, de_old, unit=(u.degree, u.degree)) self.cc_old = cc_old self.cc_new = cc_new self.ra_s_new = cc_new.ra.to_string(unit=u.hour, sep=':') self.de_s_new = cc_new.dec.to_string(unit=u.degree, sep=':') self.ra_s_old = cc_old.ra.to_string(unit=u.hour, sep=':') self.de_s_old = cc_old.dec.to_string(unit=u.degree, sep=':') if verbose: print("Coordinates at {:f}: RA={} DEC={}".format( self.epoch_old, self.ra_s_old, self.de_s_old)) print("with PMRA={} PMDEC={}".format(pmra, pmde)) print("Coordinates at {:f}: RA={} DEC={}".format( self.epoch_new, self.ra_s_new, self.de_s_new)) print("") return cc_new
def transform_to_hadec(self, tf=None, sky=None, mount_set_icrs=None): tem = sky.temperature pre = sky.pressure hum = sky.humidity ra = Angle(radians=tf.ra.radian * u.radian) dec = Angle(radians=tf.dec.radian * u.radian) star = Star(ra=ra, dec=dec) #HA= self.obs.sidereal_time() - star.ra #ha=SkyCoord(ra=HA,dec=star.dec, unit=(u.radian,u.radian), frame='cirs',location=tf.location,obstime=tf.obstime,pressure=pre,temperature=tem,relative_humidity=hum) self.lg.error('not yet implemented') sys.exit(1)
def predict_without_uncertainties(self, mjd, complain=True): """Predict the object position at a given MJD. The return value is a tuple ``(ra, dec)``, in radians, giving the predicted position of the object at *mjd*. Unlike :meth:`predict`, the astrometric uncertainties are ignored. This function is therefore deterministic but potentially misleading. If *complain* is True, print out warnings for incomplete information. This function relies on the external :mod:`skyfield` package. """ import sys from skyfield.api import Star self.verify(complain=complain) planets, ts = load_skyfield_data( ) # might download stuff from the internet earth = planets['earth'] t = ts.tdb(jd=mjd + 2400000.5) # "Best" position. The implementation here is a bit weird to keep # parallelism with predict(). args = { 'ra_hours': self.ra * R2H, 'dec_degrees': self.dec * R2D, } if self.pos_epoch is not None and self.pos_epoch != 51544.5: print_( 'AstrometryInfo.predict_without_uncertainties(): ' 'ignoring epoch of position!', file=sys.stderr) ### o.promoepoch = self.pos_epoch + 2400000.5 ###else: ### if complain: ### print_ ('AstrometryInfo.predict(): assuming epoch of position is J2000.0', file=sys.stderr) ### o.promoepoch = 2451545.0 # J2000.0 if self.promo_ra is not None: args['ra_mas_per_year'] = self.promo_ra args['dec_mas_per_year'] = self.promo_dec if self.parallax is not None: args['parallax_mas'] = self.parallax if self.vradial is not None: args['radial_km_per_s'] = self.vradial bestra, bestdec, _ = earth.at(t).observe(Star(**args)).radec() return bestra.radians, bestdec.radians
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 calc_radec_w_proper_motion(ra, de, pmra, pmde, epoch=2018.): planets = load('/Users/gks/Dropbox/mypylib/notebooks/GIT/HETobs/de421.bsp') ts = load.timescale() earth = planets['earth'] t = ts.utc(epoch) t_2000 = ts.utc(2000) ra_ang = Angle(degrees=ra) de_ang = Angle(degrees=de) star_obj = Star(ra=ra_ang, dec=de_ang, ra_mas_per_year=pmra, dec_mas_per_year=pmde) astrometric = earth.at(t).observe(star_obj) ra_out, dec_out, dist_out = astrometric.radec() ra_new = ra_out.to(u.degree).value de_new = dec_out.to(u.degree).value print("Old:", ra, de) print("New:", ra_new, de_new) return ra_new, de_new
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 _convert_radec_to_altaz(ra, dec, lon, lat, height, time): """Convert a single position. This is done for easy code sharing with other tools. Skyfield does support arrays of positions. """ radec = Star(ra=Angle(degrees=ra), dec=Angle(degrees=dec)) earth = load(EPHEMERIS)['earth'] location = earth + Topos(longitude_degrees=lon, latitude_degrees=lat, elevation_m=height * 1000.0) ts = load.timescale() obstime = ts.from_astropy(Time(time, scale='utc')) alt, az, _ = location.at(obstime).observe(radec).apparent().altaz(pressure_mbar=0) return dict(az=az.degrees, alt=alt.degrees)
def stellar_info(d): # used in starstab # returns a list of lists with name, SHA and Dec all navigational stars for epoch of date. t12 = ts.ut1(d.year, d.month, d.day, 12, 0, 0) #calculate at noon out = [] for line in db.strip().split('\n'): x1 = line.index(',') name = line[0:x1] HIPnum = line[x1 + 1:] star = Star.from_dataframe(df.loc[int(HIPnum)]) astrometric = earth.at(t12).observe(star).apparent() ra, dec, distance = astrometric.radec(epoch='date') sha = fmtgha(0, ra.hours) decl = fmtdeg(dec.degrees) out.append([name, sha, decl]) return out
def Star_cirs(ra, dec, epoch): """Wrapper for skyfield.api.star that creates a position given CIRS coordinates observed from CHIME Parameters ---------- ra, dec : skyfield.api.Angle RA and dec of the source in CIRS coordinates epoch : skyfield.api.Time Time of the observation Returns ------- body : skyfield.api.Star Star object in ICRS coordinates """ from skyfield.api import Star return cirs_radec(Star(ra=ra, dec=dec, epoch=epoch))
def mp_stellar_info(d, ts, df, n): # used in starstab # returns a list of lists with name, SHA and Dec all navigational stars for epoch of date. # 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) eph = load(config.ephemeris[config.ephndx][0]) # load chosen ephemeris earth = eph['earth'] t00 = ts.ut1(d.year, d.month, d.day, 0, 0, 0) #calculate at midnight #t12 = ts.ut1(d.year, d.month, d.day, 12, 0, 0) #calculate at noon out = [] if n == 0: db = db1 elif n == 1: db = db2 elif n == 2: db = db3 elif n == 3: db = db4 elif n == 4: db = db5 else: db = db6 for line in db.strip().split('\n'): x1 = line.index(',') name = line[0:x1] HIPnum = line[x1 + 1:] star = Star.from_dataframe(df.loc[int(HIPnum)]) astrometric = earth.at(t00).observe(star).apparent() ra, dec, distance = astrometric.radec(epoch='date') sha = fmtgha(0, ra.hours) decl = fmtdeg(dec.degrees) out.append([name, sha, decl]) return out
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 = 45.0 limiting_magnitude = 7.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.
c1 = T_pos((t, t0, coord), pmra, pmdec, plx, vrad) Ricky_coord = SkyCoord(ra=ricky[0, 1], dec=ricky[0, 4], unit='deg', frame='icrs') #print 'new - ricky:', c1.separation(Ricky_coord).arcsec[0] * 1000. #print 'new - ricky (acosd):', (c1.ra.deg[0] - Ricky_coord.ra.deg) * np.cos(coord.dec.rad) * 3E6 #print 'new - ricky (d):', (c1.dec.deg[0] - Ricky_coord.dec.deg)*3E6 from skyfield.api import load, Star, Angle lens = Star(ra=Angle(degrees=coord.ra.deg), dec=Angle(degrees=coord.dec.deg), ra_mas_per_year=pmra * 1000., dec_mas_per_year=pmdec * 1000., parallax_mas=plx * 1000.) ts = load.timescale() ts1 = ts.utc(t.jyear[0] - 15.) planets = load('de421.bsp') earth = planets['earth'] astrometric = earth.at(ts1).observe(lens) rai, deci, distancesa = astrometric.radec() skyfield_coord = SkyCoord(ra=rai._degrees, dec=deci._degrees, unit='deg', frame='icrs') #print 'skyfield - ricky:', skyfield_coord.separation(Ricky_coord).arcsec * 1000. #print 'skyfield - new:', skyfield_coord.separation(c1[0]).arcsec * 1000.
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()) print(distance)
import numpy as np ts = load.timescale() t = ts.utc(2022, 1, 1) eph = load('../../de421.bsp') sun = eph['sun'] earth = eph['earth'] df = pd.read_csv('bs_hip_all_selected cols.csv').set_index('hip') df = df.loc[orion_stars] ra = Angle(degrees=df['ra'].values) dec = Angle(degrees=df['dec'].values) stars = Star(ra=ra, dec=dec) star_positions = earth.at(t).observe(stars) #======================================== import matplotlib.pyplot as plt from matplotlib.collections import LineCollection from hypatie.plots import plot_radec, plot_altaz from hypatie.transform import radec_to_altaz from hypatie.data import cities lon, lat = cities['strasbourg'][:2] marker_size = (0.5 + 7 - df['Vmag'].values)**2.0
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
earth = ephem['earth'] sun = ephem['sun'] moon = ephem['moon'] mars = ephem['mars barycenter'] venus = ephem['venus'] plain_greenwich = Topos(latitude='51.5 N', longitude='0 W') greenwich = earth + plain_greenwich iss_tle = """\ 1 25544U 98067A 18161.85073725 .00003008 00000-0 52601-4 0 9993 2 25544 51.6418 50.3007 0003338 171.6979 280.7366 15.54163173117534 """ ISS = EarthSatellite(*iss_tle.splitlines()) sirius = Star(ra_hours=(6, 45, 8.91728), dec_degrees=(-16, 42, 58.0171)) minute = 1 / 24 / 60 sec = minute / 60 ms = sec / 1000 def compare(value, expected_value, epsilon): if hasattr(value, '__len__') or hasattr(expected_value, '__len__'): assert max(abs(value - expected_value)) <= epsilon else: assert abs(value - expected_value) <= epsilon def is_root(f, times, target_f, epsilon): left_times = times - epsilon
while True: #check if rotor is moving print Rotor.isMoving() if Rotor.isMoving(): print "Rotor moving, sleeping" time.sleep(5) else: print "Rotor stopped, calculating" alt, az, dist = Tracker.calcAltAz() Rotor.move(alt.degrees, az.degrees) #setup location planets = load('de421.bsp') earth = planets['earth'] location = earth + Topos('36.31205 N', '81.35347 W') #setup test target #barnard = Star(ra_hours=(17,57,48.49803), dec_degrees(4,41,36.2072)) testTarget = Star(ra_hours=(22, 57, 39.52), dec_degrees=(-29, 37, 24)) Tracker = Tracking(testTarget, location) Tracker.calcAltAz() Rotor = RotorController() Rotor.connect("/dev/ttyACM0") Rotor.move(0, 0) __start()
def predict(self, mjd, complain=True, n=20000): """Predict the object position at a given MJD. The return value is a tuple ``(ra, dec, major, minor, pa)``, all in radians. These are the predicted position of the object and its uncertainty at *mjd*. If *complain* is True, print out warnings for incomplete information. *n* is the number of Monte Carlo samples to draw for computing the positional uncertainty. The uncertainty ellipse parameters are sigmas, not FWHM. These may be converted with the :data:`S2F` constant. This function relies on the external :mod:`skyfield` package. """ import sys from skyfield.api import Star from . import ellipses self.verify(complain=complain) planets, ts = load_skyfield_data( ) # might download stuff from the internet earth = planets['earth'] t = ts.tdb(jd=mjd + 2400000.5) # "Best" position. args = { 'ra_hours': self.ra * R2H, 'dec_degrees': self.dec * R2D, } if self.pos_epoch is not None and self.pos_epoch != 51544.5: print_('AstrometryInfo.predict(): ignoring epoch of position!', file=sys.stderr) ### o.promoepoch = self.pos_epoch + 2400000.5 ###else: ### if complain: ### print_ ('AstrometryInfo.predict(): assuming epoch of position is J2000.0', file=sys.stderr) ### o.promoepoch = 2451545.0 # J2000.0 if self.promo_ra is not None: args['ra_mas_per_year'] = self.promo_ra args['dec_mas_per_year'] = self.promo_dec if self.parallax is not None: args['parallax_mas'] = self.parallax if self.vradial is not None: args['radial_km_per_s'] = self.vradial bestra, bestdec, _ = earth.at(t).observe(Star(**args)).radec() bestra = bestra.radians bestdec = bestdec.radians # Monte Carlo to get an uncertainty. As always, astronomy position # angle convention requires that we treat declination as X and RA as # Y. First, we check sanity and generate randomized parameters: if self.pos_u_maj is None and self.promo_u_maj is None and self.u_parallax is None: if complain: print_( 'AstrometryInfo.predict(): no uncertainties ' 'available; cannot Monte Carlo!', file=sys.stderr) return (bestra, bestdec, 0., 0., 0.) if self.pos_u_maj is not None: sd, sr, cdr = ellipses.ellbiv(self.pos_u_maj, self.pos_u_min, self.pos_u_pa) decs, ras = ellipses.bivrandom(self.dec, self.ra, sd, sr, cdr, n).T else: ras = np.zeros(n) + self.ra decs = np.zeros(n) + self.dec if self.promo_ra is None: pmras = np.zeros(n) pmdecs = np.zeros(n) elif self.promo_u_maj is not None: sd, sr, cdr = ellipses.ellbiv(self.promo_u_maj, self.promo_u_min, self.promo_u_pa) pmdecs, pmras = ellipses.bivrandom(self.promo_dec, self.promo_ra, sd, sr, cdr, n).T else: pmras = np.zeros(n) + self.promo_ra pmdecs = np.zeros(n) + self.promo_dec if self.parallax is None: parallaxes = np.zeros(n) elif self.u_parallax is not None: parallaxes = np.random.normal(self.parallax, self.u_parallax, n) else: parallaxes = np.zeros(n) + self.parallax if self.vradial is None: vradials = np.zeros(n) elif self.u_vradial is not None: vradials = np.random.normal(self.vradial, self.u_vradial, n) else: vradials = np.zeros(n) + self.vradial # Now we compute the positions and summarize as an ellipse: results = np.empty((n, 2)) for i in range(n): args['ra_hours'] = ras[i] * R2H args['dec_degrees'] = decs[i] * R2D args['ra_mas_per_year'] = pmras[i] args['dec_mas_per_year'] = pmdecs[i] args['parallax_mas'] = parallaxes[i] args['radial_km_per_s'] = vradials[i] ara, adec, _ = earth.at(t).observe(Star(**args)).radec() results[i] = adec.radians, ara.radians maj, min, pa = ellipses.bivell(*ellipses.databiv(results)) # All done. return bestra, bestdec, maj, min, pa