def convertToAngle(value, isHours=None): """ convertToAngle ties to take any value and converts is to the right form in skyfield angles. if the value is a string, we convert it to float value. in case of isHours, we should have already a string, which represents hours inside. if the value is float and we expect to have hours, the float value is normally given in degrees, so we have to calculate the numbers in hours. :param value: :param isHours: :return: angle as skyfield angle """ if isinstance(value, str): value = stringToDegree(value) if value is None: return None else: if isHours: value *= 24 / 360 if isHours: angle = Angle(hours=value) else: angle = Angle(degrees=value) return angle
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 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 test_J2000T0JNow_2(): class Test: tt = 2458687 ut1 = 1 ra, dec = transform.J2000ToJNow(Angle(hours=12), Angle(degrees=180), Test()) assert ra.hours != 0 assert dec.degrees != 0
def test_J2000T0AltAz_2(): class Test: tt = 2458849.50000 ut1 = 0.5 loc = Topos('42.3583 N', '71.0636 W') alt, az = transform.J2000ToAltAz(Angle(hours=12), Angle(degrees=45), Test(), loc) assert alt.degrees != 0 assert az.degrees != 0
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 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 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 test_solveDone_2(qtbot): result = { 'success': False, 'raJ2000S': Angle(hours=10), 'decJ2000S': Angle(degrees=20), 'angleS': 30, 'scaleS': 1, 'errorRMS_S': 3, 'flippedS': False, 'imagePath': 'test', 'message': 'test', } app.astrometry.signals.done.connect(app.uiWindows['showImageW']['classObj'].solveDone) with qtbot.waitSignal(app.message) as blocker: suc = app.uiWindows['showImageW']['classObj'].solveDone(result=result) assert not suc assert ['Solving error: test', 2] == blocker.args
def get_alt_azimuth(self, calc_time, satellite_name): try: satellite_number = self.satellites[satellite_name]['Number'] satellite = self.by_number[int(satellite_number)] except ValueError: return Angle(degrees=0), Angle(degrees=0), 0 difference = satellite - home topocentric = difference.at(ts.tt_jd(calc_time)) pos = topocentric.position.km alt, az, distance = topocentric.altaz() velocity = topocentric.velocity.km_per_s d = np.dot(velocity, pos) / np.linalg.norm( pos) # slant velocity km/sec return alt, az, d
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 moon_phases(moon, t0, t1): """Calculates times of the phases of the moon. This function searches between ``t0`` and ``t1`` for times when the moon's geocentric ecliptic longitude minus that of the sun is: * 0 degrees for new moon * 90 degrees for first quarter * 180 degrees for full moon * 270 degrees for last quarter Example ------- >>> ephem = load('de430t.bsp') >>> moon = ephem['moon'] >>> t0 = ts.utc(2017, 1) >>> t1 = ts.utc(2017, 2) >>> times, lon_diffs = moon_phases(moon, t0, t1) >>> >>> new_moons = times[lon_diffs.degrees==0] >>> first_quarters = times[lon_diffs.degrees==90] >>> full_moons = times[lon_diffs.degrees==180] >>> last_quarters = times[lon_diffs.degrees==270] Parameters ---------- moon : Segment Vector representing the moon t0 : Time Time object of length 1 representing the start of the search interval t1 : Time Time object of length 1 representing the end of the search interval Returns ------- times : Time Times of moon quarters longitude_diffs: Angle moon's ecliptic longitude - sun's ecliptic longitude at ``times`` """ earth = moon.ephemeris['earth'] sun = moon.ephemeris['sun'] f = partial(_ecliptic_lon_diff, earth, moon, sun) partition_edges = _divide_evenly(t0.tt, t1.tt, 29 * .2) jd0, jd1, targets, f0, f1, _ = _find_value(f, [0, 90, 180, 270], partition_edges, slope='positive') times = secant(f, jd0, jd1, targets, f0, f1) return ts.tt(jd=times), Angle(degrees=targets)
def meridian_transits(observer, body, t0, t1): """Calculates times of upper and lower transits of the local meridian. This function searches between ``t0`` and ``t1`` for times when ``body``'s local hour angle is 0h for an upper transit or 12h for a lower transit. Example ------- >>> ephem = load('de430t.bsp') >>> sun = ephem['sun'] >>> earth = ephem['earth'] >>> greenwich = earth + Topos('51.5 N', '0 W') >>> t0 = ts.utc(2017, 1, 1) >>> t1 = ts.utc(2017, 1, 8) >>> times, hour_angles = meridian_transits(greenwich, mars, t0, t1) >>> >>> upper_transits = times[hour_angles.hours==0] >>> lower_transits = times[hour_angles.hours==12] Parameters ---------- observer : VectorSum VectorSum of earth + Topos body : Segment or VectorSum Vector representing the object whose transits are being found. t0 : Time Time object of length 1 representing the start of the search interval t1 : Time Time object of length 1 representing the end of the search interval Returns ------- times : Time Times of transits hour_angles : Angle Local Hour Angle of ``body`` at ``times`` """ if isinstance(observer, Topos): raise ValueError('`observer` should be a VectorSum of earth + Topos.') if isinstance(body, EarthSatellite) or ( isinstance(body, VectorSum) and isinstance(body.positives[-1], EarthSatellite)): raise ValueError("meridian_transits doesn't support EarthSatellites.") f = partial(_lha, observer, body) partition_edges = _divide_evenly(t0.tt, t1.tt, .2) jd0, jd1, targets, f0, f1, _ = _find_value(f, [0, 180], partition_edges, slope='positive') times = secant(f, jd0, jd1, targets, f0, f1) return ts.tt(jd=times), Angle(degrees=targets, preference='hours')
def max_ecliptic_latitudes(secondary, primary, t0, t1): """Calculates data about extreme max and min ecliptic latitudes. This function searches between ``t0`` and ``t1`` for times when `secondary`'s ecliptic latitude centered at ``primary`` is at a local maximum, e.g., if ``primary`` is the sun, the ecliptic latitudes will be heliocentric. Example ------- >>> ephem = load('de430t.bsp') >>> venus = ephem['venus'] >>> sun = ephem['sun'] >>> t0 = ts.utc(2017) >>> t1 = ts.utc(2020) >>> times, lats = extreme_ecliptic_latitudes(venus, sun, t0, t1) >>> north_times = times[lats>0] >>> south_times = times[lats<0] Parameters ---------- secondary : Segment or VectorSum Vector representing the object whose maximum ecliptic latitudes are being found primary : Segment or VectorSum Vector representing the object orbited by `secondary` t0 : Time The start of the time range to search t1 : Time The end of the time range to search Returns ------- times : Time Times of extreme ecliptic latitudes lats : Angle Ecliptic latitudes that correspond to `times` """ period = _sidereal_period(secondary, primary) partition_edges = _divide_evenly(t0.tt, t1.tt, period * .2) f = partial(_ecliptic_lat, secondary, primary) jd0, jd1, minimum, f0, f1 = _find_extremes(f, partition_edges, find='any') if len(jd0) != 0: times = brent_min(f, jd0, jd1, minimum, f0, f1, tol=1e-15) else: times = array([]) # TODO: Should brent_min retur f(x) to avoid this function call? lats = f(times) return ts.tt(jd=times), Angle(degrees=lats)
def test_solveDone_4(qtbot): app.uiWindows['showImageW']['classObj'].ui.checkAutoSolve.setChecked(True) app.uiWindows['showImageW']['classObj'].ui.checkStackImages.setChecked(False) result = { 'success': True, 'raJ2000S': Angle(hours=10), 'decJ2000S': Angle(degrees=20), 'angleS': 30, 'scaleS': 1, 'errorRMS_S': 3, 'flippedS': False, 'imagePath': 'test', 'solvedPath': 'test', 'message': 'test', } app.astrometry.signals.done.connect(app.uiWindows['showImageW']['classObj'].solveDone) with qtbot.waitSignal(app.uiWindows['showImageW']['classObj'].signals.showImage): suc = app.uiWindows['showImageW']['classObj'].solveDone(result=result) assert suc
def seasons(earth, t0, t1): """Calculates times of equinoxes and solstices. This function searches between ``t0`` and ``t1`` for times when the sun's ecliptic longitude is: * 0 degrees for march equinoxes * 90 degrees for june solstices * 180 degrees for september equinoxes * 270 degrees for december solstices Example ------- >>> ephem = load('de430t.bsp') >>> earth = ephem['earth'] >>> t0 = ts.utc(2017) >>> t1 = ts.utc(2018) >>> times, lons = seasons(earth, t0, t1) >>> >>> march_equinoxes = times[lons.degrees==0] >>> june_solstices = times[lons.degrees==90] >>> sept_equinoxes = times[lons.degrees==180] >>> dec_solstices = times[lons.degrees==270] Parameters ---------- earth : Segment Vector representing earth t0 : Time Time object of length 1 representing the start of the search interval t1 : Time Time object of length 1 representing the end of the search interval Returns ------- times : Time Times of solstices longitudes : Angle sun's ecliptic longitude at ``times`` """ sun = earth.ephemeris['sun'] f = partial(_ecliptic_lon, earth, sun) partition_edges = _divide_evenly(t0.tt, t1.tt, 365 * .2) jd0, jd1, targets, f0, f1, _ = _find_value(f, [0, 90, 180, 270], partition_edges, slope='positive') times = secant(f, jd0, jd1, targets, f0, f1) return ts.tt(jd=times), Angle(degrees=targets)
def JNowToJ2000(ra, dec, timeJD): """ :param ra: :param dec: :param timeJD: :return: """ if not isinstance(ra, Angle): return Angle(hours=0), Angle(degrees=0) if not isinstance(dec, Angle): return Angle(hours=0), Angle(degrees=0) with _lock: ra = ra.radians dec = dec.radians ra = ERFA.anp(ra + ERFA.eo06a(timeJD.tt, 0.0)) raConv, decConv, _ = ERFA.atic13(ra, dec, timeJD.ut1, 0.0) ra = Angle(radians=raConv, preference='hours') dec = Angle(radians=decConv, preference='degrees') return ra, dec
def convertToHMS(ra): """ takes the given RA value, which should be in HMS format (but different types) and convert it to solve-field readable string in HH:MM:SS :param ra: right ascension as Angle :return: converted value as string """ if isinstance(ra, (float, int)): ra = Angle(hours=ra) if isinstance(ra, str): return '' t = Angle.signed_hms(ra) value = f'{t[1]:02.0f}:{t[2]:02.0f}:{t[3]:02.0f}' return value
def convertToDMS(dec): """ takes the given DEC value, which should be in DMS format (but different types) and convert it to solve-field readable string in sDD:MM:SS :param dec: declination as Angle :return: converted value as string """ if isinstance(dec, (float, int)): dec = Angle(degrees=dec) if isinstance(dec, str): return '' t = Angle.signed_dms(dec) sign = '+' if dec.degrees > 0 else '-' value = f'{sign}{t[1]:02.0f}:{t[2]:02.0f}:{t[3]:02.0f}' return value
def J2000ToAltAz(ra, dec, timeJD, location): """ :param ra: :param dec: :param timeJD: :param location: :return: """ if not isinstance(ra, Angle): return Angle(degrees=0), Angle(degrees=0) if not isinstance(dec, Angle): return Angle(degrees=0), Angle(degrees=0) with _lock: ra = ra.radians dec = dec.radians lat = location.latitude.radians lon = location.longitude.radians elevation = location.elevation.m aob, zob, hob, dob, rob, eo = ERFA.atco13(ra, dec, 0.0, 0.0, 0.0, 0.0, timeJD.ut1, 0.0, 0, lon, lat, elevation, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) decConv = np.pi / 2 - zob ra = Angle(radians=aob, preference='degrees') dec = Angle(radians=decConv, preference='degrees') return ra, dec
def J2000ToJNow(ra, dec, timeJD): """ :param ra: :param dec: :param timeJD: :return: """ if not isinstance(ra, Angle): return Angle(hours=0), Angle(degrees=0) if not isinstance(dec, Angle): return Angle(hours=0), Angle(degrees=0) with _lock: ra = ra.radians dec = dec.radians raConv, decConv, eo = ERFA.atci13(ra, dec, 0, 0, 0, 0, timeJD.ut1, 0) raConv = ERFA.anp(raConv - eo) ra = Angle(radians=raConv, preference='hours') dec = Angle(radians=decConv, preference='degrees') return ra, dec
def test_convertToHMS_2(): value = Angle(hours=-12.0) value = transform.convertToHMS(value) assert value == '12:00:00'
def test_convertToHMS_1(): parameter = Angle(hours=12) value = transform.convertToHMS(parameter) assert value == '12:00:00'
def test_position_angle(): a = Angle(degrees=0), Angle(degrees=0) b = Angle(degrees=1), Angle(degrees=1) assert str(position_angle_of(a, b)) == '315deg 00\' 15.7"'
def test_convertToDMS_1(): parameter = Angle(degrees=60) value = transform.convertToDMS(parameter) assert value == '+60:00:00'
def make_chart_shift(self, ra, de, pmra, pmde, name, outdir='findercharts_2/'): # make the chart with the 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_1989 = self.earth.at(self.t_1989).observe(star_obj) ra_out, dec_out, dist_out = astrometric.radec() ra_out1, dec_out1, dist_out1 = astrometric_1989.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_new, ra_old] #[ra_old,ra_new] deline = [de_new, de_old] #[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') if isfinite(pmra): #print 'pm finite' if max(abs(pmra), abs(pmde)) > 1000: fovrad = astropy.coordinates.Angle('0d8m0s') if max(abs(pmra), abs(pmde)) > 4000: print 'big radius' fovrad = astropy.coordinates.Angle('0d16m0s') oo, oh = astroplan.plots.plot_finder_image(cc_new, reticle=True, survey='DSS2 Red', fov_radius=fovrad) 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) #oo.text(0,-.2,'FOV radius: {}'.format(fovrad.arcsec) fig.savefig(outdir + name + '.pdf') close(fig) return cc_new
from skyfield.api import Star, load, Angle import pandas as pd 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]
def test_convertToDMS_2(): value = Angle(degrees=-90.0) value = transform.convertToDMS(value) assert value == '-90:00:00'
#t = Time(2019.9, format='jyear') 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.
class Test: jdStart = 2458715.14771 jdEnd = 2458715.15 flip = False message = 'test' altitude = Angle(degrees=50)